Why are folks creating inside containers?

9 years in the past, in March 2013, Solomon Hykes and his cofounders revolutionized how we do software program growth with an open supply platform referred to as Docker. Though the creators of Docker did not invent containers, they popularized them. Because of Docker, engineers can create instruments, like GitHub Codespaces, that allow us to code in a growth container hosted within the cloud.

I’ll admit that once I first heard about growth containers, I had two questions:

• Why are folks creating inside containers?
• What are containers?

When you’ve got related questions, this publish is for you.

On this weblog publish, I am going to clarify what containers are, how they profit engineers, and the way GitHub Codespaces use containers.

What does it imply to develop inside a container?

Elevate your hand for those who’ve ever uttered the phrases, “It really works on my machine.” (Don’t fear; you are not alone)!

When you’re not conversant in this phrase, it is a meme, however it’s additionally an actual phrase builders discover themselves saying in the event that they work in a codebase the place the environments fluctuate. Though working in various environments will not be excellent, it does occur. From my expertise, conditions like this happen when my native surroundings, my coworkers’ native environments, staging, and manufacturing all have slight variations. As a result of the environments had barely totally different configurations, bugs existed in a single surroundings however didn’t exist within the different surroundings. It may really feel so embarrassing and irritating to construct a function or repair a bug that works regionally however would not work in manufacturing or staging.

Nevertheless, containers remedy the problem of inconsistent developer environments. Containers allow software program engineers to program in a constant surroundings. Now, your coding surroundings can mirror manufacturing through the use of the identical working system, configurations, and dependencies. This ensures bugs and options behave the identical throughout all environments relieving builders from the embarrassment of claiming, “It really works on my machine.”

Now that we perceive the aim of containers, let’s discover how Codespaces leverages containers.

GitHub Codespaces takes software program and cloud growth to the subsequent degree

GitHub Codespaces permits you to code in a container hosted within the cloud. On this context, the cloud is an surroundings that does not reside in your laptop however quite on the web.

Sooner onboarding

Usually, software program engineers are liable for establishing their native surroundings once they be part of a crew. Native surroundings setup contains putting in the required dependencies, linters, surroundings variables, and extra. Builders might spend as much as per week configuring their surroundings, relying on the standard of the documentation. Once I was purely a software program engineer, it took me about 2 days to arrange my surroundings, and the expertise was painful as a result of I wished to start out coding instantly. As an alternative, I needed to seed my database and edit my .zshrc file.

Thankfully, organizations can automate the onboarding course of utilizing GitHub Codespaces to configure a customized surroundings. When a brand new engineer joins the crew, they will open a codespace and skip the native surroundings setup as a result of the required extensions, dependencies, and surroundings variables exist inside the codespace.

Code from anyplace

With Codespaces, I can code anyplace that I’ve web entry. If I swap units or overlook my laptop computer at residence, I can simply resume my work on an iPad whereas I’m on the airplane with out cloning a repository, downloading my most well-liked IDE, and establishing a neighborhood surroundings. That is potential as a result of Codespaces opens a Visible Studio Code-like editor contained in the browser. One of the best half is Codespaces can autosave my code even when I overlook to push my modifications to my repository.

Constant environments

As talked about within the paragraphs above, containers help you work in a mirrored manufacturing surroundings. As a result of GitHub Codespaces makes use of containers, you will get the identical outcomes and developer expertise in your native surroundings as you’ll in your manufacturing surroundings.

Moreover, typically when modifications occur to the codebase, resembling infrastructure enhancements, native environments can break. When native environments break, it’s as much as the developer to revive their developer surroundings. Nevertheless, GitHub Codespaces’ use of containers brings uniformity to developer environments and reduces the probabilities of working in a damaged surroundings.

Three information chances are you’ll have to configure a Codespace

You possibly can leverage three information to make the Codespaces expertise works for you and your teammates: the devcontainer.json file, the Dockerfile, and the docker-compose.yml file. Every of those information lives within the .devcontainer listing on the root of your repository.

The devcontainer.json file

The devcontainer.json file is a configuration file that tells GitHub Codespaces tips on how to configure a codespace. Inside a devcontainer file, you’ll be able to configure the next:

• Extensions
• Atmosphere variables
• Dockerfile
• Port forwarding
• Put up-creation instructions
• And extra

Because of this everytime you or somebody opens a codepspace, the extensions, surroundings variables, and different configurations you specify within the devcontainer.json file will routinely set up once they open a codespace within the specified repository. For instance, if I wished people to have the identical linter and extensions as me, I might add the next to my devcontainer.json file:
devcontainer.json

 {
    "identify": "Node.js",
    "construct": {
        "dockerfile": "Dockerfile",
        // Replace 'VARIANT' to choose a Node model: 18, 16, 14.
        // Append -bullseye or -buster to pin to an OS model.
        // Use -bullseye variants on native arm64/Apple Silicon.
        "args": { "VARIANT": "16-bullseye" }
    },

    // Configure tool-specific properties.
    "customizations": {
        // Configure properties particular to VS Code.
        "vscode": {
            // Add the IDs of extensions you need put in when the container is created.
            "extensions": [
                "dbaeumer.vscode-eslint", // this is the exentension id for eslint
                "esbenp.prettier-vscode", // this is the extension id for prettier
                "ms-vsliveshare.vsliveshare", // this is the extension id for live share
            ]
        }
    },

    // Use 'forwardPorts' to make a listing of ports inside the container obtainable regionally.
    // "forwardPorts": [],

    // Use 'postCreateCommand' to run instructions after the container is created.
    // "postCreateCommand": "yarn set up",

    // Remark out to join as root as an alternative. Extra data: https://aka.ms/vscode-remote/containers/non-root.
    "remoteUser": "node"
}

You possibly can be taught extra concerning the devcontainer.json file right here.

The Dockerfile

The Dockerfile is a configuration file that tells GitHub Codespaces tips on how to construct a container. It accommodates an inventory of instructions that the Docker consumer calls whereas creating a picture. Dockerfiles are used to automate the set up and configuration of a container. For instance, if I wished to put in Node.js in a container, I might add the next to my Dockerfile:
Dockerfile

FROM node:16-bullseye

You possibly can be taught extra about Dockerfiles right here, and you’ll be taught extra about establishing a node.js in Codespaces right here.

The docker-compose.yml file

You do not want a docker-compose.yml file in a Codespace, however it’s helpful if you wish to run a number of containers. For instance, if you wish to run a database and an online server in a Codespace, you should utilize the docker-compose.yml file to run each containers. You possibly can be taught extra about docker-compose.yml information right here. This is an instance of what a docker-compose.yml file that is connecting to a database would possibly appear to be:
docker-compose.yml

model: '3.8'

providers:
  app:
    construct:
      context: ..
      dockerfile: .devcontainer/Dockerfile
      args:
        VARIANT: "3"
        NODE_VERSION: "none"

    volumes:
      - ..:/workspace:cached

    command: sleep infinity

    network_mode: service:db

  db:
    picture: postgres:newest
    restart: unless-stopped
    volumes:
      - postgres-data:/var/lib/postgresql/knowledge
    hostname: postgres
    surroundings:
      POSTGRES_DB: my_media
      POSTGRES_USER: instance
      POSTGRES_PASSWORD: move
      POSTGRES_HOST_AUTH_METHOD: belief
    ports:
      - 5432:5432

volumes:
  postgres-data: null

Codespaces will not be the identical as GitHub’s internet editor

GitHub Codespaces will not be the identical as GitHub’s internet editor. The online editor is the editor that seems once you press “.” in a repository. It’s a light-weight editor that permits you to edit information in your repository. The online editor is nice for making minor modifications to a file, however it’s not excellent for writing code. Nevertheless, Codespaces permits you to run a full-fledged IDE within the browser outfitted with a terminal and extra.

P.S. I wrote this weblog publish with Copilot. 😉 (These are all my very own phrases, ideas, and frustrations, however Copilot helped unblock me once I couldn’t discover the proper phrases or motivation.)

There’s a lot to find out about GitHub Codespaces. Remark beneath when you’ve got any subjects relating to GitHub Codespaces you need me to cowl in future posts. Observe (me)[https://dev.to/blackgirlbytes] and GitHub on DEV if you wish to see extra content material like this. Thanks for studying! 🙏🏿