Docker Compose v5 : le SDK Go qui change tout pour l'automatisation

Le 14 février 2026, Docker a annoncé la disponibilité générale de Docker Compose v5, marquant une rupture majeure avec les versions précédentes. Contrairement aux versions v2-v4 écrites en Python, v5 est complètement réécrite en Go et expose pour la première fois un SDK natif pour l'automatisation programmatique. Cette évolution transforme Compose d'un simple CLI en un framework d'orchestration léger et programmable, bridgeant le gap entre développement local et déploiement production.

Pourquoi réécrire Compose en Go ?

Docker Compose v2-v4 étaient écrites en Python avec des bindings à des services externes. Cette architecture présentait plusieurs limitations. Avec la montée en puissance de Kubernetes et l'augmentation des cas d'usage d'orchestration décentralisée (Nomad, Swarm, Edge Compute), Docker a décidé de moderniser Compose pour rester pertinent.

La réécriture en Go permet :

• Performance : démarrage instant, parsing YAML en quelques millisecondes.
• Distribution : binaire statiquement linké, zéro dépendances externes.
• Cross-platform : compilation native pour Linux ARM64, Windows, macOS sans friction.
• SDK exposé : la logique d'orchestration devient une library réutilisable.
• Maintenabilité : codebase moderne et modulaire.

Architecture modulaire de Compose v5

Compose v5 est structurée en packages réutilisables :

github.com/docker/compose/v5
├── /api           # SDK exposé publiquement
├── /cli           # Interface ligne de commande
├── /loader        # Parseur YAML et validation
├── /engine        # Gestion du cycle de vie des conteneurs
└── /integration   # Branchement avec Docker Daemon

SDK public pour l'automatisation

La grande nouveauté : un SDK Go officiel et stable.

import "github.com/docker/compose/v5/api"

// Créer une composition et la lancer programmatiquement
composer := api.NewComposer(
  api.WithFile("docker-compose.yml"),
  api.WithProject("my-app"),
)

// Up
if err := composer.Up(context.Background()); err != nil {
  log.Fatal(err)
}

// Query services status
services, err := composer.Services(context.Background())
for _, svc := range services {
  fmt.Printf("%s: %s\n", svc.Name, svc.State)
}

// Down
composer.Down(context.Background())

Ce SDK expose :

• Composer.Up/Down : gestion du cycle de vie.
• Composer.Services : query l'état des services.
• Composer.Logs : streaming des logs en temps réel.
• Composer.Exec : exécution de commandes dans les conteneurs.
• Composer.Events : webhook et événements lifecycle.
• Composer.Config : accès programmatique à la configuration.

Streaming et événements en temps réel

Contrairement à v2-v4, v5 implémente un système d'événements asynchrone :

// Écouter les événements d'un service
events := composer.WatchService(ctx, "api", api.ServiceEventFilter{
  Types: []string{"start", "stop", "error"},
})

for event := range events {
  switch event.Type {
  case "start":
    log.Printf("Service %s started with PID %d\n", event.ServiceName, event.PID)
  case "error":
    log.Printf("Service %s failed: %s\n", event.ServiceName, event.Error)
  }
}

Cela permet des outils de monitoring et automation sophistiqués sans polling constant.

Support des Profiles avancé

Les profiles de Compose v2 permettaient de sélectionner des groupes de services, mais v5 les améliore :

services:
  api:
    image: api:latest
    profiles: [prod]
  redis:
    image: redis:latest
    profiles: [cache]
  monitoring:
    image: prometheus:latest
    profiles: [debug, prod]

Via le SDK :

composer := api.NewComposer(
  api.WithFile("docker-compose.yml"),
  api.WithProfiles([]string{"monitoring", "cache"}),
)
composer.Up(ctx)

Migration depuis Compose v2/v4

Compatibilité rétro-complète

Docker Compose v5 est 100% compatible rétro avec les fichiers docker-compose.yml v2 et v4. Les fichiers existants tournent sans modification.

curl -L "https://github.com/docker/compose/releases/download/v5.0.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
docker-compose version

Cas d'usage avec le SDK

1. Orchestration programmatique en Go

Intégrer Compose directement dans une application Go :

package main

import (
  "context"
  "github.com/docker/compose/v5/api"
)

func main() {
  composer := api.NewComposer(api.WithFile("docker-compose.yml"))

  // Démarrer tous les services
  composer.Up(context.Background())

  // Attendre que l'API soit prête
  composer.WaitForService(context.Background(), "api", 30*time.Second)

  // Exécuter des tests
  result, err := composer.Exec(context.Background(), "api", []string{"npm", "test"})

  // Nettoyer
  composer.Down(context.Background())
}

2. Terraform / Infrastructure as Code

Écrire un provider Terraform pour Compose :

resource "docker_compose_stack" "app" {
  compose_file = file("${path.module}/docker-compose.yml")
  project_name = "myapp"

  environment = {
    DATABASE_URL = "postgres://..."
  }
}

output "services" {
  value = docker_compose_stack.app.services
}

3. CI/CD avec Docker Compose API

GitHub Actions avec test et cleanup automatique :

name: Test with Compose v5 API

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-go@v4
        with:
          go-version: 1.22

      - name: Run tests with Compose SDK
        run: |
          go run ./cmd/test-runner.go \
            --compose-file docker-compose.test.yml \
            --services api,postgres

Performance vs v2/v4

Intégration avec Kubernetes

Compose to Kubernetes est maintenant natif :

docker-compose convert --format kubernetes > deployment.yaml

Le fichier généré est prêt à être appliqué sur Kubernetes :

kubectl apply -f deployment.yaml

Sécurité : secrets natifs

Compose v5 intègre la gestion des secrets :

services:
  api:
    image: api:latest
    secrets:
      - db_password
      - api_key

secrets:
  db_password:
    external: true  # Fourni via docker secret
  api_key:
    file: ./secrets/api_key.txt

Via le SDK :

composer := api.NewComposer(
  api.WithFile("docker-compose.yml"),
  api.WithSecrets(map[string]string{
    "db_password": os.Getenv("DB_PASSWORD"),
    "api_key": os.Getenv("API_KEY"),
  }),
)
composer.Up(ctx)

Limitations et considérations

• SDK v1 : API peut évoluer jusqu'à v2 d'ici 2027.
• Swarm : support décroissant (Docker oriente vers Kubernetes).
• Windows : certains volumes restent limités sur WSL2.

Conclusion

Docker Compose v5 marque la maturation de l'orchestration légère. Avec un SDK Go natif, des performances drastiquement améliorées, et une architecture modulaire, Compose v5 devient un choix viable pour l'orchestration en production, pas seulement le développement local.

Pour les DevOps et développeurs backend, cette version est un upgrade obligatoire. Le gain de performance seul (46x plus rapide sur parse) justifie la migration immédiate.