đ Retour au Sommaire
Vous avez maintenant un DevContainer correctement configurĂ© avec tous les outils nĂ©cessaires (GCC, GDB, CMake, Valgrind). Mais comment faire pour que cette configuration soit facilement utilisable par vous-mĂȘme et par dâautres personnes ?
Cette section couvre :
Analogie : Vous avez construit une belle maison (le DevContainer). Maintenant, il faut crĂ©er un chemin dâaccĂšs facile, installer une sonnette claire, et prĂ©parer un guide dâaccueil pour les visiteurs.
Pour utiliser un DevContainer, chaque développeur doit avoir :
Câest tout ! Le reste est gĂ©rĂ© automatiquement par le DevContainer.
# Installer Docker
sudo apt-get update
sudo apt-get install -y docker.io
# Ajouter l'utilisateur au groupe docker (Ă©vite d'utiliser sudo)
sudo usermod -aG docker $USER
# Redémarrer la session pour appliquer les changements
# (déconnectez-vous et reconnectez-vous, ou redémarrez)
# VĂ©rifier l'installation
docker --version
docker run hello-world
# Doit s'exécuter sans sudo et sans erreur
docker ps
Si vous obtenez une erreur de permission, redémarrez votre session ou votre ordinateur.
Ctrl+Shift+Xms-vscode-remote.remote-containers)code --install-extension ms-vscode-remote.remote-containers
Microsoft propose un pack qui inclut plusieurs extensions utiles :
code --install-extension ms-vscode-remote.vscode-remote-extensionpack
Ce pack inclut :
AprĂšs installation, vous devriez voir :
><)Imaginons que vous clonez un projet qui contient déjà une configuration DevContainer.
git clone https://github.com/exemple/projet-c.git
cd projet-c
code .
Si le projet contient un dossier .devcontainer/, VS Code affiche automatiquement une notification :
Folder contains a Dev Container configuration file.
Reopen folder in container?
[Reopen in Container] [Don't Show Again]
Cliquez sur « Reopen in Container ».
VS Code :
postCreateCommandPremiÚre fois : Peut prendre 2-10 minutes selon la connexion internet et la complexité du conteneur.
Fois suivantes : Quelques secondes seulement (le conteneur existe déjà ).
Une fois connecté :
Quand vous ĂȘtes dans un DevContainer, la barre de statut (en bas Ă gauche) affiche :
[Dev Container: Nom du conteneur]
Avec une icÎne distinctive (généralement verte ou bleue).
Cliquez dessus pour accéder aux options :
Lâexplorateur de fichiers montre les fichiers du projet, mais ils sont accĂ©dĂ©s depuis le conteneur.
Le terminal intĂ©grĂ© (Ctrl+ `) sâexĂ©cute dans le conteneur, pas sur votre machine hĂŽte.
# Dans le terminal VS Code (dans le conteneur)
whoami
# vscode
cat /etc/os-release
# Ubuntu 22.04...
gcc --version
# gcc (Ubuntu 11.4.0...) 11.4.0
Accédez à toutes les commandes via Ctrl+Shift+P puis tapez « Dev Containers ».
| Commande | Description |
|---|---|
| Reopen in Container | Ouvre le dossier actuel dans un DevContainer |
| Reopen Folder Locally | Retourne Ă lâouverture locale (hors conteneur) |
| Rebuild Container | Reconstruit le conteneur from scratch |
| Rebuild and Reopen in Container | Reconstruit et rouvre |
| Open Folder in Container⊠| Ouvre un autre dossier dans un conteneur |
| Clone Repository in Container Volume | Clone un repo directement dans un conteneur |
| Commande | Description |
|---|---|
| Show Container Log | Affiche les logs de création du conteneur |
| Inspect Container | Affiche les détails du conteneur Docker |
| Open Container Configuration File | Ouvre le devcontainer.json |
Pour un accĂšs rapide, cliquez sur lâicĂŽne verte/bleue en bas Ă gauche de VS Code. Un menu contextuel apparaĂźt avec les options principales.
Pour que VS Code propose systĂ©matiquement dâouvrir les DevContainers, configurez ce paramĂštre :
Dans vos settings VS Code (Ctrl+, â recherchez « dev containers ») :
{
"dev.containers.reopenInContainer": "prompt"
}
Options disponibles :
| Valeur | Comportement |
|---|---|
"prompt" |
Demande à chaque fois (recommandé) |
"always" |
Ouvre toujours dans le conteneur |
"never" |
Nâouvre jamais automatiquement |
# Ouvrir un projet directement dans son DevContainer
code --folder-uri vscode-remote://dev-container+$(printf '%s' '/chemin/vers/projet' | xxd -p)/workspace
Câest complexe, donc la mĂ©thode simple reste :
code /chemin/vers/projet
# Puis cliquer sur "Reopen in Container"
Lâonboarding est le processus dâintĂ©gration dâun nouveau membre dans lâĂ©quipe. Avec les DevContainers, cela peut ĂȘtre rĂ©duit de plusieurs jours Ă quelques minutes.
# Mon Projet C
## đ DĂ©marrage rapide
### Prérequis
1. **Docker** : [Instructions d'installation](https://docs.docker.com/get-docker/)
2. **VS Code** : [Télécharger](https://code.visualstudio.com/)
3. **Extension Dev Containers** : Installer depuis VS Code (`ms-vscode-remote.remote-containers`)
### Installation
```bash
# 1. Cloner le projet
git clone https://github.com/votre-org/projet-c.git
cd projet-c
# 2. Ouvrir dans VS Code
code .
# 3. Quand VS Code demande "Reopen in Container?", cliquez "Oui"
# (Ou: Ctrl+Shift+P â "Dev Containers: Reopen in Container")
# 4. Attendez la construction du conteneur (2-5 min la premiĂšre fois)
# 5. C'est prĂȘt ! Vous pouvez compiler et exĂ©cuter.
# Option 1 : Avec CMake (recommandé)
mkdir -p build && cd build
cmake ..
make
./mon_programme
# Option 2 : Raccourci VS Code
# Ctrl+Shift+B pour compiler
# F5 pour déboguer
# Dans le terminal VS Code (dans le conteneur)
gcc --version # Doit afficher GCC 11.x
cmake --version # Doit afficher CMake 3.x
valgrind --version # Doit afficher Valgrind 3.x
projet-c/
âââ .devcontainer/ # Configuration DevContainer
âââ .vscode/ # Configuration VS Code
âââ src/ # Code source
âââ include/ # Headers
âââ tests/ # Tests unitaires
âââ build/ # Fichiers compilĂ©s (ignorĂ© par Git)
âââ CMakeLists.txt # Configuration CMake
| Action | Commande |
|---|---|
| Compiler | Ctrl+Shift+B ou cmake --build build |
| DĂ©boguer | F5 |
| Tester | cd build && ctest |
| Valgrind | valgrind --leak-check=full ./build/programme |
| Formater | Ctrl+Shift+I |
docker psCtrl+Shift+P â « Dev Containers: Rebuild Container »Sur Linux, ajoutez votre utilisateur au groupe Docker :
sudo usermod -aG docker $USER
# Puis déconnectez-vous et reconnectez-vous
### Fichier CONTRIBUTING.md
Créez un fichier `CONTRIBUTING.md` pour les contributeurs :
```markdown
# Guide de contribution
## Environnement de développement
Ce projet utilise un **DevContainer** pour garantir un environnement cohérent.
### Configuration automatique
Tout l'environnement est configuré automatiquement :
- â
Compilateur (GCC 11)
- â
DĂ©bogueur (GDB)
- â
Build system (CMake)
- â
Analyseur mémoire (Valgrind)
- â
Formateur de code (clang-format)
- â
Extensions VS Code
**Vous n'avez rien Ă installer manuellement** (sauf Docker et VS Code).
### Ătapes pour contribuer
1. **Fork** le projet sur GitHub
2. **Clonez** votre fork
3. **Ouvrez** dans VS Code avec le DevContainer
4. **Créez** une branche pour votre fonctionnalité
5. **DĂ©veloppez** et testez
6. **Soumettez** une Pull Request
### Standards de code
Le projet utilise clang-format pour le formatage automatique.
- Le code est formaté automatiquement à la sauvegarde
- Style : LLVM avec indentation de 4 espaces
- Limite de colonnes : 80 caractĂšres
### Tests
Avant de soumettre :
```bash
# Compiler
cmake --build build
# Exécuter les tests
cd build && ctest --output-on-failure
# Vérifier les fuites mémoire
valgrind --leak-check=full ./build/mon_programme
### Fichier .devcontainer/README.md
Documentez la configuration du DevContainer elle-mĂȘme :
```markdown
# Configuration DevContainer
Ce dossier contient la configuration de l'environnement de développement.
## Contenu
- `devcontainer.json` : Configuration principale du DevContainer
- `Dockerfile` : (Optionnel) Image Docker personnalisée
## Ce qui est installé
| Outil | Version | Usage |
|-------|---------|-------|
| Ubuntu | 22.04 | SystĂšme de base |
| GCC | 11.x | Compilation |
| GDB | 12.x | DĂ©bogage |
| CMake | 3.22+ | Build system |
| Valgrind | 3.18+ | Analyse mémoire |
| clang-format | 14+ | Formatage code |
| Git | Latest | Versionnement |
## Extensions VS Code incluses
- C/C++ (IntelliSense, débogage)
- CMake Tools
- Error Lens
- GitLens
- etc.
## Modification
Si vous devez modifier l'environnement :
1. Modifiez `devcontainer.json`
2. Reconstruisez : `Ctrl+Shift+P` â "Rebuild Container"
3. Testez que tout fonctionne
4. Commitez les changements
## Support
En cas de problĂšme :
1. Consultez les logs : `Ctrl+Shift+P` â "Show Container Log"
2. Essayez de reconstruire : `Ctrl+Shift+P` â "Rebuild Container"
3. Ouvrez une issue sur GitHub avec les logs
Créez .devcontainer/welcome.sh :
#!/bin/bash
# Script de bienvenue exécuté au premier démarrage
clear
echo "ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ"
echo "â â"
echo "â đ Bienvenue dans l'environnement de dĂ©veloppement ! â"
echo "â â"
echo "ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ"
echo ""
echo "đ Outils disponibles :"
echo " âą GCC $(gcc --version | head -1 | awk '{print $4}')"
echo " âą GDB $(gdb --version | head -1 | awk '{print $4}')"
echo " âą CMake $(cmake --version | head -1 | awk '{print $3}')"
echo " âą Valgrind $(valgrind --version | awk '{print $2}')"
echo ""
echo "đ Commandes rapides :"
echo " âą Compiler : Ctrl+Shift+B"
echo " âą DĂ©boguer : F5"
echo " âą Terminal : Ctrl+\`"
echo " âą Formater : Ctrl+Shift+I"
echo ""
echo "đ Structure du projet :"
echo " âą src/ : Code source"
echo " âą include/ : Headers"
echo " âą tests/ : Tests unitaires"
echo " ⹠build/ : Fichiers compilés"
echo ""
echo "đ Documentation :"
echo " ⹠README.md : Guide de démarrage"
echo " âą CONTRIBUTING.md : Guide de contribution"
echo ""
echo "đĄ Astuce : Tapez 'make help' pour voir les commandes disponibles"
echo ""
echo "âââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ"
{
"postAttachCommand": "bash .devcontainer/welcome.sh"
}
Ce script sâaffichera chaque fois que VS Code se connecte au conteneur.
Si vous préférez un message discret :
{
"postAttachCommand": "echo 'â Environnement prĂȘt ! Tapez make help pour les commandes disponibles.'"
}
Pour les dĂ©butants, fournissez des guides pas Ă pas avec captures dâĂ©cran.
## Installation pour débutants
### Ătape 1 : Installer Docker
[Capture d'Ă©cran de l'installation Docker]
1. Téléchargez Docker Desktop depuis docker.com
2. Lancez l'installateur
3. Suivez les instructions Ă l'Ă©cran
4. Redémarrez votre ordinateur
### Ătape 2 : Installer VS Code
[Capture d'Ă©cran]
1. Téléchargez VS Code depuis code.visualstudio.com
2. Installez-le
### Ătape 3 : Installer l'extension
[Capture d'Ă©cran de l'installation d'extension]
1. Ouvrez VS Code
2. Cliquez sur l'icÎne des extensions (carré dans la barre de gauche)
3. Tapez "Dev Containers"
4. Cliquez sur "Install"
### Ătape 4 : Ouvrir le projet
[Capture d'Ă©cran]
1. Ouvrez un terminal
2. Tapez : git clone [URL]
3. Tapez : code [nom-du-projet]
4. Quand VS Code demande "Reopen in Container", cliquez "Oui"
5. Attendez quelques minutes
6. C'est prĂȘt !
Pour les utilisateurs avancés, fournissez des informations techniques :
## Notes techniques
### Configuration Docker
Le DevContainer utilise les options suivantes :
- `--cap-add=SYS_PTRACE` : Pour GDB
- `--security-opt seccomp=unconfined` : Pour le débogage
### Performance
Pour améliorer les performances sur les gros projets :
- Utilisez un volume Docker pour le dossier build
- Activez BuildKit : `export DOCKER_BUILDKIT=1`
### Personnalisation
Vous pouvez ajouter vos propres extensions dans :
`.vscode/settings.json` (local, non commité)
Ou demander l'ajout d'extensions globales via PR sur `devcontainer.json`.
Ăvitez dâavoir plusieurs configurations concurrentes. Un seul devcontainer.json bien maintenu.
Le devcontainer.json doit toujours ĂȘtre commitĂ© dans Git :
git add .devcontainer/
git commit -m "Add/Update DevContainer configuration"
Quand lâenvironnement Ă©volue, le code et la configuration Ă©voluent ensemble.
Avant de commiter un changement de devcontainer.json :
# Supprimer le conteneur existant
# Ctrl+Shift+P â "Dev Containers: Rebuild Container"
# VĂ©rifier que tout fonctionne
# - Compilation
# - Tests
# - DĂ©bogage
Quand vous modifiez le DevContainer :
## Changelog - DevContainer
### 2025-01-15
- Ajout de Valgrind
- Mise Ă jour de GCC vers la version 12
- **Action requise** : Rebuild Container aprĂšs pull
Préférez des images avec des versions spécifiques :
{
"image": "mcr.microsoft.com/devcontainers/cpp:1-ubuntu-22.04"
}
PlutĂŽt que :
{
"image": "mcr.microsoft.com/devcontainers/cpp:latest"
}
Les images latest peuvent changer et casser la reproductibilité.
Dans votre devcontainer.json, utilisez des commentaires :
{
"name": "Projet C",
// Ubuntu 22.04 pour GCC 11 et glibc 2.35
// Nécessaire pour la compatibilité avec le serveur de production
"image": "mcr.microsoft.com/devcontainers/cpp:ubuntu-22.04",
// Valgrind ajouté pour la détection de fuites (requis par la CI)
"postCreateCommand": "apt-get update && apt-get install -y valgrind",
// Options nécessaires pour GDB dans Docker
"runArgs": [
"--cap-add=SYS_PTRACE",
"--security-opt", "seccomp=unconfined"
]
}
Chaque développeur peut avoir des préférences personnelles (thÚme, extensions supplémentaires) sans affecter le DevContainer partagé.
Créez .vscode/settings.json et ajoutez-le à .gitignore :
echo ".vscode/settings.json" >> .gitignore
Chaque développeur peut avoir ses propres settings :
{
"workbench.colorTheme": "Monokai",
"editor.fontSize": 16,
"terminal.integrated.fontSize": 14
}
Les extensions listées dans devcontainer.json sont installées pour tous.
Pour des extensions personnelles, installez-les manuellement aprÚs la création du conteneur. Elles persisteront tant que le conteneur existe.
VS Code permet dâinjecter vos dotfiles personnels dans le conteneur.
Dans vos settings VS Code globaux :
{
"dotfiles.repository": "https://github.com/votre-username/dotfiles",
"dotfiles.targetPath": "~/dotfiles",
"dotfiles.installCommand": "install.sh"
}
Votre repository dotfiles peut contenir :
.bashrc ou .zshrc personnalisé.gitconfigCréez un script setup.sh à la racine du projet :
#!/bin/bash
# Script d'installation automatique
# Usage : curl -fsSL https://raw.githubusercontent.com/org/projet/main/setup.sh | bash
set -e
echo "đ Installation de l'environnement de dĂ©veloppement"
echo ""
# VĂ©rifier Docker
if ! command -v docker &> /dev/null; then
echo "â Docker n'est pas installĂ©."
echo " Installez Docker : https://docs.docker.com/get-docker/"
exit 1
fi
echo "â Docker dĂ©tectĂ© : $(docker --version)"
# VĂ©rifier VS Code
if ! command -v code &> /dev/null; then
echo "â VS Code n'est pas installĂ© ou pas dans le PATH."
echo " Installez VS Code : https://code.visualstudio.com/"
exit 1
fi
echo "â VS Code dĂ©tectĂ© : $(code --version | head -1)"
# Installer l'extension Dev Containers
echo "đŠ Installation de l'extension Dev Containers..."
code --install-extension ms-vscode-remote.remote-containers --force
echo "â Extension installĂ©e"
# Cloner le projet (si pas déjà fait)
PROJECT_DIR="projet-c"
if [ ! -d "$PROJECT_DIR" ]; then
echo "đ„ Clonage du projet..."
git clone https://github.com/org/projet-c.git "$PROJECT_DIR"
fi
# Ouvrir dans VS Code
echo ""
echo "đ Installation terminĂ©e !"
echo ""
echo "Pour commencer :"
echo " cd $PROJECT_DIR"
echo " code ."
echo " â Cliquez sur 'Reopen in Container' quand demandĂ©"
echo ""
Les nouveaux développeurs peuvent exécuter :
curl -fsSL https://raw.githubusercontent.com/org/projet/main/setup.sh | bash
Ajoutez un badge pour indiquer que le projet supporte les DevContainers :
[](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/org/projet)
Si vous utilisez GitHub, les DevContainers fonctionnent aussi avec GitHub Codespaces (environnement de dev dans le cloud).
Le mĂȘme devcontainer.json est utilisĂ©. Les dĂ©veloppeurs peuvent cliquer sur « Code » â « Open with Codespaces » pour avoir un environnement complet dans leur navigateur.
Créez un template repository avec :
.devcontainer/devcontainer.json pré-configuré.vscode/ avec tasks et launch configsCMakeLists.txt de baseREADME.md avec instructionssrc/, include/, tests/)Les nouveaux projets peuvent démarrer à partir de ce template.
SymptĂŽme : VS Code indique que Docker nâest pas accessible.
Solutions :
# DĂ©marrer Docker
sudo systemctl start docker
# VĂ©rifier que Docker fonctionne
docker ps
SymptĂŽme : Erreurs de permission lors de lâaccĂšs Ă Docker.
Solution :
# Ajouter l'utilisateur au groupe docker
sudo usermod -aG docker $USER
# Important : se déconnecter et reconnecter
# ou redémarrer l'ordinateur
Causes possibles :
postCreateCommand complexeSolutions :
docker pull mcr.microsoft.com/devcontainers/cpp:ubuntu-22.04postCreateCommandSymptÎme : Les extensions listées dans devcontainer.json ne sont pas installées.
Solutions :
publisher.extension-name)Ctrl+Shift+P â « Rebuild Container »Ctrl+Shift+P â « Show Container Log »SymptĂŽme : Pas dâauto-complĂ©tion, erreurs partout.
Solutions :
c_cpp_properties.jsoncompile_commands.json avec CMakeCtrl+Shift+P â « Developer: Reload Window »SymptĂŽme : Erreur lors du lancement de GDB.
VĂ©rifications :
-g ?runArgs sont présents dans devcontainer.json ?"runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined"]
launch.json est correct ?Pour diagnostiquer les problĂšmes :
# Logs de l'extension Dev Containers
# Ctrl+Shift+P â "Dev Containers: Show Container Log"
# Logs Docker
docker logs <container-id>
# Ătat des conteneurs
docker ps -a
# Espace disque Docker
docker system df
## Checklist de dépannage DevContainer
### Docker
- [ ] Docker est installé (`docker --version`)
- [ ] Docker est démarré (`docker ps` fonctionne)
- [ ] L'utilisateur est dans le groupe docker (Linux)
- [ ] Assez d'espace disque (`docker system df`)
### VS Code
- [ ] VS Code est Ă jour
- [ ] Extension Dev Containers installée
- [ ] Extension C/C++ installée
### Projet
- [ ] Le dossier `.devcontainer/` existe
- [ ] `devcontainer.json` est valide (pas d'erreur de syntaxe)
- [ ] L'image Docker existe ou est accessible
### Connexion
- [ ] Connexion internet active (pour télécharger les images)
- [ ] Pas de proxy/firewall bloquant Docker Hub
1. Ouvrir VS Code
2. Ouvrir le projet (Ctrl+O ou via terminal)
3. Si demandé, "Reopen in Container"
4. Attendre quelques secondes
5. Coder !
1. Sauvegarder les fichiers
2. Commit et push si nécessaire
3. Fermer VS Code
4. (Le conteneur s'arrĂȘte automatiquement)
Quand un collĂšgue met Ă jour le devcontainer.json :
1. git pull
2. VS Code peut demander de reconstruire
3. Sinon : Ctrl+Shift+P â "Dev Containers: Rebuild Container"
4. Attendre la reconstruction
5. Continuer le travail
Ă ce stade, vous savez :
Prochaine Ă©tape : Dans la section 2.5.5, nous verrons comment les DevContainers deviennent la « source de vĂ©ritĂ© » pour lâenvironnement de dĂ©veloppement et comment les intĂ©grer avec la CI/CD.
.vscode/settings.json (non commité)Citation :
« The best onboarding is no onboarding. With DevContainers, developers clone and code. »
â Philosophie DevContainer