Comment exécuter Docker sur Mac ? Installer Docker Desktop sur les puces M, déployer MySQL, Redis et un projet Web

Ce guide accompagne les développeurs sur Mac à puce M, de l’installation de Docker Desktop à la vérification des images et des services. Il propose une configuration Compose pour une application Web reliée à MySQL et Redis, puis des tests de connexion, de persistance et de dépannage.

Le conteneur refuse de démarrer, ou l’application Web ne parvient pas à joindre sa base de données ? Verdict — adapté : un Mac à puce M peut exécuter Docker avec Docker Desktop et Compose ; installez la version destinée à Apple Silicon, vérifiez l’architecture des images et configurez correctement les ports, les variables et les volumes.

Cet article s’adresse aux développeurs qui configurent Docker pour la première fois sur un Mac à puce M, aux équipes qui réunissent MySQL, Redis et une application Web dans un environnement local, ainsi qu’à celles qui évaluent un Mac distant pour développer ou construire un projet. Si votre besoin est plutôt de déployer un service de production, ne reprenez pas tels quels les identifiants et paramètres de développement présentés ici.

Avant l’installation, quels points conditionnent le résultat ?

Docker Desktop fournit l’environnement qui permet d’exécuter des conteneurs Linux sur macOS. Sur un Mac à puce M, cette exécution passe par une machine virtuelle Linux et les mécanismes de virtualisation disponibles sur la plateforme. Apple décrit l’exécution de Linux dans une machine virtuelle avec son cadre Virtualization ; Docker détaille, de son côté, l’installation et les prérequis actuels de Docker Desktop pour Mac. Consultez ces pages avant l’installation : la compatibilité dépend du système pris en charge et de l’installateur proposé, pas seulement du processeur.

Le point souvent négligé est l’architecture de chaque image. Apple Silicon utilise l’architecture ARM64 ; une image publiée uniquement pour une autre architecture ne devient pas native parce que Docker Desktop a été installé correctement. Docker explique les variantes d’images et leur construction dans sa documentation sur les images multiplateformes. Avant de choisir une image, vérifiez les plateformes annoncées par son éditeur et testez le conteneur dans votre environnement.

Le déploiement présenté ici est réussi lorsque quatre vérifications passent : le client Docker communique avec son moteur ; MySQL et Redis deviennent prêts ; l’application Web répond sur le Mac ; les données requises survivent à la recréation des conteneurs grâce aux volumes configurés.

Les limitations à anticiper sont concrètes :

• Architecture : une image incompatible peut échouer au démarrage ou recourir à une émulation. Ne forcez pas une plateforme sans confirmer que l’image et ses dépendances la prennent en charge.
• Réseau : un port déjà occupé sur macOS empêche sa publication. À l’intérieur du réseau Compose, l’application doit joindre les services par leur nom, et non par localhost.
• Données : les fichiers écrits dans le système de fichiers éphémère d’un conteneur peuvent disparaître lorsque celui-ci est recréé. Les volumes nommés évitent ce piège pour les bases de données.
• Démarrage : lancer deux conteneurs ne signifie pas que la base est prête à accepter des connexions. Il faut distinguer l’ordre de lancement et l’état de santé du service.
• Accès et secrets : exposer un port sur l’hôte et placer un mot de passe dans un fichier de développement ne convient pas automatiquement à un environnement partagé ou de production.

Installer Docker Desktop et valider le moteur

Téléchargez l’installateur pour Apple Silicon depuis la page officielle d’installation de Docker Desktop pour Mac. Suivez l’assistant, validez les permissions demandées et ouvrez l’application. Si macOS indique que le système ne répond pas aux exigences, vérifiez les critères de la documentation officielle plutôt que de chercher à contourner le contrôle. Les conditions peuvent évoluer ; c’est la page d’installation de Docker qui fait foi, et non une ancienne capture d’écran ou un tutoriel réalisé sur une autre version de macOS.

Lorsque Docker Desktop indique que son moteur est démarré, ouvrez Terminal et exécutez :

docker version
docker compose version

La première commande doit afficher les informations du client et du serveur. Si elle ne présente que le client ou signale une erreur de connexion, le moteur n’est pas prêt : revenez à l’état de Docker Desktop avant de poursuivre. La seconde vérifie que la commande Compose est disponible. Compose permet de décrire plusieurs services et leurs paramètres dans un fichier unique, selon la référence officielle des services Compose.

Effectuez ensuite un essai sans application :

docker run --rm hello-world

Le conteneur doit afficher son message de confirmation, puis être supprimé par --rm. Cet essai permet de séparer un problème d’installation d’un problème ultérieur dans la configuration MySQL ou Web. Si cette commande échoue, ne passez pas encore à la configuration du projet : vérifiez d’abord que Docker Desktop est ouvert et que son moteur répond à docker version.

Comment installer Docker Desktop sur un Mac à puce M et confirmer son bon fonctionnement ? Récupérez l’installateur Apple Silicon depuis le site officiel de Docker, terminez l’installation, ouvrez Docker Desktop et attendez le démarrage du moteur. Confirmez ensuite la réponse du client et du serveur avec docker version, vérifiez Compose avec docker compose version, puis lancez le conteneur hello-world. Ces contrôles valident successivement l’interface, le moteur et une exécution simple.

Vérifier l’architecture avant de choisir les images

Comment vérifier qu’une image est compatible avec un Mac à puce M ? Inspectez les plateformes publiées, puis essayez l’image sans imposer de plateforme par défaut. Par exemple :

docker buildx imagetools inspect mysql:8.4
docker buildx imagetools inspect redis:7.4
docker run --rm mysql:8.4 --version

Comparez le résultat de l’inspection avec la documentation de l’éditeur. Les pages des images MySQL officielles et des images Redis officielles précisent leurs usages et variantes ; consultez-les avant de modifier un tag ou un paramètre d’architecture. Si le conteneur ne démarre pas, examinez son erreur et ses journaux. Une option de plateforme forcée ne remplace pas la vérification de la compatibilité des dépendances.

Une image peut afficher plusieurs plateformes disponibles. Dans ce cas, Docker choisit normalement la variante correspondante à l’environnement d’exécution. En revanche, un tag personnalisé, une image construite par une équipe ou une dépendance binaire particulière peut limiter les plateformes disponibles. Si le projet utilise une image interne, demandez quelle architecture a été publiée et inspectez-la avant de modifier le fichier Compose. C’est plus sûr que d’ajouter immédiatement un paramètre d’émulation qui masquerait la cause du problème.

Créer un projet Web Compose avec MySQL et Redis

L’exemple associe une application Python minimale à MySQL et Redis. Le conteneur Web vérifie l’accès à MySQL avec une requête simple et incrémente une clé Redis. Il sert à valider les connexions, pas à fournir un modèle d’application prêt pour la production.

Créez un dossier de projet et les fichiers suivants.

Dans .env, placez des valeurs réservées au développement local :

MYSQL_DATABASE=appdb
MYSQL_USER=app
MYSQL_PASSWORD=change-me-local
MYSQL_ROOT_PASSWORD=root-change-me

Remplacez ces chaînes avant tout partage du projet. Ne réutilisez pas ces exemples comme secrets réels. Évitez également de commettre un fichier .env contenant des identifiants dans un dépôt accessible à d’autres personnes.

Dans compose.yaml :

services:
  mysql:
    image: mysql:8.4
    environment:
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "mysqladmin ping -h 127.0.0.1 -uroot -p$${MYSQL_ROOT_PASSWORD} --silent"
        ]
      interval: 5s
      timeout: 3s
      retries: 10

  redis:
    image: redis:7.4
    command: ["redis-server", "--appendonly", "yes"]
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 10

  web:
    build: .
    environment:
      MYSQL_HOST: mysql
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
      REDIS_HOST: redis
    ports:
      - "8080:5000"
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_healthy

volumes:
  mysql_data:
  redis_data:

Les noms mysql, redis et web identifient les services. Compose les place sur son réseau de projet par défaut ; l’application contacte donc les bases avec mysql et redis comme noms d’hôte. Les ports publiés servent à accéder aux services depuis le Mac. Si un port est déjà occupé, vous pouvez changer la partie gauche du mappage, par exemple 3307:3306, puis utiliser le nouveau port pour une connexion depuis macOS. Depuis le conteneur Web, gardez les noms de service et les ports internes.

Les contrôles de santé et la condition service_healthy distinguent l’ordre de démarrage de la disponibilité réelle. Compose décrit ce comportement dans ses explications sur l’ordre de démarrage et les contrôles de santé. Les volumes nommés conservent les données de MySQL et Redis indépendamment du cycle de vie des conteneurs. Le mode append-only de Redis est activé ici pour que les écritures soient enregistrées dans son répertoire de données ; adaptez la persistance à l’objectif du projet et aux options décrites pour l’image Redis.

Ajoutez Dockerfile :

FROM python:3-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

Puis requirements.txt :

Flask
PyMySQL
redis

Et app.py :

import os

from flask import Flask, jsonify
import pymysql
import redis

app = Flask(__name__)

@app.get("/")
def index():
    connection = pymysql.connect(
        host=os.environ["MYSQL_HOST"],
        user=os.environ["MYSQL_USER"],
        password=os.environ["MYSQL_PASSWORD"],
        database=os.environ["MYSQL_DATABASE"],
        connect_timeout=3,
    )
    try:
        with connection.cursor() as cursor:
            cursor.execute("SELECT 1")
            mysql_result = cursor.fetchone()[0]
    finally:
        connection.close()

    cache = redis.Redis(
        host=os.environ["REDIS_HOST"],
        port=6379,
        decode_responses=True,
        socket_connect_timeout=3,
    )
    count = cache.incr("web_visits")

    return jsonify(mysql=mysql_result, redis_counter=count)

app.run(host="0.0.0.0", port=5000)

L’application écoute sur 0.0.0.0 dans le conteneur afin que le port publié soit accessible depuis le Mac. Les versions des bibliothèques Python ne sont pas figées dans cet exemple. Pour un projet d’équipe, verrouillez les dépendances et définissez leur méthode de mise à jour afin de rendre les reconstructions prévisibles.

Comment lancer MySQL et Redis avec Docker Compose sur Mac ? Depuis le dossier contenant compose.yaml, vérifiez d’abord la configuration, puis construisez et démarrez les services :

docker compose config
docker compose up -d --build
docker compose ps
docker compose logs --tail=80 mysql redis web

config permet de repérer les erreurs de syntaxe et les variables non résolues. Dans ps, les conteneurs doivent apparaître actifs et les contrôles de santé des bases doivent devenir sains. Si ce n’est pas le cas, lisez les journaux du service concerné avant de relancer toute la pile. Le nombre de lignes demandé par --tail limite simplement la sortie affichée ; augmentez-le si l’erreur apparaît plus tôt dans les journaux.

Depuis l’application Web, localhost désigne le conteneur Web lui-même. Pour joindre les autres services du projet, utilisez MYSQL_HOST=mysql et REDIS_HOST=redis, comme dans la configuration ci-dessus.

Comment déployer une application Web et la relier à MySQL et Redis ? Ouvrez http://localhost:8080 dans le navigateur du Mac, ou lancez :

curl http://localhost:8080

La réponse JSON doit contenir le résultat de la requête MySQL et un compteur Redis. En relançant la requête, le compteur doit progresser. Cette vérification montre que l’application contacte les deux services via le réseau Compose et que la publication du port Web permet d’y accéder depuis macOS.

Si la page ne répond pas, vérifiez le port publié avec docker compose ps, puis consultez les journaux Web. Si l’application est joignable mais renvoie une erreur de base de données, vérifiez les variables, les noms d’hôtes des services et l’état de santé de MySQL. Une réponse de l’application ne prouve pas, à elle seule, que les données survivront à la suppression des conteneurs ; testez séparément les volumes.

Contrôler les données et diagnostiquer les échecs

Pour vérifier MySQL indépendamment de l’application, exécutez :

docker compose exec mysql \
  mysql -uapp -pchange-me-local appdb -e "SELECT 1;"

Pour vérifier Redis depuis son propre conteneur :

docker compose exec redis redis-cli SET essai persistant
docker compose exec redis redis-cli GET essai

Le résultat de GET doit être persistant. Redémarrez ensuite les services, puis relisez la clé :

docker compose down
docker compose up -d
docker compose exec redis redis-cli GET essai

docker compose down conserve les volumes nommés par défaut. En revanche, docker compose down -v les supprime : ne l’utilisez pas si vous souhaitez garder les données de ce projet. Les réglages de la base MySQL en conteneur suivent également les instructions de son guide Docker officiel. Pour vérifier la persistance de MySQL, créez une donnée de test, recréez les conteneurs sans effacer les volumes, puis relancez la requête.

En cas d’échec, procédez dans cet ordre : vérifiez d’abord l’état du moteur et la configuration Compose ; identifiez ensuite le conteneur concerné avec docker compose ps ; lisez ses journaux ; testez enfin le port ou la connexion depuis le bon contexte, hôte ou conteneur. Cette progression évite de modifier simultanément l’image, les variables et le réseau, ce qui rendrait la cause plus difficile à isoler.

Vérifier la pile avant de choisir son environnement

• [ ] Docker Desktop est démarré et docker version affiche le client ainsi que le serveur.
• [ ] docker compose config termine sans erreur ni variable manquante.
• [ ] Les plateformes des images ont été vérifiées auprès de leurs éditeurs et avec l’inspection des images.
• [ ] docker compose ps montre les services attendus et les bases sont saines.
• [ ] La page Web répond sur le port publié du Mac.
• [ ] L’application obtient une réponse MySQL et incrémente une valeur Redis.
• [ ] Les données restent disponibles après un redémarrage effectué sans supprimer les volumes.
• [ ] Aucun mot de passe d’exemple ni port inutilement exposé n’est conservé pour un environnement partagé.

Un Mac local reste le choix le plus simple si l’équipe développe sur ce poste et peut laisser les services tourner. Ses limites sont la disponibilité de la machine, les conflits de ports et la dépendance aux ressources locales. Si ces contraintes compliquent les constructions ou le développement à distance, comparez votre besoin avec les informations sur la location de Mac distant au Japon et la location de Mac distant à Singapour, puis vérifiez les conditions correspondant à votre usage. Nous ne supposons ici ni configuration ni capacité particulière. Pour une pile qui doit rester disponible en continu ou qui dépend d’interfaces physiques, la location n’est pas automatiquement préférable : choisissez l’environnement en fonction des exigences réelles du projet.