QuickStart: Menerapkan aplikasi Docker Compose ke Elastic Beanstalk

QuickStart Tutorial ini memandu Anda melalui proses pembuatan aplikasi Docker Compose multi-container dan menerapkannya ke lingkungan. AWS Elastic Beanstalk Anda akan membuat aplikasi web Flask dengan proxy nginx reverse untuk menunjukkan bagaimana Docker Compose menyederhanakan orkestrasi beberapa container.

Klaster AWS akun

Jika Anda belum menjadi AWS pelanggan, Anda perlu membuat AWS akun. Mendaftar memungkinkan Anda mengakses Elastic Beanstalk AWS dan layanan lain yang Anda butuhkan.

Jika Anda sudah memiliki AWS akun, Anda dapat melanjutkan kePrasyarat.

Prasyarat

Untuk mengikuti prosedur di panduan ini, Anda memerlukan terminal atau shell baris perintah untuk menjalankan perintah. Perintah ditampilkan dalam daftar yang diawali dengan simbol prompt ($) dan nama direktori saat ini, bila perlu.

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

Di Linux dan macOS, Anda dapat menggunakan shell dan manajer paket pilihan Anda. Pada Windows Anda dapat menginstal Windows Subsystem untuk Linux untuk mendapatkan Windows-integrated versi Ubuntu dan Bash.

EB CLI

Tutorial ini menggunakan Elastic Beanstalk Command Line Interface (EB CLI). Untuk detail tentang pemasangan dan konfigurasi EB CLI, lihat Instal EB CLI dengan skrip pengaturan (disarankan) dan Mengonfigurasi EB CLI.

Docker dan Docker Compose

Untuk mengikuti tutorial ini, Anda memerlukan instalasi lokal Docker dan Docker Compose yang berfungsi. Untuk informasi selengkapnya, lihat Mendapatkan Docker dan Instal Docker Compose di situs web dokumentasi Docker.

Verifikasi bahwa Docker dan Docker Compose diinstal dan dijalankan dengan menjalankan perintah berikut.

~$ docker info
~$ docker compose version

Langkah 1: Buat aplikasi Docker Compose

Untuk contoh ini, kita membuat aplikasi multi-container menggunakan Docker Compose yang terdiri dari aplikasi web Flask dan nginx reverse proxy. Ini menunjukkan bagaimana Docker Compose menyederhanakan orkestrasi beberapa kontainer yang bekerja bersama.

Aplikasi ini mencakup konfigurasi pemantauan kesehatan yang memungkinkan Elastic Beanstalk mengumpulkan metrik aplikasi terperinci dari proxy nginx Anda.

Aplikasi ini terdiri dari struktur berikut:

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

Buat struktur direktori dan tambahkan file-file berikut:

Pertama, buat docker-compose.yml file utama yang mendefinisikan layanan dan hubungannya.

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

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

Buat aplikasi web Flask di web direktori. Tambahkan konten berikut ke app.py file Anda.

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

Tambahkan konten berikut ke layanan web AndaDockerfile.

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

Buat proxy terbalik nginx di direktori. proxy Tambahkan konten berikut ke nginx.conf file Anda.

Konfigurasi ini mencakup pengaturan pemantauan kesehatan yang memungkinkan Elastic Beanstalk mengumpulkan metrik aplikasi terperinci. Untuk informasi selengkapnya tentang menyesuaikan format log pemantauan kesehatan, lihatFormat log kondisi yang ditingkatkan.

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

Tambahkan konten berikut ke layanan proxy AndaDockerfile.

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

Terakhir, buat skrip hook platform untuk mengatur direktori log yang diperlukan dan izin untuk pemantauan kesehatan. Kait platform memungkinkan Anda menjalankan skrip khusus selama proses penerapan. Untuk informasi selengkapnya tentang kait platform, lihatHook platform.

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

Langkah 2: Jalankan aplikasi Anda secara lokal

Gunakan perintah docker compose up untuk membangun dan menjalankan aplikasi multi-container Anda secara lokal. Docker Compose akan membangun kedua image kontainer dan memulai layanan yang ditentukan dalam file Andadocker-compose.yml.

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

--buildOpsi ini memastikan bahwa Docker Compose membangun image container sebelum memulai layanan. Anda akan melihat output yang menunjukkan layanan web dan layanan nginx-proxy dimulai.

Arahkan ke http://localhost di browser Anda. Anda akan melihat teks “Halo Elastic Beanstalk! Ini adalah aplikasi Docker Compose”. Proxy nginx menerima permintaan Anda pada port 80 dan meneruskannya ke aplikasi Flask yang berjalan pada port 5000.

Setelah selesai menguji, hentikan aplikasi dengan menekan Ctrl+C terminal, atau jalankan perintah berikut di terminal terpisah:

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

Langkah 3: Terapkan aplikasi Docker Compose Anda dengan EB CLI

Jalankan perintah berikut untuk membuat lingkungan Elastic Beanstalk untuk aplikasi ini.

Langkah 4: Uji aplikasi Anda pada Elastic Beanstalk

Ketika proses untuk membuat lingkungan Anda selesai, buka situs web Anda denganeb open.

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

Bagus! Anda telah menerapkan aplikasi Docker Compose multi-kontainer dengan Elastic Beanstalk! Ini akan membuka jendela peramban menggunakan nama domain yang dibuat untuk aplikasi Anda. Anda akan melihat pesan dari aplikasi Flask Anda, disajikan melalui proxy terbalik nginx.

Langkah 5: Bersihkan

Anda dapat menghentikan lingkungan Anda ketika Anda selesai bekerja dengan aplikasi Anda. Elastic Beanstalk AWS mengakhiri semua sumber daya yang terkait dengan lingkungan Anda.

Untuk mengakhiri lingkungan Elastic Beanstalk Anda dengan EB CLI jalankan perintah berikut.

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

AWS sumber daya untuk aplikasi Anda

Anda baru saja membuat aplikasi instance tunggal yang menjalankan beberapa kontainer. Ini berfungsi sebagai aplikasi sampel langsung dengan satu instans EC2, sehingga tidak memerlukan penyeimbangan beban atau penskalaan otomatis. Untuk aplikasi contoh tunggal Elastic Beanstalk menciptakan sumber daya berikut: AWS

Elastic Beanstalk mengelola semua sumber daya tersebut. Ketika Anda mengakhiri lingkungan, Elastic Beanstalk mengakhiri semua sumber daya yang dimuatnya. Aplikasi Docker Compose Anda menjalankan beberapa kontainer pada instans EC2 tunggal, dengan Elastic Beanstalk menangani orkestrasi secara otomatis.

Langkah selanjutnya

Setelah lingkungan Anda menjalankan aplikasi, Anda dapat men-deploy versi baru aplikasi atau aplikasi yang berbeda kapan saja. Men-deploy versi aplikasi baru itu sangat cepat karena tidak memerlukan persediaan atau memulai ulang instans EC2. Anda juga dapat menjelajahi lingkungan baru Anda menggunakan konsol Elastic Beanstalk. Untuk langkah-langkah mendetail, lihat Menjelajahi lingkungan Anda di bagian Memulai panduan ini.

Setelah Anda menerapkan satu atau dua contoh aplikasi dan siap untuk mulai mengembangkan dan menjalankan aplikasi Docker Compose secara lokal, lihat. Mempersiapkan image Docker Anda untuk penyebaran ke Elastic Beanstalk

Terapkan dengan konsol Elastic Beanstalk

Anda juga dapat menggunakan konsol Elastic Beanstalk untuk meluncurkan aplikasi Docker Compose. Buat file ZIP yang berisi docker-compose.yml file Anda dan semua direktori dan file terkait, lalu unggah saat membuat aplikasi baru. Untuk langkah-langkah rinci, lihat Membuat aplikasi contoh di Bab Memulai panduan ini.