Jalankan Dev Environment Lokal dengan Devcontainer

by Marcus Chen
Jalankan Dev Environment Lokal dengan Devcontainer

Kamu pasti pernah ngalamin ini: laptop baru, clone repo lama, terus npm install atau pip install error karena versi Node atau Python-nya beda. Atau lebih parah — di mesin kamu jalan, di mesin teman kamu nggak. Klasik.

Masalahnya bukan di kode. Masalahnya di environment. Dan solusi paling pragmatis yang gue temukan setelah nyoba berbagai pendekatan (Vagrant, nix-shell, manual Dockerfile) adalah devcontainer.

Devcontainer adalah spec dari VS Code (sekarang juga didukung tools lain seperti Neovim dan JetBrains) yang mendefinisikan dev environment kamu dalam sebuah container Docker. Satu folder .devcontainer/, semua orang yang clone repo kamu langsung dapat environment yang sama persis.


Kenapa Bukan Cukup Docker Compose Biasa?

Pertanyaan bagus. Gue juga awalnya pakai Docker Compose buat isolasi service — database, Redis, queue worker — tapi tetap install tools di host machine. Hasilnya? Host machine gue jadi graveyard berbagai versi Python, Node, dan Go yang saling konflik.

Devcontainer beda karena kamu kerja di dalam container itu sendiri. Editor kamu (VS Code) attach ke container, terminal kamu ada di dalam container, extension kamu jalan di dalam container. Host machine kamu cuma jadi host buat Docker daemon.

Beberapa keuntungan konkret:

  • Onboarding tim baru: clone → buka VS Code → tunggu container build → langsung kerja
  • Nggak ada lagi "works on my machine" karena semua pakai image yang sama
  • Mau ganti laptop? Backup dotfiles, install Docker dan VS Code, selesai
  • Bisa punya beberapa project dengan versi Node/Python berbeda tanpa konflik

Setup Devcontainer dari Nol

Gue akan pakai contoh project Python FastAPI karena ini setup yang sering gue pakai.

Struktur folder

my-api/
├── .devcontainer/
│   ├── devcontainer.json
│   └── docker-compose.yml
├── app/
│   └── main.py
└── requirements.txt

File devcontainer.json

Ini adalah file utama yang mendefinisikan environment kamu.

{
  "name": "FastAPI Dev",
  "dockerComposeFile": "docker-compose.yml",
  "service": "app",
  "workspaceFolder": "/workspace",
  "features": {
    "ghcr.io/devcontainers/features/python:1": {
      "version": "3.11"
    },
    "ghcr.io/devcontainers/features/git:1": {}
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-python.python",
        "ms-python.black-formatter",
        "charliermarsh.ruff"
      ],
      "settings": {
        "python.defaultInterpreterPath": "/usr/local/bin/python",
        "editor.formatOnSave": true,
        "[python]": {
          "editor.defaultFormatter": "ms-python.black-formatter"
        }
      }
    }
  },
  "postCreateCommand": "pip install -r requirements.txt",
  "remoteUser": "vscode"
}

File docker-compose.yml

version: '3.8'

services:
  app:
    image: mcr.microsoft.com/devcontainers/python:3.11
    volumes:
      - ..:/workspace:cached
    command: sleep infinity
    environment:
      - PYTHONPATH=/workspace
    networks:
      - devnet

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: dev
      POSTGRES_DB: myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - devnet

  redis:
    image: redis:7-alpine
    networks:
      - devnet

volumes:
  postgres_data:

networks:
  devnet:

File app/main.py (buat testing)

from fastapi import FastAPI
import os

app = FastAPI()

@app.get("/")
def root():
    return {
        "message": "Hello from devcontainer",
        "python_path": os.environ.get("PYTHONPATH", "not set")
    }

@app.get("/health")
def health():
    return {"status": "ok"}

File requirements.txt

fastapi==0.110.0
uvicorn[standard]==0.29.0
psycopg2-binary==2.9.9
redis==5.0.4

Setelah semua file ada, buka folder project di VS Code. VS Code bakal detect .devcontainer/ dan muncul notifikasi "Reopen in Container". Klik itu, tunggu build pertama (biasanya 2-5 menit tergantung koneksi), dan kamu udah ada di dalam container.

Buat jalanin server:

uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

Buka browser ke http://localhost:8000 — port forwarding dari container ke host otomatis di-handle VS Code.


Gotcha yang Gue Hantam Sendiri

Beberapa hal yang bikin gue buang waktu pas pertama setup devcontainer:

1. Permission issue di Linux host

Kalau kamu pakai Linux (bukan Mac atau Windows), file yang dibuat di dalam container kadang punya ownership root atau UID yang berbeda. Solusinya: pastikan remoteUser di devcontainer.json diset ke vscode, dan pakai image base dari mcr.microsoft.com/devcontainers/ yang sudah handle ini.

Kalau masih bermasalah, tambahkan ini ke devcontainer.json:

"updateRemoteUserUID": true

2. Git credentials nggak ke-forward

Kamu git clone pakai SSH di host, tapi di dalam container SSH key-nya nggak ada. Solusi paling clean: tambahkan feature git credentials forwarding.

"features": {
  "ghcr.io/devcontainers/features/git:1": {},
  "ghcr.io/devcontainers/features/sshd:1": {}
}

Atau kalau kamu pakai SSH agent di host, VS Code otomatis forward SSH agent socket ke container — tapi ini cuma jalan kalau SSH agent kamu udah running di host sebelum buka container.

3. postCreateCommand gagal karena network

Kadang pip install di postCreateCommand gagal karena container belum fully connected ke network pas command itu dijalankan. Workaround: pindah ke postStartCommand atau tambahkan retry logic:

"postCreateCommand": "pip install -r requirements.txt || (sleep 5 && pip install -r requirements.txt)"

4. Volume mount lambat di Mac

Ini bukan bug, ini memang karakteristik Docker Desktop di Mac. Kalau project kamu besar, tambahkan :cached di volume mount (sudah ada di contoh di atas). Untuk project yang sangat besar, pertimbangkan pakai --mount type=volume dan sync file dengan tool seperti Mutagen — tapi itu topik tersendiri.


Tambahkan Database Migration Otomatis

Kalau project kamu pakai Alembic untuk database migration, kamu bisa otomatisasi ini di postCreateCommand supaya setiap kali container dibuat, database langsung siap:

"postCreateCommand": "pip install -r requirements.txt && sleep 3 && alembic upgrade head"

Sleep 3 detik itu buat nunggu PostgreSQL container fully ready. Cara yang lebih proper adalah pakai script dengan retry:

#!/bin/bash
# .devcontainer/scripts/setup.sh

set -e

echo "Installing dependencies..."
pip install -r requirements.txt

echo "Waiting for database..."
until python -c "import psycopg2; psycopg2.connect(host='db', dbname='myapp', user='dev', password='dev')" 2>/dev/null; do
  echo "Database not ready, retrying in 2s..."
  sleep 2
done

echo "Running migrations..."
alembic upgrade head

echo "Setup complete!"

Terus di devcontainer.json:

"postCreateCommand": "bash .devcontainer/scripts/setup.sh"

Pakai Devcontainer Tanpa VS Code

Kalau kamu lebih suka Neovim atau editor lain, ada CLI tool resmi yang bisa kamu pakai:

# Install devcontainer CLI
npm install -g @devcontainers/cli

# Build dan start container
devcontainer up --workspace-folder .

# Exec command di dalam container
devcontainer exec --workspace-folder . bash

# Atau langsung shell ke container
devcontainer exec --workspace-folder . /bin/bash

Dari sini kamu bisa attach Neovim atau editor apapun ke container dengan cara biasa (misalnya via SSH atau langsung docker exec).

Untuk Neovim users yang suka remote development, kombinasi devcontainer CLI + docker exec + Neovim dengan LSP yang diinstall di dalam container adalah setup yang solid.


Devcontainer di CI/CD

Bonus yang sering orang lupa: kamu bisa pakai devcontainer image yang sama di GitHub Actions. Ini artinya environment lokal dan CI kamu identik.

# .github/workflows/test.yml
name: Test

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/devcontainers/python:3.11
    
    services:
      db:
        image: postgres:15-alpine
        env:
          POSTGRES_USER: dev
          POSTGRES_PASSWORD: dev
          POSTGRES_DB: myapp
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Install dependencies
        run: pip install -r requirements.txt
      
      - name: Run tests
        run: pytest
        env:
          DATABASE_URL: postgresql://dev:dev@db/myapp

Dengan setup ini, kalau test-nya pass di lokal, hampir pasti pass di CI juga. Bukan karena magic, tapi karena environment-nya sama.


Yang Gue Lakuin Sekarang

Setup ini udah gue pakai di semua project baru sejak 8 bulan lalu. Beberapa hal yang langsung gue rasain:

Onboarding contributor baru ke project open source yang gue maintain turun dari "setengah hari setup" jadi "30 menit termasuk nunggu Docker build". Mereka tinggal clone, buka VS Code, tunggu, dan langsung bisa run test.

Ganti laptop bulan lalu jauh lebih smooth. Install Docker Desktop dan VS Code, clone semua repo, buka satu per satu, tunggu container build. Nggak ada brew install panjang, nggak ada konflik Python version, nggak ada "loh kok di sini error".

Eksperimen library baru jadi lebih berani. Mau coba library yang belum terbukti? Buat branch baru, install di container, kalau nggak cocok tinggal buang. Host machine tetap bersih.

Langkah lanjutan yang bisa kamu coba:

  • Explore devcontainer features — ada ratusan feature siap pakai untuk berbagai stack
  • Setup dotfiles sync supaya kamu punya shell config yang sama di semua container
  • Coba GitHub Codespaces kalau mau versi cloud-nya — pakai format devcontainer.json yang sama persis

Kalau kamu udah punya project yang sering di-clone orang lain, tambahkan .devcontainer/ sekarang. Kontributor berikutnya bakal berterima kasih.