Voraussetzungen Schritt 1: Erstellen eines Application Load Balancers Schritt 2: Erstellen eines Amazon-ECS-Clusters Schritt 3: Registrieren einer Aufgabendefinition Schritt 4: Erstellen Sie einen Amazon-ECS-Service Schritt 5: Erstellen der AWS CodeDeploy-Ressourcen Schritt 6: Erstellen und überwachen Sie ein CodeDeployEinsatz Schritt 7: Bereinigen

Tutorial: Erstellen eines Service mit einer Blau/Grün-Bereitstellung

Das folgende Tutorial zeigt, wie ein Amazon-ECS-Service mit einer Fargate-Aufgabe erstellt wird, die den Blau/Grün-Bereitstellungstyp mithilfe der AWS CLI verwendet.

Anmerkung

Für AWS CloudFormation wurde Unterstützung für die Durchführung einer blau/grünen Bereitstellung hinzugefügt. Weitere Informationen finden Sie unterFühren Sie die blauen/grünen Bereitstellungen von Amazon ECS durch CodeDeploy unter Verwendung vonAWS CloudFormationin derAWS CloudFormationBenutzerleitfaden.

Voraussetzungen

In diesem Tutorial wird davon ausgegangen, dass Sie die folgenden Voraussetzungen erfüllt haben:

Die neuste AWS CLI-Version ist installiert und konfiguriert. Weitere Informationen über die Installation oder Aktualisierung von AWS CLI finden Sie unter Installieren der AWS Command Line Interface.
Die Schritte in Einrichtung für die Verwendung von Amazon ECS wurden ausgeführt.
Ihr AWS-Benutzer besitzt die im Amazon-ECS-Ersteinrichtungsassistent-Berechtigungen-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
Sie haben eine VPC und die zu verwendende Sicherheitsgruppe erstellt. Weitere Informationen finden Sie unter Erstellen einer Virtual Private Cloud.
Das Amazon ECS CodeDeploy Die IAM-Rolle wird erstellt. Weitere Informationen finden Sie unter Amazon ECS CodeDeploy IAM-Rolle.

Schritt 1: Erstellen eines Application Load Balancers

Amazon-ECS-Dienste, die den Blau/Grün-Bereitstellungstyp verwenden, müssen entweder einen Application Load Balancer oder einen Network Load Balancer verwendet werden. In diesem Tutorial wird ein Application Load Balancer verwendet.

So erstellen Sie einen Application Load Balancer

Verwenden Sie dencreate-load-balancerBefehl, um einen Application Load Balancer zu erstellen. Geben Sie zwei Subnetze, die sich nicht in derselben Availability Zone befinden, sowie eine Sicherheitsgruppe an.
```
aws elbv2 create-load-balancer \
     --name bluegreen-alb \
     --subnets subnet-abcd1234 subnet-abcd5678 \
     --security-groups sg-abcd1234 \
     --region us-east-1
```
Die Ausgabe enthält den Amazon Resource Name (ARN) des Load Balancer im folgenden Format:
```
arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
```

Verwenden Sie dencreate-target-groupBefehl, um eine Zielgruppe zu erstellen. Diese Zielgruppe leitet den Datenverkehr an den ursprünglichen Aufgabesatz in Ihrem Service weiter.


aws elbv2 create-target-group \
     --name bluegreentarget1 \
     --protocol HTTP \
     --port 80 \
     --target-type ip \
     --vpc-id vpc-abcd1234 \
     --region us-east-1

Die Ausgabe umfasst den ARN der Zielgruppe im folgenden Format:

arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4

Verwenden Sie den Befehl create-listener, um einen Listener für Ihren Load Balancer mit einer Standardregel zu erstellen, die Anforderungen an Ihre Zielgruppe weiterleitet.


aws elbv2 create-listener \
     --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
     --protocol HTTP \
     --port 80 \
     --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
     --region us-east-1

Die Ausgabe enthält den ARN des Listener im folgenden Format:

arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4

Schritt 2: Erstellen eines Amazon-ECS-Clusters

Verwenden Sie den Befehl create-cluster, um einen Cluster namens tutorial-bluegreen-cluster zu erstellen.


aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1

Die Ausgabe enthält den ARN des Clusters im folgenden Format:

arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster

Schritt 3: Registrieren einer Aufgabendefinition

Benutze dieregister-task-definitionBefehl zum Registrieren einer Aufgabendefinition, die mit Fargate kompatibel ist. Für sie muss als Netzwerkmodus awsvpc verwendet werden. Nachfolgend finden Sie die Beispiel-Aufgabendefinition, die für dieses Tutorial verwendet wurde.

Erstellen Sie zuerst eine Datei mit dem Namen fargate-task.json und dem folgenden Inhalt. Stellen Sie sicher, dass Sie den ARN für die Aufgabenausführungsrolle verwenden. Weitere Informationen finden Sie unter IAM-Rolle für die Amazon-ECS-Aufgabenausführung.


{
    "family": "tutorial-task-def",
        "networkMode": "awsvpc",
        "containerDefinitions": [
            {
                "name": "sample-app",
                "image": "httpd:2.4",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #00FFFF;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512",
        "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole"
}

Registrieren Sie dann die Aufgabendefinition mit der von Ihnen erstellten Datei fargate-task.json.


aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1

Schritt 4: Erstellen Sie einen Amazon-ECS-Service

Verwenden Sie den Befehl create-service, um einen Service zu erstellen.

Erstellen Sie zuerst eine Datei mit dem Namen service-bluegreen.json und dem folgenden Inhalt.


{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}

Erstellen Sie dann Ihren Service unter Verwendung der Datei service-bluegreen.json, die Sie erstellt haben.


aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1

Die Ausgabe enthält den ARN des Service im folgenden Format:

arn:aws:ecs:region:aws_account_id:service/service-bluegreen

Rufen Sie den DNS-Namen des Load Balancers mit dem folgenden Befehl ab.


 aws elbv2 describe-load-balancers --name bluegreen-alb  --query 'LoadBalancers[*].DNSName'

Geben Sie den DNS-Namen in Ihren Webbrowser ein und Sie sollten eine Webseite sehen, auf der die Beispiel-App mit blauem Hintergrund angezeigt wird.

Schritt 5: Erstellen der AWS CodeDeploy-Ressourcen

Verwenden Sie die folgenden Schritte, um Ihre zu erstellen CodeDeploy Anwendung, die Application Load Balancer-Zielgruppe für CodeDeploy Bereitstellungsgruppe und CodeDeploy Bereitstellungsgruppe.

Um zu erstellen CodeDeploy Ressourcen

Benutze denAnwendung erstellenBefehl zum Erstellen eines CodeDeploy Anwendung. Geben Sie die ECS-Plattform für die Datenverarbeitung an.


aws deploy create-application \
     --application-name tutorial-bluegreen-app \
     --compute-platform ECS \
     --region us-east-1

Die Ausgabe enthält die Anwendungs-ID im folgenden Format:

{
    "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
}

Benutze diecreate-target-groupBefehl, um eine zweite Application Load Balancer-Zielgruppe zu erstellen, die bei der Erstellung Ihrer CodeDeploy Bereitstellungsgruppe.


aws elbv2 create-target-group \
     --name bluegreentarget2 \
     --protocol HTTP \
     --port 80 \
     --target-type ip \
     --vpc-id "vpc-0b6dd82c67d8012a1" \
     --region us-east-1

Die Ausgabe umfasst den ARN der Zielgruppe im folgenden Format:

arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc

Verwenden Sie diecreate-deployment-groupBefehl zum Erstellen eines CodeDeploy Bereitstellungsgruppe.

Erstellen Sie zuerst eine Datei mit dem Namen tutorial-deployment-group.json und dem folgenden Inhalt. Dieses Beispiel verwendet die von Ihnen erstellte Ressource. Für dieserviceRoleArn, geben Sie den ARN Ihres Amazon ECS an CodeDeploy IAM-Rolle. Weitere Informationen finden Sie unter Amazon ECS CodeDeploy IAM-Rolle.


{
   "applicationName": "tutorial-bluegreen-app",
   "autoRollbackConfiguration": {
      "enabled": true,
      "events": [ "DEPLOYMENT_FAILURE" ]
   },
   "blueGreenDeploymentConfiguration": {
      "deploymentReadyOption": {
         "actionOnTimeout": "CONTINUE_DEPLOYMENT",
         "waitTimeInMinutes": 0
      },
      "terminateBlueInstancesOnDeploymentSuccess": {
         "action": "TERMINATE",
         "terminationWaitTimeInMinutes": 5
      }
   },
   "deploymentGroupName": "tutorial-bluegreen-dg",
   "deploymentStyle": {
      "deploymentOption": "WITH_TRAFFIC_CONTROL",
      "deploymentType": "BLUE_GREEN"
   },
   "loadBalancerInfo": {
      "targetGroupPairInfoList": [
        {
          "targetGroups": [
             {
                 "name": "bluegreentarget1"
             },
             {
                 "name": "bluegreentarget2"
             }
          ],
          "prodTrafficRoute": {
              "listenerArns": [
                  "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
              ]
          }
        }
      ]
   },
   "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
   "ecsServices": [
       {
           "serviceName": "service-bluegreen",
           "clusterName": "tutorial-bluegreen-cluster"
       }
   ]
}

Dann erstelle die CodeDeploy Bereitstellungsgruppe.


aws deploy create-deployment-group \
     --cli-input-json file://tutorial-deployment-group.json \
     --region us-east-1

Die Ausgabe enthält die Bereitstellungsgruppen-ID im folgenden Format:

{
    "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
}

Schritt 6: Erstellen und überwachen Sie ein CodeDeployEinsatz

Vor dem Erstellen eines CodeDeploy Bereitstellung, aktualisieren Sie die Aufgabendefinitioncommandinfargate-task.jsonwie folgt, um die Hintergrundfarbe der Beispiel-App auf Grün zu ändern.


{
    ...
        "containerDefinitions": [
            {
                ...
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #097969;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
       ...
}

Registrieren Sie die aktualisierte Aufgabendefinition mit dem folgenden Befehl.


aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1

Gehen Sie nun wie folgt vor, um eine Anwendungsspezifikationsdatei zu erstellen und hochzuladen (AppSpec Datei) und ein CodeDeploy Einsatz.

Um eine zu erstellen und zu überwachen CodeDeploy Einsatz

Erstellen Sie ein und laden Sie es hoch AppSpec Datei mit den folgenden Schritten.

Erstellen Sie eine Datei mit dem Namen appspec.yaml und dem Inhalt der CodeDeploy -Bereitstellungsgruppe. In diesem Beispiel wird die aktualisierte Aufgabendefinition verwendet.


version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:2"
        LoadBalancerInfo:
          ContainerName: "sample-app"
          ContainerPort: 80
        PlatformVersion: "LATEST"

Verwenden Sie dies3 mbBefehl zum Erstellen eines Amazon S3-Buckets für AppSpec datei.
```
aws s3 mb s3://tutorial-bluegreen-bucket
```
Benutze dies3 cpBefehl zum Hochladen der AppSpec Datei in den Amazon S3-Bucket.
```
aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
```

Erstellen Sie die CodeDeploy Bereitstellung mithilfe der folgenden Schritte.

Erstellen Sie eine Datei mit dem Namencreate-deployment.jsonmit dem Inhalt des CodeDeploy Einsatz. Dieses Beispiel verwendet die Ressourcen, die Sie zuvor im Tutorial erstellt haben.


{
    "applicationName": "tutorial-bluegreen-app",
    "deploymentGroupName": "tutorial-bluegreen-dg",
    "revision": {
        "revisionType": "S3",
        "s3Location": {
            "bucket": "tutorial-bluegreen-bucket",
            "key": "appspec.yaml",
            "bundleType": "YAML"
        }
    }
}

Verwenden Sie den Befehl create-deployment zum Erstellen der Bereitstellung.


aws deploy create-deployment \
     --cli-input-json file://create-deployment.json \
     --region us-east-1

Die Ausgabe enthält die Bereitstellungs-ID im folgenden Format:

{
    "deploymentId": "d-RPCR1U3TW"
}

Verwenden Sieget-deployment-targetBefehl, um die Details der Bereitstellung abzurufen, unter Angabe vondeploymentIdaus der vorherigen Ausgabe.


aws deploy get-deployment-target \
--deployment-id "d-IMJU3A8TW" \
--target-id tutorial-bluegreen-cluster:service-bluegreen \
--region us-east-1

Anfänglich lautet der BereitstellungsstatusInProgress. Der Verkehr wird an den ursprünglichen Aufgabensatz weitergeleitet, der einetaskSetLabelvonBLUE, ein Status vonPRIMARY, und eintrafficWeightvon100.0. Der Ersatzaufgabensatz hat einetaskSetLabelvonGREEN, ein Status vonACTIVE, und eintrafficWeightvon0.0. Der Webbrowser, in den Sie den DNS-Namen eingegeben haben, zeigt die Beispiel-App weiterhin mit blauem Hintergrund an.

{
"deploymentTarget": {
"deploymentTargetType": "ECSTarget",
"ecsTarget": {
    "deploymentId": "d-RPCR1U3TW",
    "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
    "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
    "lastUpdatedAt": "2023-08-10T12:07:24.797000-05:00",
    "lifecycleEvents": [
        {
            "lifecycleEventName": "BeforeInstall",
            "startTime": "2023-08-10T12:06:22.493000-05:00",
            "endTime": "2023-08-10T12:06:22.790000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "Install",
            "startTime": "2023-08-10T12:06:22.936000-05:00",
            "status": "InProgress"
        },
        {
            "lifecycleEventName": "AfterInstall",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "BeforeAllowTraffic",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "AllowTraffic",
            "status": "Pending"
        },
        {
            "lifecycleEventName": "AfterAllowTraffic",
            "status": "Pending"
        }
    ],
    "status": "InProgress",
    "taskSetsInfo": [
        {
            "identifer": "ecs-svc/9223370493423413672",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "ACTIVE",
            "trafficWeight": 0.0,
            "targetGroup": {
                "name": "bluegreentarget2"
            },
            "taskSetLabel": "Green"
        },
        {
            "identifer": "ecs-svc/9223370493425779968",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "PRIMARY",
            "trafficWeight": 100.0,
            "targetGroup": {
                "name": "bluegreentarget1"
            },
            "taskSetLabel": "Blue"
        }
    ]
}
}
}

Rufen Sie die Bereitstellungsdetails mit dem Befehl weiter ab, bis der Bereitstellungsstatus lautetSucceeded, wie in der folgenden Ausgabe gezeigt. Der Datenverkehr wird jetzt an den Ersatz-Tasksatz umgeleitet, der jetzt den Status hatPRIMARYund eintrafficWeightvon100.0. Aktualisieren Sie den Webbrowser, in den Sie den DNS-Namen des Load Balancers eingegeben haben, und Sie sollten jetzt die Beispiel-App mit grünem Hintergrund sehen.

{
"deploymentTarget": {
"deploymentTargetType": "ECSTarget",
"ecsTarget": {
    "deploymentId": "d-RPCR1U3TW",
    "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
    "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
    "lastUpdatedAt": "2023-08-10T12:07:24.797000-05:00",
    "lifecycleEvents": [
        {
            "lifecycleEventName": "BeforeInstall",
            "startTime": "2023-08-10T12:06:22.493000-05:00",
            "endTime": "2023-08-10T12:06:22.790000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "Install",
            "startTime": "2023-08-10T12:06:22.936000-05:00",
            "endTime": "2023-08-10T12:08:25.939000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AfterInstall",
            "startTime": "2023-08-10T12:08:26.089000-05:00",
            "endTime":  "2023-08-10T12:08:26.403000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "BeforeAllowTraffic",
            "startTime": "2023-08-10T12:08:26.926000-05:00",
            "endTime":  "2023-08-10T12:08:27.256000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AllowTraffic",
            "startTime": "2023-08-10T12:08:27.416000-05:00",
            "endTime": "2023-08-10T12:08:28.195000-05:00",
            "status": "Succeeded"
        },
        {
            "lifecycleEventName": "AfterAllowTraffic",
            "startTime": "2023-08-10T12:08:28.715000-05:00",
            "endTime":  "2023-08-10T12:08:28.994000-05:00",
            "status": "Succeeded"
        }
    ],
    "status": "Succeeded",
    "taskSetsInfo": [
        {
            "identifer": "ecs-svc/9223370493425779968",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "ACTIVE",
            "trafficWeight": 0.0,
            "targetGroup": {
                "name": "bluegreentarget1"
            },
            "taskSetLabel": "Blue"
        },
        {
            "identifer": "ecs-svc/9223370493423413672",
            "desiredCount": 1,
            "pendingCount": 0,
            "runningCount": 1,
            "status": "PRIMARY",
            "trafficWeight": 100.0,
            "targetGroup": {
                "name": "bluegreentarget2"
            },
            "taskSetLabel": "Green"
        }
    ]
}
}
}

Schritt 7: Bereinigen

Wenn Sie dieses Tutorial abgeschlossen haben, sollten Sie die damit verknüpften Ressourcen bereinigen, um zu vermeiden, dass für nicht verwendete Ressourcen Kosten entstehen.

Bereinigen der Ressourcen des Tutorials

Verwenden Sie dendelete-deployment-groupBefehl zum Löschen der CodeDeploy Bereitstellungsgruppe.


aws deploy delete-deployment-group \
     --application-name tutorial-bluegreen-app \
     --deployment-group-name tutorial-bluegreen-dg \
     --region us-east-1

Verwenden Sie dieAnwendung löschenBefehl zum Löschen der CodeDeploy Anwendung.


aws deploy delete-application \
     --application-name tutorial-bluegreen-app \
     --region us-east-1

Verwenden Sie den Befehl delete-service, um den Amazon-ECS-Service zu löschen. Mit dem --force-Flag können Sie einen Service auch dann löschen, wenn er nicht auf null Aufgaben herunterskaliert wurde.
```
aws ecs delete-service \
     --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
     --force \
     --region us-east-1
```

Verwenden Sie den Befehl delete-cluster, um den Amazon-ECS-Cluster zu löschen.


aws ecs delete-cluster \
     --cluster tutorial-bluegreen-cluster \
     --region us-east-1

Benutze dies3 rmBefehl zum Löschen der AppSpec Datei aus dem Amazon S3-Bucket.
```
aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
```
Verwenden Sie den Befehl s3 rb zum Löschen des Amazon S3-Buckets.
```
aws s3 rb s3://tutorial-bluegreen-bucket
```

Verwenden Sie diedelete-load-balancerBefehl, um den Application Load Balancer zu löschen.


aws elbv2 delete-load-balancer \
     --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
     --region us-east-1

Verwenden Sie dendelete-target-groupBefehl, um die beiden Application Load Balancer-Zielgruppen zu löschen.


aws elbv2 delete-target-group \
     --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
     --region us-east-1


aws elbv2 delete-target-group \
     --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
     --region us-east-1

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Anleitung: Erstellen eines Service unter Verwendung von Service Discovery

Tutorial: Auf Amazon ECS achten CloudWatch Ereignisse