Eine ECS verwaltete Docker-Umgebung mit der Elastic Beanstalk Beanstalk-Konsole erstellen

Dieses Tutorial beschreibt die Konfiguration von Containern und die Vorbereitung des Quellcodes für eine ECS verwaltete Docker-Umgebung, die zwei Container verwendet.

Die Container, eine PHP Anwendung und ein Nginx-Proxy, werden auf jeder der Amazon Elastic Compute Cloud (AmazonEC2) -Instances in einer Elastic Beanstalk Beanstalk-Umgebung nebeneinander 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 Sie verwaltete Docker-Container ECS

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 gesamte Code für dieses Tutorial ist im awslabs-Repository unter verfügbar. GitHub https://github.com/awslabs/eb-docker-nginx-proxy

Die Datei, die Elastic Beanstalk zur Konfiguration der Container auf einer EC2 Amazon-Instance verwendet, ist eine JSON -formatierte Textdatei mit dem Namen v2. Dockerrun.aws.json Die Versionen der ECS verwalteten Docker-Plattform verwenden ein Version 2-Format dieser Datei. Dieses Format kann nur mit der ECS verwalteten Docker-Plattform verwendet werden, da es sich erheblich von den anderen Versionen der Konfigurationsdateien unterscheidet, die die Docker-Plattformzweige unterstützen, die nicht von verwaltet werden. ECS

Erstellen Sie eine Dockerrun.aws.json v2-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"
        }
      ]
    }
  ]
}

Diese Beispielkonfiguration definiert zwei Container, 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 v2 und seinen Parametern finden Sie unter. Format der Containerdefinition

Inhalte hinzufügen

Als Nächstes fügen Sie einige Inhalte für Ihre PHP Website hinzu, die Besuchern angezeigt werden sollen, 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 Sie ein Elastic Beanstalk Beanstalk-Anwendungsquellpaket

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 die Option ECSRunning on 64-bit Amazon Linux 2023 aus.

So starten Sie eine Umgebung (Konsole)

1. Öffnen Sie die Elastic Beanstalk Beanstalk-Konsole mit diesem vorkonfigurierten Link: console.aws.amazon.com/elasticbeanstalk/home#/? newApplication applicationNameenvironmentType=Tutorials& = 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 das Symbol URL neben dem Namen der Umgebung, um Ihre neue Website zu sehen.

Verbinden mit einer Container-Instance

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

Der einfachste Weg, eine Verbindung zu einer Instance in Ihrer Umgebung herzustellen, ist die Verwendung von EB. CLI Um es zu verwenden, installieren Sie das EB CLI, falls Sie dies noch nicht getan haben. Sie müssen Ihre Umgebung auch mit einem EC2 SSH Amazon-Schlüsselpaar konfigurieren. Verwenden Sie dazu entweder die Sicherheitskonfigurationsseite der Konsole oder den Befehl CLI EB eb init. Verwenden Sie den Befehl EB CLI eb ssh, um eine Verbindung zu einer Umgebungsinstanz herzustellen.

Nachdem Sie nun mit einer EC2 Amazon-Instance verbunden sind, die Ihre Docker-Container hostet, 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 beiden laufenden Container, die Sie bereitgestellt haben, sowie den ECS Amazon-Container-Agenten, der die Bereitstellung koordiniert hat.

Untersuchen Sie den ECS Amazon-Containeragenten

EC2Amazon-Instances in einer ECS verwalteten Docker-Umgebung auf Elastic Beanstalk führen einen Agentenprozess in einem Docker-Container aus. Dieser Agent stellt eine Verbindung zum ECS Amazon-Service her, um den Einsatz von Containern zu koordinieren. Diese Bereitstellungen werden in Amazon als Aufgaben ausgeführtECS, 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-Anfrage anhttp://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 ECS Amazon-Clusters und den ARN (Amazon-Ressourcennamen) der Cluster-Instance (die EC2 Amazon-Instance, mit der Sie verbunden sind).

Für weitere Informationen senden Sie eine HTTP GET-Anfrage anhttp://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 sind beim ECS Amazon-Service selbst erhältlich, den Sie über den anrufen können AWS Command Line Interface. Anweisungen zur Verwendung von AWS CLI mit Amazon ECS und allgemeine Informationen zu Amazon finden Sie ECS im ECSAmazon-Benutzerhandbuch.