🐳 Docker sur macOS Apple Silicon avec Colima

Guide complet d’installation + bonnes pratiques + QEMU optionnel + intégration VS Code + templates .devcontainer.
Sans Docker Desktop — approche recommandée pour un environnement de dev moderne.

🎯 Objectif

Mettre en place un environnement Docker :

• ✅ Léger et performant sur Apple Silicon (M1/M2/M3/M4)
• ✅ 100 % open source (pas de dépendance Docker Desktop)
• ✅ Reproductible (CI/CD friendly)
• ✅ Intégré proprement avec VS Code (Docker + Dev Containers)
• ✅ Compatible images Intel via QEMU (optionnel)

🧠 Pourquoi ne pas utiliser Docker Desktop ?

Sur macOS, Docker ne tourne pas “nativement” (pas de kernel Linux). Il faut donc une VM Linux.

Docker Desktop fournit cette VM mais ajoute :

• une surcouche propriétaire + UI
• une consommation CPU/RAM plus élevée
• une licence payante en entreprise (selon conditions Docker)

👉 Colima fournit une VM Linux minimaliste via Lima avec de très bonnes perfs et un workflow CLI standard :

Docker CLI → Colima → Lima VM → Linux ARM64 natif

📦 1) Pré-requis

✅ 1.1 Vérifier que tu es bien sur Apple Silicon

uname -m

Résultat attendu : arm64.

✅ 1.2 Installer Homebrew (si absent)

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Puis :

brew update
brew doctor

🔧 2) Installer Docker (CLI) + Colima

⚠️ On installe le CLI Docker, pas Docker Desktop.

brew install colima docker docker-compose

🧩 QEMU (optionnel — voir section dédiée)

Ne l’installe que si tu dois exécuter des images amd64 (Intel) sur ton Mac ARM.

🚀 3) Démarrer Colima (configuration recommandée)

Démarrage optimisé poste dev (à adapter selon RAM/CPU) :

colima start --cpu 4 --memory 6 --disk 60 --arch aarch64

Recommandations ressources

💡 Évite x86_64 : ce serait de l’émulation, donc plus lent.

✅ 4) Vérifier l’installation

docker version

Tu dois voir Client et Server.

Test réel :

docker run --rm hello-world

⚙️ 5) Vérifier / fixer le contexte Docker

Colima crée généralement un contexte Docker dédié.

Lister :

docker context ls

Résultat attendu : colima * (l’astérisque indique le contexte actif).

Si nécessaire :

docker context use colima

📁 6) Workflow quotidien recommandé

Démarrer la VM quand tu en as besoin :

colima start

Lancer ton projet :

docker compose up -d

Arrêter proprement en fin de journée :

colima stop

✅ Avantage : pas de daemon Docker qui tourne en permanence et consomme des ressources.

⚡ 7) Bonnes pratiques de performance (macOS + VM)

7.1 Préférer des images ARM64 natives

Apple Silicon = linux/arm64. Beaucoup d’images sont multi-arch, mais pas toutes.

Vérifier une image :

docker buildx imagetools inspect nginx

Tu veux voir linux/arm64 dans la liste des plateformes.

7.2 Volumes & filesystem : règles d’or

Sur macOS, ton code est monté dans une VM Linux → I/O plus sensibles qu’un Linux natif.

✅ À faire

• Monter uniquement les dossiers nécessaires
• Utiliser des volumes Docker pour DB/cache (meilleures perfs + moins de surprises)
• Avoir un .dockerignore strict
• Limiter les gros répertoires “bruyants” (ex: node_modules, caches)

❌ À éviter

• Binder tout $HOME
• Synchroniser des centaines de milliers de fichiers inutilement
• Binder node_modules si tu peux l’éviter

Exemple de volume “acceptable”

services:
  app:
    volumes:
      - .:/app:delegated

🧠 8) Commandes Colima utiles

📍 9) Où sont stockées les données ?

Colima stocke ses données ici :

~/.colima/

Tu peux y trouver configuration, disque VM, etc. (utile pour debug/backup).

🧩 10) QEMU (OPTIONNEL)

10.1 À quoi sert QEMU ?

Ton Mac est ARM64. Certaines images Docker sont uniquement Intel (amd64).
QEMU permet d’exécuter ces images via émulation CPU.

Sans QEMU, tu peux rencontrer :

exec format error

Avec QEMU :

• l’image peut démarrer
• mais c’est plus lent

10.2 Quand l’installer ?

Uniquement si tu dois utiliser :

• des images legacy non multi-arch
• des outils internes entreprise construits en amd64
• certaines bases/outils “historiques”

10.3 Installer QEMU (option)

brew install qemu
colima restart

10.4 Impact performance

10.5 Vérifier l’architecture d’une image

docker image inspect <image> | grep -i architecture

💻 11) VS Code : extensions & configuration

11.1 Extensions recommandées

• Docker — ms-azuretools.vscode-docker
• Dev Containers — ms-vscode-remote.remote-containers
• Remote Explorer — ms-vscode.remote-explorer
• GitLens — eamodio.gitlens (optionnel mais pratique)

11.2 Forcer VS Code à utiliser le socket Colima

VS Code peut chercher Docker Desktop par défaut. Configure le socket Colima dans settings.json :

{
  "docker.host": "unix:///Users/<USER>/.colima/default/docker.sock"
}

Remplace <USER> par ton user macOS.

11.3 Tester

Dans VS Code :
Cmd + Shift + P → Docker: Show Containers

Tu dois voir les containers gérés par Colima.

📦 12) Qu’est-ce qu’un template .devcontainer ?

Un template .devcontainer permet d’ouvrir ton projet directement dans un conteneur avec tout l’environnement prêt : langages, outils, extensions VS Code, etc.

👉 VS Code exécute le workspace dans le container, pas sur ton Mac.

Pourquoi c’est une best practice ?

• ✅ Environnement reproductible
• ✅ Zéro “ça marche sur ma machine”
• ✅ Onboarding immédiat d’un dev
• ✅ Alignement DEV/CI/PROD
• ✅ Mac propre (moins d’installations locales)

12.1 Structure typique

my-project/
├── docker-compose.yml
└── .devcontainer/
    ├── devcontainer.json
    └── Dockerfile   (optionnel)

12.2 Exemple devcontainer.json (avec docker-compose)

{
  "name": "Dev Environment",
  "dockerComposeFile": "../docker-compose.yml",
  "service": "app",
  "workspaceFolder": "/workspace",

  "customizations": {
    "vscode": {
      "extensions": [
        "ms-azuretools.vscode-docker",
        "ms-vscode-remote.remote-containers",
        "eamodio.gitlens"
      ]
    }
  }
}

Ce fichier :

1. démarre docker compose
2. se connecte au service app
3. monte ton code dans /workspace
4. installe les extensions VS Code listées

12.3 Exemple Dockerfile “dev” (optionnel)

Si tu veux un conteneur spécifique au développement (outils, debug, etc.) :

FROM php:8.3-cli

RUN apt-get update && apt-get install -y \
    git unzip curl ca-certificates

# Exemple: dépendances PHP
RUN docker-php-ext-install pdo pdo_mysql

# Exemple: xdebug
# RUN pecl install xdebug && docker-php-ext-enable xdebug

12.4 Utiliser Dev Containers dans VS Code

Ouvre le dossier du projet, puis :

Cmd + Shift + P → Dev Containers: Reopen in Container

VS Code va :

• construire/mettre à jour l’image (si besoin)
• démarrer les services (compose)
• connecter ton IDE au conteneur
• installer les extensions

🏗️ 13) Build multi-architecture (CI/CD)

Pour builder des images compatibles ARM + Intel :

docker buildx create --use
docker buildx build --platform linux/amd64,linux/arm64 -t myimage:latest .

💡 Ajoute --push si tu pousses sur un registry.

🧹 14) Maintenance

Nettoyage des ressources Docker :

docker system prune -af

Reset complet de Colima (⚠️ supprime la VM) :

colima delete
colima start --cpu 4 --memory 6 --disk 60 --arch aarch64

✅ Conclusion

Stack recommandée sur macOS Apple Silicon :

Colima + Docker CLI + VS Code Dev Containers
(QEMU uniquement si legacy amd64)

Tu obtiens :

• une VM Linux minimaliste et performante
• un workflow Docker standard
• un environnement dev reproductible et industrialisable
• une intégration IDE propre, portable et scalable

J'accepte que mes données (y compris mon adresse IP anonymisée) soient stockées !

Commentez !

Il n'y a actuellement aucun commentaire, alors soyez le premier !