Mit Docker Desktop Lokal und auf AWS ECS entwickeln

Die neue Funktion compose in Docker Desktop

Seit der Version 2.3.0.5 ist Docker Desktop in der Lage, mit dem Kommando docker compose up eine definierte Serviceumgebung auf Amazon Web Services automatisiert bereitzustellen. Das bisher genutzte Kommando docker-compose bleibt vorerst erhalten und dient der lokalen Bereitstellung des Service. Beide Kommandos greifen auf die gleiche docker-compose.yml zu. Hierzu ist es im einfachsten Fall nicht mehr notwendig, die benötigten Ressourcen im AWS Account vorher aufzubauen. Alle benötigten Resourcen werden im Hintergrund automatisch erstellt. Nach Ausführen des Befehls kann direkt auf den laufenden Service in AWS zugegriffen werden, wie es mit der lokalen Instanz auch möglich ist.

Wie fängt man an? Ein einfacher Webservice

Context erstellen

Zuerst einmal muß ein weiterer Context erstellt werden, damit wir lokale und AWS Umgebung trennen und referenzieren können.

$ docker context create ecs docker-ecs
$ docker context ls
NAME                TYPE                DESCRIPTION                               DOCKER ENDPOINT               KUBERNETES ENDPOINT   ORCHESTRATOR
docker-ecs          ecs                 credentials read from environment
default *           moby                Current DOCKER_HOST based configuration   unix:///var/run/docker.sock                         swarm

YAML Datei erstellen und lokal testen

Ich benutze hier in diesem Beispiel Docker Desktop für Mac in der Version 2.5.0.1. Wir erstellen eine simple YAML Datei und testen zuerst lokal, danach bauen wir den Service auf AWS auf.

docker-compose.yml:

version: "3.8"
x-aws-logs_retention: 14

services:
   web:
       image: nginx:latest 
       ports:
           - target: 80
             protocol: tcp
             x-aws-protocol: http

Zu beachten ist hier, das die speziellen Erweiterungen für AWS ECS mit x-aws- beginnen und von docker-compose ignoriert werden. Die verschiedenen Optionen erklärt obiger Verweis auf die Docker Dokumentation oder auch die GitHub Seite docker/compose-cli.

Lokal starten

Für den lokalen Test nehmen wir das altbekannte Kommando docker-compose

$ docker context use default
$ docker-compose up -d

Der Endpunkt steht bereit. Den lokalen Port erfahren wir mit docker-compose ps

$ docker-compose ps
          Name                        Command               State           Ports
-----------------------------------------------------------------------------------------
docker-compose-ecs_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:32773->80/tcp

Bereitstellen auf AWS

Um mit AWS den Service zu erstellen, sind Rechte in genutzten AWS Account erforderlich. In der Docker Dokumentation ist beschrieben, welche Rechte nötig sind, um den Service erstellen zu können. Nach dem Wechsel des context kann man anfangen. Im Hintergrund erstellt docker cli dann einen CloudFormation Stack, in der Shell kann man den Fortschritt beobachten. Wer will, kann vor den folgenden Kommandos erst einmal docker compose convert eintippen und bekommt das erstellte CloudFormation Template zu sehen.

$ docker context use docker-ecs
$ aws-vault exec centrias -- docker compose up
[+] Running 14/14
 ⠿ dockercomposeecs          CreateComplete                                                                                         220.0s
 ⠿ WebTaskExecutionRole      CreateComplete                                                                                          16.0s
 ⠿ WebTCP80TargetGroup       CreateComplete                                                                                           1.0s
 ⠿ LogGroup                  CreateComplete                                                                                           3.0s
 ⠿ Cluster                   CreateComplete                                                                                           6.0s
 ⠿ DefaultNetwork            CreateComplete                                                                                           5.0s
 ⠿ CloudMap                  CreateComplete                                                                                          46.1s
 ⠿ DefaultNetworkIngress     CreateComplete                                                                                           1.0s
 ⠿ Default80Ingress          CreateComplete                                                                                           0.0s
 ⠿ LoadBalancer              CreateComplete                                                                                         122.0s
 ⠿ WebTaskDefinition         CreateComplete                                                                                           3.0s
 ⠿ WebServiceDiscoveryEntry  CreateComplete                                                                                           1.0s
 ⠿ WebTCP80Listener          CreateComplete                                                                                           3.0s
 ⠿ WebService                CreateComplete                                                                                          81.0s

# Status und Loadbalancer Endpoint abfragen
$ aws-vault exec centrias -- docker compose ps
ID                                         NAME                REPLICAS            PORTS
dockercomposeecs-WebService-xYJ8WbnwQZpA   web                 1/1                 docke-LoadB-CWZHXQJ0YAMF-1250472604.eu-central-1.elb.amazonaws.com:80->80/http

Der Service ist durch die Orchestrierung mit AWS CloudFormation wieder rückstandsfrei zu entfernen, wenn man eingibt:

$ aws-vault exec centrias -- docker compose down

Vorteile

• Lokales Entwickeln eines Service in docker-compose.yml
• Alle Funktionen in Docker Desktop bereits enthalten
• Paralleles Deployment lokal und auf ECS
• Reduzierter Aufwand für das Bereitstellen in der AWS Cloud
• Schreiben von Infrastructure as Code kaum nötig

Fazit

Es ist bemerkenswert, wie schnell und einfach es nun möglich ist, Container Services zu entwickeln und bei AWS in Betrieb zu nehmen. Jeder, der schon einmal ECS Fargate mit allen Abhängigkeiten in IaC implementiert hat, weiß sicher diese “Abkürzung” zu schätzen.

Neugierig?

Dann kontaktiert uns gern!