ECS-verwaltete Docker-Umgebungen mit der Elastic-Beanstalk-Konsole

Sie können einen Cluster aus Multi-Container-Instances in einer Single-Instance-Umgebung oder einer skalierbaren Elastic-Beanstalk-Umgebung mit der Elastic-Beanstalk-Konsole launchen. In diesem Tutorial werden Details zur Container-Konfiguration und zur Vorbereitung des Quellcodes für eine Umgebung mit zwei Containern beschrieben.

Die Container, eine PHP-Anwendung und ein nginx-Proxy werden parallel auf jeder der Amazon Elastic Compute Cloud-Instances (Amazon EC2) in einer Elastic Beanstalk-Umgebung ausgeführt. Nach dem Erstellen der Umgebung und der Überprüfung, ob die Anwendungen ausgeführt werden, müssen Sie eine Verbindung zu einer Container-Instance herstellen, um zu sehen, ob alles zusammenpasst.

Definieren von ECS-verwalteten Docker-Containern

Der erste Schritt beim Erstellen einer neuen Docker-Umgebung ist das Erstellen eines Verzeichnisses für Ihre Anwendungsdaten. Dieser Ordner kann sich in einem beliebigen Verzeichnis auf Ihrem lokalen Computer befinden und einen beliebigen Namen haben. Zusätzlich zu einer Container-Konfigurationsdatei enthält dieser Ordner den Inhalt, den Sie in Elastic Beanstalk hochladen und für Ihre Umgebung bereitstellen.

Anmerkung

Der Code für dieses Tutorial ist im "awslabs"-Repository auf GitHub unter https://github.com/awslabs/eb-docker-nginx-proxy verfügbar.

Die Datei, die Elastic Beanstalk zum Konfigurieren der Container auf einer Amazon EC2-Instance verwendet, ist eine JSON-formatierte Textdatei mit dem Namen Dockerrun.aws.json. Erstellen Sie eine Textdatei mit diesem Namen im Stammverzeichnis Ihrer Anwendung und fügen Sie den folgenden Text hinzu:

{
  "AWSEBDockerrunVersion": 2,
  "volumes": [
    {
      "name": "php-app",
      "host": {
        "sourcePath": "/var/app/current/php-app"
      }
    },
    {
      "name": "nginx-proxy-conf",
      "host": {
        "sourcePath": "/var/app/current/proxy/conf.d"
      }
    }  
  ],
  "containerDefinitions": [
    {
      "name": "php-app",
      "image": "php:fpm",
      "essential": true,
      "memory": 128,
      "mountPoints": [
        {
          "sourceVolume": "php-app",
          "containerPath": "/var/www/html",
          "readOnly": true
        }
      ]
    },
    {
      "name": "nginx-proxy",
      "image": "nginx",
      "essential": true,
      "memory": 128,
      "portMappings": [
        {
          "hostPort": 80,
          "containerPort": 80
        }
      ],
      "links": [
        "php-app"
      ],
      "mountPoints": [
        {
          "sourceVolume": "php-app",
          "containerPath": "/var/www/html",
          "readOnly": true
        },
        {
          "sourceVolume": "nginx-proxy-conf",
          "containerPath": "/etc/nginx/conf.d",
          "readOnly": true
        },
        {
          "sourceVolume": "awseb-logs-nginx-proxy",
          "containerPath": "/var/log/nginx"
        }
      ]
    }
  ]
}

In dieser Beispielkonfiguration werden zwei Container definiert, eine PHP-Website mit einem nginx-Proxy davor. Diese beiden Containern werden parallel in Docker-Containern auf jeder Instance in Ihrer Elastic Beanstalk-Umgebung ausgeführt. Dabei greifen sie auf gemeinsame Inhalte (die Inhalte der Website) aus Volumes auf der Host-Instance zu, die auch in dieser Datei definiert sind. Die Container selbst werden aus Images erstellt, die in offiziellen Repositorys auf Docker Hub gehostet werden. Die sich ergebende Umgebung sieht wie folgt aus:

Die Volumes in der Konfiguration entsprechen dem Inhalt, den Sie als Nächstes erstellen und als Teil Ihres Anwendungs-Quell-Bundle hochladen. Die Container greifen auf Inhalt auf dem Host zu, indem Volumes im mountPoints-Abschnitt der Container-Definitionen gemountet werden.

Weitere Informationen zum Format von Dockerrun.aws.json und dessen Parametern finden Sie unter Format der Containerdefinition.

Inhalte hinzufügen

Als Nächstes fügen Sie einige Inhalte für Ihre PHP-Website hinzu, um sie für Besucher anzuzeigen, und eine Konfigurationsdatei für den nginx-Proxy.

php-app/index.php

<h1>Hello World!!!</h1>
<h3>PHP Version <pre><?= phpversion()?></pre></h3>

php-app/static.html

<h1>Hello World!</h1>
<h3>This is a static HTML page.</h3>

proxy/conf.d/default.conf

server {
  listen 80;
  server_name localhost;
  root /var/www/html;
 
  index index.php;
 
  location ~ [^/]\.php(/|$) {
    fastcgi_split_path_info ^(.+?\.php)(/.*)$;
    if (!-f $document_root$fastcgi_script_name) {
      return 404;
    }

    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_param PATH_INFO $fastcgi_path_info;
    fastcgi_param PATH_TRANSLATED $document_root$fastcgi_path_info;

    fastcgi_pass php-app:9000;
    fastcgi_index index.php;
  }
}

Bereitstellen in Elastic Beanstalk

Ihr Anwendungsordner enthält nun die folgenden Dateien:

├── Dockerrun.aws.json
├── php-app
│   ├── index.php
│   └── static.html
└── proxy
    └── conf.d
        └── default.conf

Dies ist alles, was Sie benötigen, um die Elastic Beanstalk-Umgebung zu erstellen. Erstellen Sie ein .zip-Archiv der obigen Dateien und Ordner (nicht im Projektordner der obersten Ebene enthalten). Zum Erstellen des Archivs in Windows Explorer wählen Sie den Inhalt des Projektordners, klicken Sie mit der rechten Maustaste, wählen Sie Send To (Senden an) und klicken Sie dann auf Compressed (zipped) Folder (Komprimierter (gezippter) Ordner).

Anmerkung

Weitere Informationen über die erforderliche Dateistruktur und Anweisungen für die Erstellung von Archiven in anderen Umgebungen finden Sie unter Erstellen des Quell-Bundles einer Anwendung.

Laden Sie als Nächstes das Quell-Bundle in Elastic Beanstalk hoch und erstellen Sie Ihre Umgebung. Wählen Sie für Platform (Plattform) die Option Docker aus. Wählen Sie für Platform branch (Plattformzweig) ECS auf Amazon Linux 2 mit 64 Bit aus.

So starten Sie eine Umgebung (Konsole)

1. Öffnen Sie die Elastic Beanstalk-Konsole mit diesem vorkonfigurierten Link: console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced

2. Wählen Sie für Platform (Plattform) die Plattform und den Plattformzweig aus, die der von Ihrer Anwendung verwendeten Sprache entsprechen, oder die Docker-Plattform für containerbasierte Anwendungen.

3. Wählen Sie für Application code (Anwendungscode) die Option Upload your code (Eigenen Code hochladen).

4. Wählen Sie Local file (Lokale Datei), wählen Sie Choose file (Datei wählen) und öffnen Sie das Quell-Bundle.

5. Klicken Sie auf Review and launch (Überprüfen und starten).

6. Prüfen Sie die verfügbaren Einstellungen und wählen Sie Create app (Anwendung erstellen) aus.

Die Elastic Beanstalk-Konsole leitet Sie zum Verwaltungs-Dashboard für die neue Umgebung um. Dieser Bildschirm zeigt den Status der Umgebung und Ereignisse, die vom Elastic Beanstalk-Service ausgegeben werden. Wenn der Status grün ist, klicken Sie auf die URL neben dem Umgebungsnamen, um Ihre neue Website anzuzeigen.

Verbinden mit einer Container-Instance

Als Nächstes stellen Sie eine Verbindung zu einer Amazon EC2-Instance in Ihrer Elastic Beanstalk-Umgebung her, um einige der beweglichen Teile in Aktion zu sehen.

Am einfachsten ist es, in Ihrer Umgebung mithilfe der EB CLI eine Verbindung mit einer Instance herzustellen. Sofern noch nicht geschehen, müssen Sie die EB CLI zuerst installieren, um sie nutzen zu können. Sie müssen Ihre Umgebung außerdem mit einem Amazon EC2-SSH-Schlüsselpaar konfigurieren. Verwenden Sie hierzu entweder die Sicherheitskonfigurationsseite der Konsole oder den EB CLI-Befehl eb init. Um eine Verbindung mit einer Umgebungs-Instance herzustellen, verwenden Sie den EB CLI-Befehl eb ssh.

Nachdem Sie eine Verbindung zu einer Amazon EC2-Instance hergestellt haben, auf der Ihre Docker-Container gehostet werden, können Sie sehen, wie die Dinge eingerichtet sind. Führen Sie ls auf /var/app/current aus:

[ec2-user@ip-10-0-0-117 ~]$ ls /var/app/current
Dockerrun.aws.json  php-app  proxy

Dieses Verzeichnis enthält die Dateien aus dem Quell-Bundle, die Sie während der Umgebungserstellung in Elastic Beanstalk hochgeladen haben.

[ec2-user@ip-10-0-0-117 ~]$ ls /var/log/containers
nginx-proxy    nginx-proxy-4ba868dbb7f3-stdouterr.log     
php-app        php-app-dcc3b3c8522c-stdouterr.log       rotated

Hier werden Protokolle auf der Container-Instance erstellt und von Elastic Beanstalk erfasst. Elastic Beanstalk erstellt ein Volume in diesem Verzeichnis für jeden Container, den Sie auf den Container-Standort mounten, in dem Protokolle geschrieben werden.

Sie können auch einen Blick auf Docker werfen, um die laufenden Containern mit anzuzeige docker ps.

[ec2-user@ip-10-0-0-117 ~]$ sudo docker ps
CONTAINER ID   IMAGE                            COMMAND                  CREATED         STATUS                  PORTS                               NAMES                                                
4ba868dbb7f3   nginx                            "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes            0.0.0.0:80->80/tcp, :::80->80/tcp   ecs-awseb-Tutorials-env-dc2aywfjwg-1-nginx-proxy-acca84ef87c4aca15400        
dcc3b3c8522c   php:fpm                          "docker-php-entrypoi…"   4 minutes ago   Up 4 minutes            9000/tcp                            ecs-awseb-Tutorials-env-dc2aywfjwg-1-php-app-b8d38ae288b7b09e8101                             
d9367c0baad6   amazon/amazon-ecs-agent:latest   "/agent"                 5 minutes ago   Up 5 minutes (healthy)                                      ecs-agent

Dies zeigt die zwei laufenden Container, die Sie bereitgestellt haben, sowie den Amazon ECS-Container-Agenten, der die Bereitstellung koordiniert hat.

Überprüfen des Amazon ECS-Container-Agenten

Amazon-EC2-Instances in einer ECS-verwalteten Docker-Umgebung auf Elastic Beanstalk führen einen Agentenvorgang in einem Docker-Container aus. Dieser Agent stellt eine Verbindung mit dem Amazon ECS Service her, um die Container-Bereitstellungen zu koordinieren. Diese Bereitstellungen werden als Aufgaben in Amazon ECS ausgeführt, die in Aufgabendefinitionsdateien konfiguriert sind. Elastic Beanstalk erstellt diese Aufgabendefinitionsdateien basierend auf der Dockerrun.aws.json, die Sie in ein Quell-Bundle hochladen.

Überprüfen Sie den Status des Container-Agenten mit einer HTTP-Get-Anforderung an http://localhost:51678/v1/metadata:

[ec2-user@ip-10-0-0-117 ~]$ curl http://localhost:51678/v1/metadata
{
  "Cluster":"awseb-Tutorials-env-dc2aywfjwg",
  "ContainerInstanceArn":"arn:aws:ecs:us-west-2:123456789012:container-instance/awseb-Tutorials-env-dc2aywfjwg/db7be5215cd74658aacfcb292a6b944f",
  "Version":"Amazon ECS Agent - v1.57.1 (089b7b64)"
}

Diese Struktur zeigt den Namen des Amazon ECS-Clusters und den ARN (Amazon-Ressourcennamen) der Cluster-Instance (die Amazon EC2-Instance, mit der Sie verbunden sind) an.

Für weitere Informationen senden Sie eine HTTP-Get-Anforderung an http://localhost:51678/v1/tasks:

[ec2-user@ip-10-0-0-117 ~]$ curl http://localhost:51678/v1/tasks
{
   "Tasks":[
      {
         "Arn":"arn:aws:ecs:us-west-2:123456789012:task/awseb-Tutorials-env-dc2aywfjwg/bbde7ebe1d4e4537ab1336340150a6d6",
         "DesiredStatus":"RUNNING",
         "KnownStatus":"RUNNING",
         "Family":"awseb-Tutorials-env-dc2aywfjwg",
         "Version":"1",
         "Containers":[
            {
               "DockerId":"dcc3b3c8522cb9510b7359689163814c0f1453b36b237204a3fd7a0b445d2ea6",
               "DockerName":"ecs-awseb-Tutorials-env-dc2aywfjwg-1-php-app-b8d38ae288b7b09e8101",
               "Name":"php-app",
               "Volumes":[
                  {
                     "Source":"/var/app/current/php-app",
                     "Destination":"/var/www/html"
                  }
               ]
            },
            {
               "DockerId":"4ba868dbb7f3fb3328b8afeb2cb6cf03e3cb1cdd5b109e470f767d50b2c3e303",
               "DockerName":"ecs-awseb-Tutorials-env-dc2aywfjwg-1-nginx-proxy-acca84ef87c4aca15400",
               "Name":"nginx-proxy",
               "Ports":[
                  {
                     "ContainerPort":80,
                     "Protocol":"tcp",
                     "HostPort":80
                  },
                  {
                     "ContainerPort":80,
                     "Protocol":"tcp",
                     "HostPort":80
                  }
               ],
               "Volumes":[
                  {
                     "Source":"/var/app/current/php-app",
                     "Destination":"/var/www/html"
                  },
                  {
                     "Source":"/var/log/containers/nginx-proxy",
                     "Destination":"/var/log/nginx"
                  },
                  {
                     "Source":"/var/app/current/proxy/conf.d",
                     "Destination":"/etc/nginx/conf.d"
                  }
               ]
            }
         ]
      }
   ]
}

Diese Struktur beschreibt die Aufgabe, die zur Bereitstellung der beiden Docker-Container aus dem Beispielprojekt dieses Tutorials ausgeführt wird. Die folgenden Informationen werden angezeigt:

• KnownStatus – Der RUNNING-Status gibt an, dass die Container noch aktiv sind.

• Family (Familie) – Der Name der Aufgabendefinition, die Elastic Beanstalk aus Dockerrun.aws.json erstellt hat.

• Version – Die Version der Aufgabendefinition. Diese wird mit jeder Aktualisierung der Aufgabendefinitionsdatei erhöht.

• Containers (Container) – Informationen über die Container, die in der Instance ausgeführt werden.

Noch mehr Informationen finden Sie im Amazon ECS-Service selbst, den Sie mit der aufrufe AWS Command Line Interface. Anweisungen zur Verwendung der AWS CLI mit Amazon ECS und Informationen zu Amazon ECS im Allgemeinen finden Sie im Amazon-ECS-Benutzerhandbuch.