QuickStart: Stellen Sie eine Docker Compose-Anwendung auf Elastic Beanstalk bereit

Dieses QuickStart Tutorial führt Sie durch den Prozess der Erstellung einer Docker Compose-Anwendung mit mehreren Containern und deren Bereitstellung in einer Umgebung. AWS Elastic Beanstalk Sie erstellen eine Flask-Webanwendung mit einem Nginx-Reverse-Proxy, um zu demonstrieren, wie Docker Compose die Orchestrierung mehrerer Container vereinfacht.

Ihre AWS Konto

Wenn Sie noch kein AWS Kunde sind, müssen Sie ein AWS Konto erstellen. Wenn Sie sich registrieren, können Sie auf Elastic Beanstalk und andere AWS Dienste zugreifen, die Sie benötigen.

Wenn Sie bereits ein AWS Konto haben, können Sie weitermachen zu. Voraussetzungen

Voraussetzungen

Um die Verfahren in diesem Leitfaden zu befolgen, benötigen Sie ein Befehlszeilen-Terminal oder eine Shell für die Ausführung der Befehle. Befehle werden ggf. in Auflistungen mit einem vorangestellten Eingabeaufforderungssymbol ($) und dem Namen des aktuellen Verzeichnisses angezeigt.

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

In Linux und macOS können Sie Ihren bevorzugten Shell- und Paket-Manager verwenden. Unter Windows können Sie das Windows-Subsystem für Linux installieren, um eine Windows-integrated Version von Ubuntu und Bash zu erhalten.

EB-CLI

Dieses Tutorial verwendet die Befehlszeilenschnittstelle Elastic Beanstalk Command Line Interface (EB CLI). Detaillierte Anweisungen zum Installieren und Konfigurieren der EB CLI finden Sie unter EB CLI mit Setup-Skript installieren (empfohlen) und Konfigurieren der EB CLI.

Docker und Docker Compose

Um diesem Tutorial zu folgen, benötigen Sie eine funktionierende lokale Installation von Docker und Docker Compose. Weitere Informationen finden Sie unter Docker herunterladen und Docker Compose installieren auf der Docker-Dokumentationswebsite.

Stellen Sie sicher, dass Docker und Docker Compose installiert sind und ausgeführt werden, indem Sie die folgenden Befehle ausführen.

~$ docker info
~$ docker compose version

Schritt 1: Erstellen Sie eine Docker Compose-Anwendung

In diesem Beispiel erstellen wir mit Docker Compose eine Multicontainer-Anwendung, die aus einer Flask-Webanwendung und einem Nginx-Reverse-Proxy besteht. Dies zeigt, wie Docker Compose die Orchestrierung mehrerer Container vereinfacht, die zusammenarbeiten.

Die Anwendung beinhaltet eine Konfiguration zur Gesundheitsüberwachung, die es Elastic Beanstalk ermöglicht, detaillierte Anwendungsmetriken von Ihrem Nginx-Proxy zu sammeln.

Die Anwendung besteht aus der folgenden Struktur:

~/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

Erstellen Sie die Verzeichnisstruktur und fügen Sie die folgenden Dateien hinzu:

Erstellen Sie zunächst die docker-compose.yml Hauptdatei, die die Dienste und ihre Beziehungen definiert.

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

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

Erstellen Sie die Flask-Webanwendung im Verzeichnis. web Fügen Sie Ihrer app.py Datei den folgenden Inhalt hinzu.

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

Fügen Sie Ihrem Webservice die folgenden Inhalte hinzu. Dockerfile

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"]

Erstellen Sie den Nginx-Reverse-Proxy im proxy Verzeichnis. Fügen Sie Ihrer Datei den folgenden Inhalt hinzunginx.conf.

Diese Konfiguration beinhaltet eine Einrichtung zur Gesundheitsüberwachung, die es Elastic Beanstalk ermöglicht, detaillierte Anwendungsmetriken zu sammeln. Weitere Informationen zur Anpassung der Protokollformate für die Gesundheitsüberwachung finden Sie unter. Format der Protokolle der erweiterten Zustandsberichte

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;
        }
    }
}

Fügen Sie Ihrem Proxy-Service die folgenden Inhalte hinzu. Dockerfile

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

Erstellen Sie abschließend ein Plattform-Hook-Skript, um die erforderlichen Protokollverzeichnisse und Berechtigungen für die Zustandsüberwachung einzurichten. Plattform-Hooks ermöglichen es Ihnen, während des Bereitstellungsprozesses benutzerdefinierte Skripts auszuführen. Weitere Informationen zu Plattform-Hooks finden Sie unterPlattform-Hooks.

#!/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

Schritt 2: Führen Sie Ihre Anwendung lokal aus

Verwenden Sie den Befehl docker compose up, um Ihre Multicontainer-Anwendung lokal zu erstellen und auszuführen. Docker Compose erstellt beide Container-Images und startet die in Ihrer Datei definierten Dienste. docker-compose.yml

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

Die --build Option stellt sicher, dass Docker Compose die Container-Images erstellt, bevor die Dienste gestartet werden. Sie sollten eine Ausgabe sehen, die zeigt, dass sowohl der Webdienst als auch der Nginx-Proxy-Service gestartet werden.

Navigieren Sie http://localhost in Ihrem Browser zu. Du solltest den Text „Hello Elastic Beanstalk! Dies ist eine Docker Compose-Anwendung“. Der Nginx-Proxy empfängt Ihre Anfrage auf Port 80 und leitet sie an die Flask-Anwendung weiter, die auf Port 5000 läuft.

Wenn Sie mit dem Testen fertig sind, beenden Sie die Anwendung, indem Sie Ctrl+C im Terminal drücken, oder führen Sie den folgenden Befehl in einem separaten Terminal aus:

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

Schritt 3: Stellen Sie Ihre Docker Compose-Anwendung mit der EB CLI bereit

Führen Sie die folgenden Befehle aus, um eine Elastic Beanstalk Beanstalk-Umgebung für diese Anwendung zu erstellen.

Schritt 4: Testen Sie Ihre Anwendung auf Elastic Beanstalk

Wenn der Prozess zur Erstellung Ihrer Umgebung abgeschlossen ist, öffnen Sie Ihre Website mit. eb open

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

Großartig! Sie haben eine Docker Compose-Anwendung mit mehreren Containern mit Elastic Beanstalk bereitgestellt! Es wird ein Browserfenster mit dem für die Anwendung erstellten Domainnamen geöffnet. Sie sollten die Nachricht von Ihrer Flask-Anwendung sehen, die über den Nginx-Reverse-Proxy bereitgestellt wird.

Schritt 5: Bereinigen

Sie können Ihre Umgebung beenden, wenn Sie mit der Arbeit an Ihrer Anwendung fertig sind. Elastic Beanstalk beendet alle AWS Ressourcen, die mit Ihrer Umgebung verknüpft sind.

Führen Sie den folgenden Befehl aus, um Ihre Elastic Beanstalk Beanstalk-Umgebung mit der EB-CLI zu beenden.

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

AWS Ressourcen für Ihre Anwendung

Sie haben gerade eine Einzelinstanzanwendung erstellt, auf der mehrere Container ausgeführt werden. Es dient als einfache Beispielanwendung mit einer einzigen EC2-Instance, sodass kein Lastenausgleich oder auto Skalierung erforderlich sind. Für Einzelinstanzanwendungen erstellt Elastic Beanstalk die folgenden Ressourcen: AWS

Elastic Beanstalk verwaltet all diese Ressourcen. Wenn Sie die Umgebung beenden, werden alle darin enthaltenen Ressourcen von Elastic Beanstalk beendet. Ihre Docker Compose-Anwendung führt mehrere Container auf einer einzigen EC2-Instance aus, wobei Elastic Beanstalk die Orchestrierung automatisch übernimmt.

Nächste Schritte

Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen. Sie können Ihre neue Umgebung auch mit der Elastic Beanstalk Beanstalk-Konsole erkunden. Ausführliche Schritte finden Sie unter Erkunden Sie Ihre Umgebung im Kapitel Erste Schritte dieses Handbuchs.

Nachdem Sie ein oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, mit der lokalen Entwicklung und Ausführung von Docker Compose-Anwendungen zu beginnen, finden Sie unterVorbereiten Ihres Docker-Images für die Bereitstellung auf Elastic Beanstalk.

Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole

Sie können auch die Elastic Beanstalk Beanstalk-Konsole verwenden, um eine Docker Compose-Anwendung zu starten. Erstellen Sie eine ZIP-Datei, die Ihre docker-compose.yml Datei und alle zugehörigen Verzeichnisse und Dateien enthält, und laden Sie sie dann hoch, wenn Sie eine neue Anwendung erstellen. Eine ausführliche Anleitung dazu finden Sie unter Erstellen einer Beispielanwendung im Kapitel Erste Schritte dieses Handbuchs.