Erste Schritte mit Amazon ECS mit AWS-Copilot

Erste Schritte mit Amazon ECS mit AWS-Copilot durch Bereitstellen einer Amazon-ECS-Anwendung.

Voraussetzungen

Überprüfen Sie zu Beginn, ob die folgenden Voraussetzungen erfüllt sind:

• Richten Sie ein AWS-Konto ein. Weitere Informationen finden Sie unter Einrichtung für die Verwendung von Amazon ECS.

• Installieren des AWS-Copilot-CLI. Releases unterstützen derzeit Linux- und macOS-Systeme. Weitere Informationen finden Sie unter Installieren von AWS-Copilot-CLI.

• Installieren und Konfigurieren der AWS CLI. Weitere Informationen finden Sie unter AWS-Befehlszeilenschnittstelle.

• Führen Sie Folgendes aus: aws configure, um ein Standardprofil einzurichten, das die AWS-Copilot-CLI verwendet, um Ihre Anwendung und Dienste zu verwalten.

• Installieren und Ausführen von Docker. Weitere Informationen finden Sie unter Erste Schritte mit Docker.

Bereitstellen Ihrer Anwendung mit einem Befehl

Stellen Sie sicher, dass das AWS-Befehlszeilentool installiert ist und aws configure bereits ausgeführt wurde, bevor Sie beginnen.

Stellen Sie die Anwendung mit dem folgenden Befehl bereit.

git clone https://github.com/aws-samples/amazon-ecs-cli-sample-app.git demo-app && \ 
cd demo-app &&                               \
copilot init --app demo                      \
  --name api                                 \
  --type 'Load Balanced Web Service'         \
  --dockerfile './Dockerfile'                \
  --port 80                                  \
  --deploy

Bereitstellen der Anwendung Schritt für Schritt

Schritt 1: Konfigurieren Ihrer Anmeldeinformationen

Führen Sie aws configure aus, um ein Standardprofil einzurichten, das die AWS-Copilot-CLI verwendet, um Ihre Anwendung und Dienste zu verwalten.

aws configure

Schritt 2: Klonen der Demo-App

Klonen Sie eine einfache Flask-Anwendung und Dockerfile.

git clone https://github.com/aws-samples/amazon-ecs-cli-sample-app.git demo-app

Schritt 3: Einrichten Ihrer Anwendung

1. Führen Sie aus dem demo-app-Verzeichnis den init-Befehl aus.

   Führen Sie für Windows-Benutzer den Befehl init aus dem Ordner aus, der das heruntergeladene copilot.exe-Datei enthält.

   copilot init

   AWS-Copilot führt Sie durch die Einrichtung Ihrer erste Anwendung und Service mit einer Reihe von Terminal-Eingabeaufforderungen, beginnend mit Nächster Schritt. Wenn Sie AWS-Copilot bereits verwendet haben, um Anwendungen bereitzustellen, werden Sie aufgefordert, eine aus einer Liste von Anwendungsnamen auszuwählen.

2. Benennen Sie Ihre Anwendung.

   What would you like to name your application? [? for help]

   Enter demo.

Schritt 4: Einrichten eines ECS Service in Ihrer „Demo“-Anwendung

1. Sie werden aufgefordert, einen Servicetyp auszuwählen. Sie bauen eine einfache Flask-Anwendung und dient einer kleinen API.

   Which service type best represents your service's architecture? [Use arrows to move, type to filter, ? for more help]
      > Load Balanced Web Service
        Backend Service
        Scheduled Job

   Choose Load Balanced Web Service .

2. Geben Sie einen Namen für Ihren Service an.

   What do you want to name this Load Balanced Web Service? [? for help]

   Enter api für Ihren Servicenamen.

3. Wählen Sie eine Docker-Datei aus.

   Which Dockerfile would you like to use for api? [Use arrows to move, type to filter, ? for more help]
      > ./Dockerfile
        Use an existing image instead

   Choose Dockerfile.

   Für Windows-Benutzer geben Sie den Pfad zur Dockerfile in das Feld demo-app folder (*`...\demo-app\Dockerfile`*\.) ein.

4. Port definieren.

   Which port do you want customer traffic sent to? [? for help] (80)

   Enter 80 oder akzeptieren Sie die Standardeinstellung.

5. Sie sehen ein Protokoll, in dem die erstellten Anwendungsressourcen angezeigt werden.

   Creating the infrastructure to manage services under application demo.

6. Stellen Sie nach dem Erstellen der Anwendungsressourcen eine Testumgebung bereit.

   Would you like to deploy a test environment? [? for help] (y/N)

   Enter y.

   Proposing infrastructure changes for the test environment.

7. Es wird ein Protokoll angezeigt, das den Status Ihrer Anwendungsbereitstellung anzeigt.

   Note: It's best to run this command in the root of your Git repository.
   Welcome to the Copilot CLI! We're going to walk you through some questions
   to help you get set up with an application on ECS. An application is a collection of
   containerized services that operate together.
   
   Use existing application: No
   Application name: demo
   Workload type: Load Balanced Web Service
   Service name: api
   Dockerfile: ./Dockerfile
   no EXPOSE statements in Dockerfile ./Dockerfile
   Port: 80
   Ok great, we'll set up a Load Balanced Web Service named api in application demo listening on port 80.
   
   ✔ Created the infrastructure to manage services under application demo.
   
   ✔ Wrote the manifest for service api at copilot/api/manifest.yml
   Your manifest contains configurations like your container size and port (:80).
   
   ✔ Created ECR repositories for service api.
   
   All right, you're all set for local development.
   Deploy: Yes
   
   ✔ Created the infrastructure for the test environment.
   - Virtual private cloud on 2 availability zones to hold your services     [Complete]
   - Virtual private cloud on 2 availability zones to hold your services     [Complete]
     - Internet gateway to connect the network to the internet               [Complete]
     - Public subnets for internet facing services                           [Complete]
     - Private subnets for services that can't be reached from the internet  [Complete]
     - Routing tables for services to talk with each other                   [Complete]
   - ECS Cluster to hold your services                                       [Complete]
   ✔ Linked account aws_account_id and region region to application demo.
   
   ✔ Created environment test in region region under application demo.                         
   Environment test is already on the latest version v1.0.0, skip upgrade.
   [+] Building 0.8s (7/7) FINISHED
    => [internal] load .dockerignore                                                                                  0.1s
    => => transferring context: 2B                                                                                    0.0s
    => [internal] load build definition from Dockerfile                                                               0.0s
    => => transferring dockerfile: 37B                                                                                0.0s
    => [internal] load metadata for docker.io/library/nginx:latest                                                    0.7s
    => [internal] load build context                                                                                  0.0s
    => => transferring context: 32B                                                                                   0.0s
    => [1/2] FROM docker.io/library/nginx@sha256:aeade65e99e5d5e7ce162833636f692354c227ff438556e5f3ed0335b7cc2f1b     0.0s
    => CACHED [2/2] COPY index.html /usr/share/nginx/html                                                             0.0s
    => exporting to image                                                                                             0.0s
    => => exporting layers                                                                                            0.0s
    => => writing image sha256:3ee02fd4c0f67d7bd808ed7fc73263880649834cbb05d5ca62380f539f4884c4                       0.0s
    => => naming to aws_account_id.dkr.ecr.region.amazonaws.com/demo/api:cee7709                                      0.0s
   WARNING! Your password will be stored unencrypted in /home/user/.docker/config.json.
   Configure a credential helper to remove this warning. See
   https://docs.docker.com/engine/reference/commandline/login/#credentials-store
   
   Login Succeeded
   The push refers to repository [aws_account_id.dkr.ecr.region.amazonaws.com/demo/api]
   592a5c0c47f1: Pushed
   6c7de695ede3: Pushed
   2f4accd375d9: Pushed
   ffc9b21953f4: Pushed
   cee7709: digest: sha_digest
   
   ✔ Deployed api, you can access it at http://demo-Publi-1OQ8VMS2VC2WG-561733989.region.elb.amazonaws.com.

Schritt 5: Überprüfen Sie, dass Ihre Anwendung ausgeführt wird

Zeigen Sie den Status Ihrer Anwendung mithilfe der folgenden Befehle an.

Listen Sie alle Ihre AWS-Copilot-Anwendungen auf.

copilot app ls

Zeigen Sie Informationen zu den Umgebungen und Diensten in Ihrer Anwendung an.

copilot app show

Zeigen Sie Informationen zu Ihren Umgebungen an.

copilot env ls

Zeigen Sie Informationen über den Service an, einschließlich Endpunkte, Kapazität und zugehöriger Ressourcen.

copilot svc show

Liste aller Dienste in einer Anwendung.

copilot svc ls

Protokolle eines bereitgestellten Dienstes anzeigen.

copilot svc logs

Servicestatus anzeigen.

copilot svc status

Auflisten der verfügbaren Befehle und Optionen.

copilot --help

copilot init --help

Schritt 6: Erfahren Sie, wie Sie eine CI/CD-Pipeline erstellen

Eine detaillierte Anleitung finden Sie im ECS-Workshop, wie Sie eine CI/CD-Pipeline und einen Git-Workflow mit AWS-Copilot nutzen.

Schritt 7: Bereinigen

Führen Sie den folgenden Befehl aus, um alle Ressourcen zu löschen und zu bereinigen.

copilot app delete