QuickStart: Déployer une application Docker Compose sur Elastic Beanstalk

Ce QuickStart didacticiel explique le processus de création d'une application Docker Compose multi-conteneurs et de son déploiement dans un AWS Elastic Beanstalk environnement. Vous allez créer une application Web Flask avec un proxy inverse nginx pour montrer comment Docker Compose simplifie l'orchestration de plusieurs conteneurs.

Votre AWS compte

Si vous n'êtes pas encore AWS client, vous devez créer un AWS compte. L'inscription vous permet d'accéder à Elastic Beanstalk AWS et aux autres services dont vous avez besoin.

Si vous avez déjà un AWS compte, vous pouvez passer àPrérequis.

Prérequis

Pour suivre les procédures décrites dans ce guide, vous aurez besoin d'un shell ou d'un terminal de ligne de commande pour exécuter des commandes. Dans les listes, les commandes sont précédées d'un symbole d'invite ($) et du nom du répertoire actuel, le cas échéant.

~/eb-project$ this is a command
this is output

Sous Linux et macOS, vous pouvez utiliser le shell et le gestionnaire de package de votre choix. Sur Windows, vous pouvez installer le sous-système Windows pour Linux afin d'obtenir une version intégrée à Windows d'Ubuntu et de Bash.

INTERFACE DE LIGNE DE COMMANDE (CLI) EB

Ce tutoriel utilise également l'interface de ligne de commande Elastic Beanstalk (CLI EB). Pour de plus amples informations sur l'installation et la configuration de la CLI EB, veuillez consulter Installation de la CLI EB avec un script de configuration (recommandé) et Configuration de l'interface de ligne de commande EB.

Docker et Docker Compose

Pour suivre ce didacticiel, vous aurez besoin d'une installation locale fonctionnelle de Docker et Docker Compose. Pour plus d'informations, consultez Télécharger Docker et installer Docker Compose sur le site Web de documentation de Docker.

Vérifiez que Docker et Docker Compose sont installés et en cours d'exécution en exécutant les commandes suivantes.

~$ docker info
~$ docker compose version

Étape 1 : créer une application Docker Compose

Dans cet exemple, nous créons une application multi-conteneurs à l'aide de Docker Compose composée d'une application Web Flask et d'un proxy inverse nginx. Cela montre comment Docker Compose simplifie l'orchestration de plusieurs conteneurs qui fonctionnent ensemble.

L'application inclut une configuration de surveillance de l'état qui permet à Elastic Beanstalk de collecter des métriques d'application détaillées à partir de votre proxy nginx.

La structure de l'application est la suivante :

~/eb-docker-compose-flask/
|-- docker-compose.yml
|-- web/
|   |-- Dockerfile
|   |-- app.py
|   `-- requirements.txt
|-- proxy/
|   |-- Dockerfile
|   `-- nginx.conf
`-- .platform/
    `-- hooks/
        `-- postdeploy/
            `-- 01_setup_healthd_permissions.sh

Créez la structure du répertoire et ajoutez les fichiers suivants :

Créez d'abord le docker-compose.yml fichier principal qui définit les services et leurs relations.

services:
  web:
    build: ./web
    expose:
      - "5000"

  nginx-proxy:
    build: ./proxy
    ports:
      - "80:80"
    volumes:
      - "/var/log/nginx:/var/log/nginx"
    depends_on:
      - web

Créez l'application Web Flask dans le web répertoire. Ajoutez le contenu suivant à votre app.py fichier.

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello Elastic Beanstalk! This is a Docker Compose application'

Ajoutez le contenu suivant à votre service WebDockerfile.

FROM public.ecr.aws/docker/library/python:3.12
COPY . /app
WORKDIR /app
RUN pip install Flask==3.1.1
EXPOSE 5000
CMD [ "python3", "-m" , "flask", "run", "--host=0.0.0.0"]

Créez le proxy inverse nginx dans le répertoire. proxy Ajoutez le contenu suivant à votre nginx.conf fichier.

Cette configuration inclut une configuration de surveillance de l'état qui permet à Elastic Beanstalk de collecter des métriques détaillées sur les applications. Pour plus d'informations sur la personnalisation des formats des journaux de surveillance de l'état, consultezFormat de journal d'intégrité améliorée.

events {
    worker_connections 1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    map $http_upgrade $connection_upgrade {
        default       "upgrade";
    }

    # Health monitoring log format for Elastic Beanstalk
    log_format healthd '$msec"$uri"$status"$request_time"$upstream_response_time"$http_x_forwarded_for';
    
    upstream flask_app {
        server web:5000;
    }

    server {
        listen 80 default_server;
        root /usr/share/nginx/html;

        # Standard access log
        access_log /var/log/nginx/access.log;
        
        # Health monitoring log for Elastic Beanstalk
        if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
            set $year $1;
            set $month $2;
            set $day $3;
            set $hour $4;
        }
        access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
        
        location / {
            proxy_pass http://flask_app;
            proxy_http_version    1.1;

            proxy_set_header    Connection             $connection_upgrade;
            proxy_set_header    Upgrade                $http_upgrade;
            proxy_set_header    Host                   $host;
            proxy_set_header    X-Real-IP              $remote_addr;
            proxy_set_header    X-Forwarded-For        $proxy_add_x_forwarded_for;
        }
    }
}

Ajoutez le contenu suivant à votre service proxyDockerfile.

FROM public.ecr.aws/nginx/nginx:alpine
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80

Enfin, créez un script de connexion à la plateforme pour configurer les répertoires de journaux et les autorisations nécessaires à la surveillance de l'état de santé. Les hooks de plateforme vous permettent d'exécuter des scripts personnalisés pendant le processus de déploiement. Pour plus d'informations sur les hooks de plateforme, consultezHooks de plateforme.

#!/bin/bash
set -ex

NGINX_CONTAINER=$(docker ps --filter "name=nginx-proxy" -q)

if [ -z "$NGINX_CONTAINER" ]; then
    echo "Error: No nginx-proxy container found running"
    exit 1
fi

NGINX_UID=$(docker exec ${NGINX_CONTAINER} id -u nginx)
NGINX_GID=$(docker exec ${NGINX_CONTAINER} id -g nginx)

mkdir -p /var/log/nginx/healthd
chown -R ${NGINX_UID}:${NGINX_GID} /var/log/nginx

Étape 2 : Exécutez votre application localement

Utilisez la commande docker compose up pour créer et exécuter votre application multi-conteneurs localement. Docker Compose créera les deux images de conteneur et démarrera les services définis dans votre docker-compose.yml fichier.

~/eb-docker-compose-flask$ docker compose up --build

--buildCette option garantit que Docker Compose crée les images du conteneur avant de démarrer les services. Vous devriez voir une sortie indiquant le démarrage du service Web et du service nginx-proxy.

Accédez à http://localhost dans votre navigateur. Vous devriez voir le texte « Hello Elastic Beanstalk ! Il s'agit d'une application Docker Compose ». Le proxy nginx reçoit votre demande sur le port 80 et la transmet à l'application Flask exécutée sur le port 5000.

Lorsque vous avez terminé le test, arrêtez l'application Ctrl+C en appuyant sur le terminal ou exécutez la commande suivante dans un autre terminal :

~/eb-docker-compose-flask$ docker compose down

Étape 3 : Déployez votre application Docker Compose avec l'EB CLI

Exécutez les commandes suivantes pour créer un environnement Elastic Beanstalk pour cette application.

Étape 4 : Testez votre application sur Elastic Beanstalk

Lorsque le processus de création de votre environnement est terminé, ouvrez votre site Web aveceb open.

~/eb-docker-compose-flask$ eb open

Excellent ! Vous avez déployé une application Docker Compose multi-conteneurs avec Elastic Beanstalk ! Celle-ci ouvre une fenêtre de navigation en utilisant le nom de domaine créé pour votre application. Vous devriez voir le message de votre application Flask, diffusé via le proxy inverse nginx.

Étape 5 : nettoyer

Vous pouvez mettre fin à votre environnement lorsque vous avez fini d'utiliser votre application. Elastic Beanstalk AWS met fin à toutes les ressources associées à votre environnement.

Pour mettre fin à votre environnement Elastic Beanstalk avec l'EB CLI, exécutez la commande suivante.

~/eb-docker-compose-flask$ eb terminate

AWS ressources pour votre application

Vous venez de créer une seule instance d'application exécutant plusieurs conteneurs. Il s'agit d'un exemple d'application simple avec une seule EC2 instance, il ne nécessite donc pas d'équilibrage de charge ni de dimensionnement automatique. Pour les applications à instance unique, Elastic Beanstalk crée les ressources suivantes : AWS

Elastic Beanstalk gère toutes ces ressources. Lorsque vous arrêtez votre environnement, Elastic Beanstalk arrête toutes les ressources qu'il contient. Votre application Docker Compose exécute plusieurs conteneurs sur une seule EC2 instance, Elastic Beanstalk gérant automatiquement l'orchestration.

Étapes suivantes

Dès que vous disposez d'un environnement exécutant une application, vous pouvez à tout moment déployer une nouvelle version de l'application ou une application totalement différente. Le déploiement d'une nouvelle version d'application est très rapide car il ne nécessite ni le provisionnement ni le redémarrage des instances. EC2 Vous pouvez également explorer votre nouvel environnement à l'aide de la console Elastic Beanstalk. Pour connaître les étapes détaillées, consultez la section Explorez votre environnement dans le chapitre Mise en route de ce guide.

Une fois que vous avez déployé un ou deux exemples d'applications et que vous êtes prêt à commencer à développer et à exécuter des applications Docker Compose localement, consultezPréparation de votre image Docker pour le déploiement sur Elastic Beanstalk.

Déployez avec la console Elastic Beanstalk

Vous pouvez également utiliser la console Elastic Beanstalk pour lancer une application Docker Compose. Créez un fichier ZIP contenant votre docker-compose.yml fichier ainsi que tous les répertoires et fichiers associés, puis téléchargez-le lors de la création d'une nouvelle application. Pour connaître les étapes détaillées, voir Création d'un exemple d'application dans le chapitre Mise en route de ce guide.