Créer un environnement de développement avec DevContainer, Dockerfile et Docker-Compose

Apprenez à configurer un environnement de développement évolutif avec DevContainer, en passant de configurations simples à l'orchestration multi-services avec Docker-Compose.

Les environnements de développement consistent souvent en une configuration complexe d’outils, de versions de dépendances, et de systèmes spécifiques. Cela peut rendre le passage d’un projet à un autre ou l’intégration de nouveaux membres dans une équipe difficile. C’est là qu’intervient DevContainer, une solution qui permet de définir et partager des environnements de développement portables et reproductibles.

Dans cet article, je vais te montrer comment démarrer avec DevContainer, et comment le faire évoluer en fonction des besoins en passant par trois étapes :

  • Un DevContainer de base
  • Un DevContainer avec Dockerfile pour une personnalisation plus fine
  • Un DevContainer avec Docker-Compose pour gérer plusieurs services dans un environnement de développement

Chaque étape sera introduite par l’ajout d’une nouvelle fonctionnalité dans un projet exemple, montrant ainsi pourquoi et quand faire évoluer la configuration.

Dans les exemples suivants, le fichier index.html se trouve dans le dossier app pour illustrer une simple application web.

Étape 1 : Mettre en place un DevContainer basique

La première étape consiste à créer un environnement de développement dans un conteneur avec une configuration très simple. Cela permet d’unifier les environnements au sein d’une équipe de développement, sans avoir besoin de personnaliser l’environnement pour chaque développeur.

Configuration basique

La configuration la plus simple d’un DevContainer repose sur un fichier devcontainer.json, qui définit l’image Docker à utiliser pour le conteneur de développement. Pour commencer, voici un exemple de fichier devcontainer.json minimal :`

{
  "name": "Basic DevContainer",
  "image": "mcr.microsoft.com/vscode/devcontainers/base:ubuntu"
}

Avec cette configuration, tout développeur travaillant sur ce projet peut simplement ouvrir le projet dans un éditeur compatible (comme VSCode) et bénéficier d’un environnement Linux prêt à l'emploi, sans avoir à configurer quoi que ce soit localement.

Structure du projet pour un DevContainer basique :

/my-project
  ├── .devcontainer
  │   └── devcontainer.json
  └── app
      └── index.html

Quand utiliser cette configuration ?

Ce type de configuration est idéal pour des projets simples ou des environnements standards où aucune personnalisation n’est nécessaire. Si votre projet n'a besoin que d'un environnement de développement commun basé sur une image Docker existante, cette approche est rapide et efficace.

Étape 2 : Ajouter un Dockerfile pour plus de contrôle

En avançant dans le développement, il arrive souvent que l'on ait besoin d'ajouter des outils ou des bibliothèques spécifiques à l’environnement. C’est là qu’un Dockerfile devient utile.

Personnalisation avec Dockerfile

La deuxième étape consiste à introduire un Dockerfile qui permettra de personnaliser davantage l’environnement en ajoutant des outils ou configurations spécifiques au projet. Voici un exemple de devcontainer.json avec un Dockerfile associé :

{
  "name": "Custom DevContainer",
  "build": {
    "dockerfile": "Dockerfile"
  }
}

Le fichier Dockerfile permet d’ajouter des instructions pour installer des paquets supplémentaires :

# Même image que dans le devcontainer.json minimal
FROM mcr.microsoft.com/vscode/devcontainers/base:ubuntu

# Installation d'outils supplémentaires
RUN apt-get update && apt-get install -y curl

Structure du projet avec un Dockerfile ajouté :

/my-project
  ├── .devcontainer
  │   ├── devcontainer.json
  │   └── Dockerfile
  └── app
      └── index.html

Quand utiliser un Dockerfile ?

Cette configuration est utile lorsque le projet a des besoins spécifiques, comme des versions particulières d’outils de développement, ou des dépendances supplémentaires que l’image Docker de base ne fournit pas. Par exemple, si vous développez une application avec un framework nécessitant certains outils non inclus dans l’image de base, le Dockerfile vous permet de les ajouter.

Étape 3 : Utiliser Docker-Compose pour un environnement multi-services

Quand le projet devient encore plus complexe, il peut être nécessaire d'orchestrer plusieurs services, comme une application web et une base de données. C'est ici que Docker-Compose intervient.

Gestion de services multiples avec Docker-Compose

Avec Docker-Compose, vous pouvez facilement orchestrer plusieurs conteneurs. Cela permet, par exemple, de faire tourner à la fois une API et une base de données pour le développement local. Voici comment évoluer vers une configuration docker-compose.yml pour un environnement multi-services :

{
  "name": "DevContainer with Docker-Compose",
  "dockerComposeFile": "docker-compose.yml",
  "service": "app"
}

Le fichier docker-compose.yml pourrait ressembler à ceci :

services:
  app:
    build: .
    volumes:
      - .:/workspace
    ports:
      - "8080:8080"
  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb

Avec cette configuration, vous pouvez développer et tester des fonctionnalités nécessitant plusieurs services dans un environnement cohérent.

Structure du projet avec Docker-Compose :

/my-project
  ├── .devcontainer
  │   ├── devcontainer.json
  │   └── Dockerfile
  ├── docker-compose.yml
  └── app
      └── index.html

Quand utiliser Docker-Compose ?

Docker-Compose devient essentiel lorsque vous travaillez avec des systèmes complexes nécessitant plusieurs services (comme une API avec une base de données). Cela permet de reproduire des environnements similaires à ceux de production tout en restant dans un cadre de développement local.

Conclusion

Au fur et à mesure que les besoins de votre projet évoluent, il devient nécessaire d’adapter votre environnement de développement. DevContainer offre une grande flexibilité pour cela, en commençant par une configuration simple et en évoluant vers des environnements plus complexes avec Dockerfile et Docker-Compose.

  • DevContainer de base : rapide et efficace pour des projets simples.
  • DevContainer avec Dockerfile : permet de personnaliser les outils et configurations de votre environnement.
  • DevContainer avec Docker-Compose : gère plusieurs services pour un développement et un test local optimisés.

Je t'encourage à essayer ces configurations et à les adapter à tes besoins spécifiques. L'utilisation de DevContainers peut grandement simplifier le processus de gestion d’environnements de développement, surtout dans des équipes où la cohérence est primordiale.