Dev-Container in VS Code beherrschen

Erstellen Sie konsistente, portable und reproduzierbare Entwicklungsumgebungen mit Dev Containern

Inhaltsverzeichnis

Entwickler stehen häufig vor dem Dilemma „funktioniert auf meinem Rechner“, verursacht durch Abhängigkeitsinkongruenzen, Tool-Versionen oder Betriebssystemunterschiede. Dev Containers in Visual Studio Code (VS Code) lösen dies elegant – indem sie Ihnen ermöglichen, innerhalb einer containerisierten Umgebung zu entwickeln, die speziell für Ihr Projekt konfiguriert ist.

Moderne Softwareentwicklung erfordert konsistente, reproduzierbare Umgebungen, die auf verschiedenen Maschinen und Betriebssystemen funktionieren. Egal, ob Sie an einem Python-Datenwissenschaftsprojekt, einer Node.js-Webanwendung oder einem Go-Mikroservice arbeiten – sicherzustellen, dass jedes Teammitglied eine identische Entwicklungsumgebung hat, kann herausfordernd sein.

vs code dev containers

Dieser umfassende Leitfaden erklärt, was Dev Containers sind, warum sie wertvoll sind und wie Sie sie in VS Code für reibungslose, portable Entwicklungsworkflows einrichten. Sie lernen alles von der Grundeinrichtung bis zu fortgeschrittenen Konfigurationen mit Docker Compose und Best Practices für die Teamzusammenarbeit.

🧩 Was sind Dev Containers?

Dev Containers sind eine Funktion, die von der VS Code Remote - Containers-Erweiterung (jetzt Teil von VS Code Remote Development) bereitgestellt wird. Sie ermöglichen es Ihnen, Ihr Projekt in einem Docker-Container zu öffnen, der mit allen Ihren Abhängigkeiten, Sprachen und Tools vorkonfiguriert ist.

Stellen Sie sich das wie folgt vor:

“Eine vollständig konfigurierte Entwicklungsumgebung, definiert als Code.”

Anstatt Python, Node.js, Datenbanken und verschiedene Tools direkt auf Ihrem Rechner zu installieren, definieren Sie diese in Konfigurationsdateien. Wenn Sie das Projekt in VS Code öffnen, startet es automatisch einen Container mit allem vorinstalliert und genau wie angegeben konfiguriert.

Eine typische Dev-Container-Konfiguration umfasst:

  • Eine Dockerfile oder einen Verweis auf ein Basisimage (definiert das Container-Betriebssystem, Sprachen und Tools)
  • Eine devcontainer.json-Datei (konfiguriert Arbeitsbereichseinstellungen, VS Code-Erweiterungen, Portweiterleitung, Umgebungsvariablen und Startbefehle)
  • Optional docker-compose.yml, falls Ihr Projekt von mehreren Diensten abhängt (wie Datenbanken, Redis, Message Queues usw.)

⚙️ Warum Dev Containers verwenden?

Hier sind die Vorteile:

  • Reproduzierbarkeit: Jeder Entwickler und jedes CI-System verwendet dieselbe Umgebung. Keine „funktioniert auf meinem Rechner, aber nicht auf Ihrem“-Probleme mehr. Was auf Ihrem Laptop läuft, läuft identisch auf dem Windows-Rechner Ihres Kollegen, Mac oder Linux-Arbeitsplatz.

  • Isolation: Keine Notwendigkeit, Ihren lokalen Rechner mit widersprüchlichen Abhängigkeiten zu verschmutzen. Arbeiten Sie an mehreren Projekten, die unterschiedliche Versionen von Python, Node.js oder anderen Tools erfordern, ohne Versionenkonflikte oder virtuelle Umgebungen zu jonglieren.

  • Portabilität: Funktioniert auf jedem Betriebssystem, das Docker unterstützt. Ihre Entwicklungsumgebung reist mit Ihrem Code. Klonen Sie ein Repository, öffnen Sie es in VS Code, und Sie sind bereit zum Codieren in Minuten – unabhängig von Ihrem Betriebssystem.

  • Teamkonsistenz: Eine Konfiguration, die im gesamten Team geteilt wird. Neue Teammitglieder können in Minuten starten, anstatt Stunden (oder Tage) damit zu verbringen, ihre Entwicklungsumgebung mit den richtigen Tools und Versionen zu konfigurieren.

  • Automatisierung: Installiert automatisch VS Code-Erweiterungen, Sprachabhängigkeiten und Tools, wenn Sie das Projekt öffnen. Post-Create-Befehle können Datenbankmigrationen durchführen, Daten einfügen oder andere Einrichtungsschritte ohne manuellen Eingriff ausführen.

  • Sicherheit: Potenziell riskante Abhängigkeiten in Containern isolieren. Wenn Sie mit einer älteren, anfälligen Version einer Bibliothek testen müssen, bleibt diese enthalten und beeinflusst Ihr Host-System nicht.

Praktisches Beispiel: Stellen Sie sich vor, Sie treten einem Team bei, das an einem Mikroservices-Projekt arbeitet, das Python 3.11, PostgreSQL 15, Redis und Elasticsearch verwendet. Ohne Dev Containers würden Sie Stunden damit verbringen, jede Komponente zu installieren und zu konfigurieren. Mit Dev Containers öffnen Sie das Projekt in VS Code, lassen es den Container erstellen, und Sie schreiben innerhalb von 5-10 Minuten Code.

🧱 Einrichtung eines Dev Containers in VS Code

Gehen wir Schritt für Schritt vor.

1. Installation der erforderlichen Tools

Bevor Sie beginnen, stellen Sie sicher, dass Folgendes installiert ist:

  • Docker Desktop (oder ein äquivalenter Container-Runtime wie Podman)

    • Für Windows/Mac: Docker Desktop herunterladen und installieren
    • Für Linux: Docker Engine installieren und sicherstellen, dass Ihr Benutzer in der docker-Gruppe ist

  • VS Code (empfohlen wird die neueste Version)

  • Die Dev Containers-Erweiterung (von Microsoft)

    • Öffnen Sie VS Code
    • Gehen Sie zu Erweiterungen (Ctrl+Shift+X oder Cmd+Shift+X)
    • Suchen Sie nach “Dev Containers”
    • Installieren Sie die Erweiterung mit der ID: ms-vscode-remote.remote-containers

Überprüfen Sie Ihre Einrichtung:

# Überprüfen Sie, ob Docker läuft
docker --version
docker ps

# Sollte die Docker-Version und laufende Container (falls vorhanden) ausgeben

2. Initialisierung des Dev Containers

Öffnen Sie Ihr Projektverzeichnis in VS Code und öffnen Sie die Befehlspalette (Ctrl+Shift+P oder Cmd+Shift+P auf macOS), dann geben Sie ein und wählen Sie:

Dev Containers: Add Dev Container Configuration Files...

VS Code zeigt eine Liste von vordefinierten Umgebungstemplates an. Wählen Sie das aus, das zu Ihrem Projekt passt:

  • Node.js — JavaScript/TypeScript-Projekte
  • Python — Datenwissenschaft, Web-Apps, Skripte
  • Go — Go-Anwendungen und -Dienste
  • .NET — C#/F#-Anwendungen
  • Java — Spring Boot-, Maven-, Gradle-Projekte
  • Docker-in-Docker — Wenn Sie Docker innerhalb Ihres Containers benötigen
  • Und viele mehr…

Sie können auch zusätzliche Funktionen wie Folgendes auswählen:

  • Häufige Utilities (git, curl, wget)
  • Datenbank-Clients
  • Cloud-CLI-Tools (AWS, Azure, GCP)

Dieser Assistent erstellt einen Ordner .devcontainer mit:

  • devcontainer.json — Hauptkonfigurationsdatei
  • Dockerfile — Benutzerdefinierte Bilddefinition (oder ein Verweis auf ein vorab erstelltes Basisbild)

3. Anpassung von devcontainer.json

Die Datei devcontainer.json ist der Ort, an dem die Magie passiert. Hier ist ein gut dokumentiertes Beispiel für ein Node.js-Projekt:

{
  // Container-Anzeigename in VS Code
  "name": "Node.js Development Container",

  // Build-Konfiguration - kann Dockerfile oder vorab erstelltes Bild verwenden
  "build": {
    "dockerfile": "Dockerfile",
    "context": ".."
  },

  // Alternative: Verwenden Sie ein vorab erstelltes Bild anstelle von Dockerfile
  // "image": "mcr.microsoft.com/devcontainers/javascript-node:18",

  // Arbeitsbereichskonfiguration
  "customizations": {
    "vscode": {
      // VS Code-Einstellungen, die im Container gelten
      "settings": {
        "terminal.integrated.defaultProfile.linux": "bash",
        "editor.formatOnSave": true,
        "editor.defaultFormatter": "esbenp.prettier-vscode"
      },

      // Erweiterungen, die automatisch installiert werden sollen
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "eamodio.gitlens",
        "ms-azuretools.vscode-docker"
      ]
    }
  },

  // Port-Weiterleitung - Container-Ports auf dem Host verfügbar machen
  "forwardPorts": [3000, 5432],
  "portsAttributes": {
    "3000": {
      "label": "Anwendung",
      "onAutoForward": "notify"
    }
  },

  // Befehle, die in verschiedenen Phasen ausgeführt werden sollen
  "postCreateCommand": "npm install",     // Nach der Container-Erstellung
  "postStartCommand": "npm run dev",      // Nach dem Container-Start

  // Umgebungsvariablen
  "containerEnv": {
    "NODE_ENV": "development",
    "PORT": "3000"
  },

  // Container als nicht-root-Benutzer ausführen (empfohlen für Sicherheit)
  "remoteUser": "node",

  // Zusätzliche Volumes mounten
  "mounts": [
    "source=${localEnv:HOME}/.ssh,target=/home/node/.ssh,readonly,type=bind"
  ]
}

Wichtige Konfigurationsoptionen erklärt:

  • name — Anzeigename, der in der VS Code-Statusleiste angezeigt wird
  • build / image — Verwenden Sie ein Dockerfile oder ein vorab erstelltes Bild
  • customizations.vscode.extensions — VS Code-Erweiterungen zur automatischen Installation
  • forwardPorts — Ports, die vom Container zum Host freigegeben werden sollen
  • postCreateCommand — Wird einmal ausgeführt, wenn der Container erstmals erstellt wird (z. B. Abhängigkeiten installieren)
  • postStartCommand — Wird jedes Mal ausgeführt, wenn der Container startet
  • containerEnv — Umgebungsvariablen, die im Container verfügbar sind
  • remoteUser — Benutzerkonto, das im Container verwendet werden soll
  • mounts — Zusätzliche Dateien/Ordner zum Mounten (wie SSH-Schlüssel)

💡 Professionelle Tipps:

  • Verwenden Sie postCreateCommand für langsame Operationen (npm install, pip install)
  • Verwenden Sie postStartCommand für schnelle Startaufgaben (Datenbankmigrationen)
  • Geben Sie immer die Erweiterungen an, die Ihr Projekt benötigt — dies stellt eine konsistente Tooling sicher
  • Verwenden Sie Umgebungsvariablen für Konfigurationen, die sich zwischen Entwicklern unterscheiden

4. Build und Öffnen im Container

Sobald Ihre Konfiguration bereit ist, ist es Zeit, Ihre Entwicklungsumgebung zu starten:

Öffnen Sie die Befehlspalette (Ctrl+Shift+P / Cmd+Shift+P) und führen Sie aus:

Dev Containers: Reopen in Container

Was passiert als Nächstes:

  1. Bild-Build — VS Code erstellt das Docker-Bild basierend auf Ihrem Dockerfile oder zieht ein vorab erstelltes Bild heran. Dies kann beim ersten Mal einige Minuten dauern.

  2. Container-Erstellung — Docker erstellt einen neuen Container aus dem erstellten Bild.

  3. Volume-Mounting — Ihr Projektverzeichnis wird in den Container gemountet, sodass Ihr Code innerhalb des Containers zugänglich ist.

  4. Installation von Erweiterungen — Alle angegebenen VS Code-Erweiterungen werden automatisch im Container installiert.

  5. Post-Create-Befehle — Ihr postCreateCommand wird ausgeführt (z. B. npm install, pip install -r requirements.txt).

  6. Fertig! — VS Code verbindet sich erneut mit dem Container, und Sie entwickeln nun darin.

Überprüfen Sie, dass Sie sich im Container befinden:

Sie können bestätigen, dass Sie innerhalb des Containers arbeiten, indem Sie ein Terminal öffnen und Folgendes ausführen:

# Überprüfen Sie das Betriebssystem
uname -a
# Ausgabe: Linux ... (Kernel des Containers)

# Überprüfen Sie den Hostnamen (in der Regel die Container-ID)
hostname
# Ausgabe: abc123def456

# Überprüfen Sie die laufenden Prozesse
ps aux
# Sie werden Container-Prozesse sehen, nicht die Ihres Host-Systems

Beachten Sie, dass die VS Code-Statusleiste (unten links) nun anzeigt: Dev Container: [Ihr Container-Name]

Container-Lebenszyklus-Befehle:

  • Container neu erstellen — Dev Containers: Rebuild Container (wenn Sie das Dockerfile ändern)
  • Ohne Cache neu erstellen — Dev Containers: Rebuild Container Without Cache (für einen frischen Build)
  • Lokal öffnen — Dev Containers: Reopen Folder Locally (Container verlassen, auf dem Host arbeiten)

5. Hinzufügen zusätzlicher Dienste (Optional)

Echtweltanwendungen hängen oft von Datenbanken, Caching-Schichten, Message Queues oder anderen Diensten ab. Sie können Docker Compose verwenden, um mehrere Container zu orchestrieren.

Beispiel: Vollständige Anwendung mit Node.js, PostgreSQL und Redis

Erstellen Sie eine docker-compose.yml in Ihrem .devcontainer-Ordner:

version: "3.8"

services:
  # Hauptentwicklungscontainer
  app:
    build:
      context: ..
      dockerfile: .devcontainer/Dockerfile

    volumes:
      # Projektverzeichnis mounten
      - ..:/workspace:cached
      # Benennen Sie das Volume für node_modules (bessere Leistung)
      - node_modules:/workspace/node_modules

    # Container laufen lassen
    command: sleep infinity

    # Netzwerkzugriff auf andere Dienste
    depends_on:
      - db
      - redis

    environment:
      DATABASE_URL: postgresql://dev:secret@db:5432/appdb
      REDIS_URL: redis://redis:6379

  # PostgreSQL-Datenbank
  db:
    image: postgres:15-alpine
    restart: unless-stopped
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: appdb
    ports:
      - "5432:5432"

  # Redis-Cache
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - redis-data:/data
    ports:
      - "6379:6379"

volumes:
  postgres-data:
  redis-data:
  node_modules:

Dann aktualisieren Sie Ihr devcontainer.json, um Docker Compose zu verwenden:

{
  "name": "Full-stack Dev Environment",

  // Verwenden Sie docker-compose anstelle eines einzelnen Containers
  "dockerComposeFile": "docker-compose.yml",

  // Welcher Dienst als Entwicklungscontainer verwendet werden soll
  "service": "app",

  // Pfad zum Arbeitsbereichsordner im Container
  "workspaceFolder": "/workspace",

  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "ms-azuretools.vscode-docker",
        "ckolkman.vscode-postgres"  // PostgreSQL-Client
      ]
    }
  },

  "forwardPorts": [3000, 5432, 6379],

  "postCreateCommand": "npm install && npm run db:migrate",

  "remoteUser": "node"
}

Was diese Einrichtung bietet:

  • app — Ihr Entwicklungscontainer mit Node.js
  • db — PostgreSQL-Datenbank, zugänglich unter db:5432 von Ihrer App
  • redis — Redis-Cache, zugänglich unter redis:6379
  • Benannte Volumes — Datenbankdaten zwischen Container-Neustarts persistent speichern
  • Port-Weiterleitung — Zugriff auf alle Dienste von Ihrem Host-Gerät

Verbinden Sie sich mit Diensten von Ihrem Code aus:

// In Ihrer Node.js-Anwendung
const { Pool } = require('pg');
const redis = require('redis');

// PostgreSQL-Verbindung
const pool = new Pool({
  connectionString: process.env.DATABASE_URL
  // Wird aufgelöst zu: postgresql://dev:secret@db:5432/appdb
});

// Redis-Verbindung
const redisClient = redis.createClient({
  url: process.env.REDIS_URL
  // Wird aufgelöst zu: redis://redis:6379
});

Zugriff auf Dienste von Ihrem Host:

  • App: http://localhost:3000
  • PostgreSQL: localhost:5432 (mit jedem PostgreSQL-Client)
  • Redis: localhost:6379 (mit redis-cli oder GUI-Tools)

Jetzt starten alle Dienste automatisch, wenn Sie das Projekt in VS Code öffnen!

🧠 Fortgeschrittene Tipps und Best Practices

Verwendung von vorgefertigten Bildern

Sparen Sie erhebliche Build-Zeit, indem Sie mit den offiziellen Devcontainer-Bildern von Microsoft beginnen:

{
  "image": "mcr.microsoft.com/devcontainers/python:3.11",
  "features": {
    "ghcr.io/devcontainers/features/git:1": {},
    "ghcr.io/devcontainers/features/github-cli:1": {}
  }
}

Features sind wiederverwendbare Installationsskripte für häufig verwendete Tools (Git, GitHub CLI, Node, AWS CLI usw.).

Versionskontroll-Best Practices

Immer committen Sie Ihr .devcontainer-Verzeichnis:

git add .devcontainer/
git commit -m "Dev Container-Konfiguration hinzufügen"
git push

Dies stellt sicher:

  • ✅ Neue Teammitglieder erhalten die Umgebung automatisch
  • ✅ Änderungen an der Umgebung werden verfolgt und sind überprüfbar
  • ✅ Jeder entwickelt in derselben Einrichtung

Professioneller Tipp: Fügen Sie einen README-Abschnitt hinzu, der die Dev-Container-Einrichtung erklärt:


## Entwicklungseinrichtung

Dieses Projekt verwendet VS Code Dev Containers. Um zu beginnen:

1. Installieren Sie Docker Desktop und VS Code
2. Installieren Sie die Erweiterung "Dev Containers"
3. Klonen Sie dieses Repository
4. Öffnen Sie es in VS Code
5. Klicken Sie auf "Im Container öffnen", wenn Sie dazu aufgefordert werden

Debugging in Containern

Debugging funktioniert nahtlos. Konfigurieren Sie Ihre launch.json wie gewohnt:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Launch Node.js",
      "type": "node",
      "request": "launch",
      "program": "${workspaceFolder}/index.js",
      "skipFiles": ["<node_internals>/**"]
    }
  ]
}

Setzen Sie Haltepunkte und debuggen Sie normal — VS Code verwaltet die Containerverbindung automatisch.

Kontinuierliche Integration Parität

Verwenden Sie dasselbe Container-Bild in Ihrer CI/CD-Pipeline:

# GitHub Actions Beispiel
name: CI
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/devcontainers/javascript-node:18
    steps:
      - uses: actions/checkout@v3
      - run: npm install
      - run: npm test

Dies stellt Entwicklungs-/Produktionsparität sicher — wenn die Tests lokal funktionieren, werden sie auch in der CI funktionieren.

Leistungsoptimierung

Für macOS/Windows-Nutzer — verwenden Sie benannte Volumes für Abhängigkeiten:

{
  "mounts": [
    "source=myproject-node_modules,target=${containerWorkspaceFolder}/node_modules,type=volume"
  ]
}

Dies verbessert die Datei-E/A-Leistung für node_modules, venv usw. erheblich.

Mehrstufige Entwicklung

Erstellen Sie verschiedene Konfigurationen für verschiedene Teamrollen:

.devcontainer/
├── devcontainer.json          # Standard (Full-Stack)
├── frontend/
│   └── devcontainer.json      # Frontend-only (leichter)
└── backend/
    └── devcontainer.json      # Backend-only (mit DB)

Teammitglieder können ihre Umgebung auswählen, wenn sie das Projekt öffnen.

Arbeiten mit SSH-Schlüsseln und Git

Mounten Sie Ihre SSH-Schlüssel für Git-Operationen:

{
  "mounts": [
    "source=${localEnv:HOME}${localEnv:USERPROFILE}/.ssh,target=/home/node/.ssh,readonly,type=bind"
  ],
  "postCreateCommand": "ssh-add ~/.ssh/id_ed25519 || true"
}

Benutzerdefinierte Umgebungsdateien

Laden Sie umgebungsspezifische Konfigurationen:

{
  "runArgs": ["--env-file", ".devcontainer/.env"]
}

.devcontainer/.env:

API_KEY=dev_key_here
DEBUG=true
LOG_LEVEL=debug

🔧 Häufige Problembehebung

Container startet nicht

Fehler: Cannot connect to the Docker daemon

Lösung:

  • Stellen Sie sicher, dass Docker Desktop läuft
  • Unter Linux überprüfen: sudo systemctl status docker
  • Überprüfen Sie, ob Docker in Ihrem PATH ist: docker --version

Langsame Leistung auf macOS/Windows

Problem: Dateioperationen sind langsam

Lösungen:

  1. Verwenden Sie benannte Volumes für node_modules, venv usw.

  2. Aktivieren Sie die Dateifreigabe in den Docker Desktop-Einstellungen

  3. Erwägen Sie die Verwendung der Optionen cached oder delegated:

    "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind,consistency=cached"

Erweiterungen werden nicht installiert

Problem: In devcontainer.json angegebene Erweiterungen werden nicht installiert

Lösungen:

  1. Container neu aufbauen: Dev Containers: Rebuild Container
  2. Überprüfen Sie, ob die Erweiterungskennungen korrekt sind
  3. Stellen Sie sicher, dass die Erweiterungen Remote-Container unterstützen (die meisten tun das)

Port bereits belegt

Fehler: Port 3000 ist bereits belegt

Lösungen:

  1. Beenden Sie konkurrierende Container: docker ps und docker stop <container>
  2. Ändern Sie die Portzuordnung in forwardPorts
  3. Verwenden Sie dynamische Ports: VS Code weist automatisch verfügbare Ports zu

Änderungen am Dockerfile werden nicht angewendet

Problem: Geändertes Dockerfile, aber Änderungen werden nicht angezeigt

Lösung: Bauen Sie ohne Cache neu auf:

Dev Containers: Rebuild Container Without Cache

Container beendet sich sofort

Problem: Container startet und stoppt dann

Lösung: Fügen Sie einen Befehl hinzu, um ihn in docker-compose.yml laufen zu lassen:

command: sleep infinity

Oder in devcontainer.json:

{
  "overrideCommand": true
}

✅ Fazit

Dev Containers in VS Code bringen Konsistenz, Einfachheit und Automatisierung in Ihren Entwicklungsworkflow. Sie verwandeln komplexe, fragile Einstellungen in code-definierte Umgebungen, die einfach funktionieren, unabhängig von Ihrem Gerät oder Betriebssystem.

Wichtige Erkenntnisse:

  • 🎯 Beseitigen Sie “funktioniert auf meinem Gerät”-Probleme — Jeder verwendet identische Umgebungen
  • 🚀 Schnellere Einarbeitung — Neue Teammitglieder sind in Minuten, nicht Tagen produktiv
  • 🔒 Bessere Sicherheit — Isolieren Sie Abhängigkeiten von Ihrem Host-System
  • 📦 Portabel — Ihre Umgebung reist mit Ihrem Code
  • 🤝 Teamkonsistenz — Keine Abhängigkeitsversionskonflikte mehr
  • 🔄 CI/CD-Parität — Verwenden Sie dasselbe Bild in Entwicklung und kontinuierlicher Integration

Ob Sie an einem einfachen Python-Skript oder einer komplexen Mikroservices-Architektur mit mehreren Datenbanken arbeiten — Dev Containers bieten eine robuste Grundlage für die moderne Entwicklung.

Wenn Sie an Multi-Language-Projekten zusammenarbeiten, zu Open-Source-Repositories beitragen, häufig neue Entwickler einarbeiten oder einfach saubere und reproduzierbare Entwicklungsumgebungen wünschen — Dev Containers sind ein Muss in Ihrem Stack.

Fangen Sie klein an: Probieren Sie Dev Containers in Ihrem nächsten Projekt aus. Sobald Sie die Vorteile erleben, werden Sie sich fragen, wie Sie jemals ohne sie entwickelt haben.

📚 Nützliche Ressourcen und verwandte Artikel

Offizielle Dokumentation:

Verwandte Artikel auf dieser Seite: