How to Set Up Dev Containers in VS Code with Docker: Standardizing a Consistent Development Environment for Your Entire Team

Context & Why It Matters

If you have ever collaborated on a software project, you are probably familiar with this scenario: a feature runs smoothly on developer A’s machine, but the moment developer B or a tester tries it, errors blow up everywhere. The classic response is always: “That’s weird, it works on my machine!”

Think of each personal computer as a unique kitchen. One person uses gas, another uses induction; one prefers German knives, another uses cast iron skillets. Even with the exact same recipe, the finished dish can turn out burnt or taste completely different depending on the tools used. Software development works the same way. Differences between macOS, Windows, and Linux, or minor patch differences in Python (such as 3.11.2 vs. 3.11.6) and underlying C-binding libraries, can easily break an application.

For complex projects, onboarding a new team member and setting up their environment often burns one to two full working days. Worse yet, when urgent bug fixes come up for legacy repositories running Node 14 or Python 3.8, you find yourself scrambling to uninstall or downgrade your current runtime. The risk of dependency conflicts on your host machine is huge.

Dev Containers (Development Containers) solve this problem once and for all. The entire runtime, package manager, and CLI tools are neatly packaged inside an isolated Docker container. VS Code running on your host machine attaches directly inside that container. The real-world impact? Onboarding time for new team members drops from two days to just ten minutes. A new developer simply clones the repository, opens it, and everything is instantly ready to code.

Prerequisites & Installation

Before configuring Dev Containers, ensure your machine has these two foundational tools installed:

1. Docker Desktop (on Windows/macOS) or Docker Engine (on Linux). Ensure the Docker daemon process is up and running.
2. The latest version of Visual Studio Code.

Next, open VS Code and switch to the Extensions view (Ctrl + Shift + X on Windows/Linux or Cmd + Shift + X on macOS). Search for Microsoft’s Dev Containers extension (ID: ms-vscode-remote.remote-containers) and click Install.

Open your local terminal and run the following commands to confirm Docker is responding properly:

docker --version
docker ps

If the terminal prints out the version and an empty container table without permission errors, you are ready to proceed.

Detailed Configuration

All Dev Containers configuration lives inside the .devcontainer/ directory at your project root, containing a devcontainer.json file:

my-project/
├── .devcontainer/
│   └── devcontainer.json
├── src/
│   └── app.py
└── README.md

The devcontainer.json file acts as the technical specification: which base image the container runs, what VS Code extensions come pre-installed, how ports are forwarded, and which setup scripts execute during provisioning.

Configuration Template for a Python Project

{
  "name": "Python 3.11 Workspace",
  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bullseye",
  "customizations": {
    "vscode": {
      "settings": {
        "python.defaultInterpreterPath": "/usr/local/bin/python"
      },
      "extensions": [
        "ms-python.python",
        "ms-python.black-formatter",
        "njpwerner.autodocstring"
      ]
    }
  },
  "forwardPorts": [8000],
  "postCreateCommand": "pip install --upgrade pip && if [ -f requirements.txt ]; then pip install -r requirements.txt; fi",
  "remoteUser": "vscode"
}

Key Configuration Parameters Explained

• image: The base image for the container. Here, every team member develops on an identical Debian Linux environment preconfigured with Python 3.11.
• customizations.vscode.extensions: VS Code extensions automatically installed inside the container. The entire team shares the same code formatting standards (such as Black) without anyone needing to install them manually.
• forwardPorts: Network ports exposed to the host machine. For example, when running a FastAPI backend on port 8000, navigating to http://localhost:8000 in your host browser displays the output.
• postCreateCommand: A command string that runs once right after the container is successfully created. This is typically used to install all dependencies from requirements.txt.

Activating the Dev Container Environment

After saving your configuration file, press F1 (or Ctrl + Shift + P / Cmd + Shift + P), then search for and select:

Dev Containers: Reopen in Container

VS Code will pull the image, build the container, and mount your workspace directory inside it. Looking at the bottom-left corner of the window, you will see the status icon turn green, displaying Dev Container: Python 3.11 Workspace. From this point on, every terminal command inside VS Code runs directly within the Linux container.

Verification & Monitoring

Once the container is up and running, verify the environment. Open the integrated terminal in VS Code (Ctrl + `) and run the following commands:

# Check OS kernel details
uname -a

# Check Python version
python --version

# Verify binary path
which python

The output will display the exact Linux information and Python 3.11 runtime. Whether your host machine runs Apple Silicon M-series chips or Windows 11 x86_64, your code runs on the exact same runtime environment.

Resource Monitoring and Cleanup

Running containers introduces additional RAM and CPU usage. When working with multiple projects simultaneously, it is wise to keep an eye on resource consumption.

Open a terminal window on your host machine and run:

docker stats

The dashboard continuously streams CPU and memory usage (a typical lightweight Python workspace usually consumes around 300MB to 800MB of RAM).

If you update devcontainer.json (such as adding ports or extensions), there is no need to rebuild manually from scratch. Simply press F1 and select Dev Containers: Rebuild Container. Your local source code remains completely intact.

At the end of the workday, when you want to stop the container and free up system resources, press F1 and choose Dev Containers: Reopen Folder Locally. The container automatically stops, cleanly returning allocated memory back to the host operating system.