Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Tutorial: Einen Dienst mithilfe einer Bereitstellung erstellen Blue/Green
<a name="create-blue-green"></a>

Amazon ECS hat blue/green Bereitstellungen in den Create Service Wizard auf der Amazon ECS-Konsole integriert. Weitere Informationen finden Sie unter [Erstellung einer Amazon-ECS-Bereitstellung mit fortlaufender Aktualisierung](create-service-console-v2.md).

Das folgende Tutorial zeigt, wie Sie einen Amazon ECS-Service erstellen, der eine Fargate-Aufgabe enthält, die den blue/green Bereitstellungstyp mit dem AWS CLI verwendet.

**Anmerkung**  
Support für die Durchführung einer blue/green Bereitstellung wurde hinzugefügt CloudFormation. Weitere Informationen finden Sie im *AWS CloudFormation Benutzerhandbuch* unter [Durchführen von Amazon blue/green ECS-Bereitstellungen CodeDeploy mithilfe von CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) Using.

## Voraussetzungen
<a name="create-blue-green-prereqs"></a>

In diesem Tutorial wird davon ausgegangen, dass Sie die folgenden Voraussetzungen erfüllt haben:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen zur Installation oder Aktualisierung von finden Sie unter [Installation von AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). AWS CLI
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\_ FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben eine VPC und die zu verwendende Sicherheitsgruppe erstellt. Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Die Amazon ECS CodeDeploy IAM-Rolle wird erstellt. Weitere Informationen finden Sie unter [Amazon ECS CodeDeploy IAM-Rolle](codedeploy_IAM_role.md).

## Schritt 1: Erstellen eines Application Load Balancers
<a name="create-blue-green-loadbalancer"></a>

Amazon ECS-Services, die den blue/green Bereitstellungstyp verwenden, können einen Application Load Balancer, Network Load Balancer, Service Connect oder Headless verwenden. Für die verwaltete Verkehrsverlagerung benötigen Sie einen Load Balancer oder Service Connect. In diesem Tutorial wird ein Application Load Balancer verwendet.

**So erstellen Sie einen Application Load Balancer**

1. Verwenden des Befehls [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html), 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 Balancers im folgenden Format:

   ```
   arn:aws:elasticloadbalancing:{{region}}:{{aws_account_id}}:loadbalancer/app/{{bluegreen-alb/e5ba62739c16e642}}
   ```

1. Verwenden Sie den Befehl [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html), 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
   ```

1. Verwenden Sie den Befehl [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html), 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: Eine Amazon-ECS-Cluster erstellen
<a name="create-blue-green-cluster"></a>

Verwenden Sie den Befehl [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html), 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
<a name="create-blue-green-taskdef"></a>

Verwenden Sie den Befehl [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html), um eine Aufgabendefinition zu registrieren, 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](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate",
    "networkMode": "awsvpc",
    "containerDefinitions": [
        {
            "name": "sample-app",
            "image": "public.ecr.aws/docker/library/httpd:latest",
            "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: #333;} </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"
}
```

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: Einen Amazon-ECS-Service erstellen
<a name="create-blue-green-service"></a>

Verwenden Sie den Befehl [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html), 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
```

## Schritt 5: Erstellen Sie die Ressourcen AWS CodeDeploy
<a name="create-blue-green-codedeploy"></a>

Gehen Sie wie folgt vor, um Ihre CodeDeploy Anwendung, die Application Load Balancer Balancer-Zielgruppe für die CodeDeploy Bereitstellungsgruppe und die CodeDeploy Bereitstellungsgruppe zu erstellen.

**Um Ressourcen zu erstellen CodeDeploy**

1. Verwenden Sie den Befehl [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html), um eine CodeDeploy Anwendung zu erstellen. 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"
   }
   ```

1. Verwenden Sie den Befehl [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html), um eine zweite Application Load Balancer Balancer-Zielgruppe zu erstellen, die bei der Erstellung Ihrer Bereitstellungsgruppe verwendet wird. CodeDeploy 

   ```
   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
   ```

1. Verwenden Sie den Befehl [create-deployment-group, um eine Bereitstellungsgruppe](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html) zu erstellen. CodeDeploy 

   Erstellen Sie zuerst eine Datei mit dem Namen `tutorial-deployment-group.json` und dem folgenden Inhalt. Dieses Beispiel verwendet die von Ihnen erstellte Ressource. Geben Sie für die `serviceRoleArn` den ARN Ihrer Amazon CodeDeploy ECS-IAM-Rolle an. Weitere Informationen finden Sie unter [Amazon ECS CodeDeploy IAM-Rolle](codedeploy_IAM_role.md).

   ```
   {
      "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}}"
          }
      ]
   }
   ```

   Erstellen Sie dann 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: Eine CodeDeploy Bereitstellung erstellen und überwachen
<a name="create-blue-green-verify"></a>

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

**Um eine CodeDeploy Bereitstellung zu erstellen und zu überwachen**

1. Gehen Sie wie folgt vor, um eine AppSpec Datei zu erstellen und hochzuladen.

   1. Erstellen Sie eine Datei mit dem Namen `appspec.yaml` und dem Inhalt der CodeDeploy -Bereitstellungsgruppe. Dieses Beispiel verwendet die Ressourcen, die Sie zuvor im Tutorial erstellt haben.

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

   1. Verwenden Sie den Befehl [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html), um einen Amazon S3 S3-Bucket für die AppSpec Datei zu erstellen.

      ```
      aws s3 mb s3://{{tutorial-bluegreen-bucket}}
      ```

   1. Verwenden Sie den Befehl [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html), um die AppSpec Datei in den Amazon S3 S3-Bucket hochzuladen.

      ```
      aws s3 cp ./appspec.yaml s3://{{tutorial-bluegreen-bucket}}/{{appspec.yaml}}
      ```

1. Erstellen Sie die CodeDeploy Bereitstellung mithilfe der folgenden Schritte.

   1. Erstellen Sie eine Datei `create-deployment.json` mit dem Namen des Inhalts der CodeDeploy Bereitstellung. 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"
              }
          }
      }
      ```

   1. Verwenden Sie den Befehl [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) 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"
      }
      ```

   1. Verwenden Sie den Befehl [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html), um die Details der Bereitstellung unter Angabe der `deploymentId` aus der vorherigen Ausgabe anzufordern.

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

      Fahren Sie mit dem Abrufen der Bereitstellungsdetails fort, bis der Status `Succeeded` lautet, wie in der folgenden Ausgabe dargestellt.

      ```
      {
          "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": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Schritt 7: Bereinigen
<a name="create-blue-green-cleanup"></a>

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**

1. Verwenden Sie den Befehl [delete-deployment-group, um die Bereitstellungsgruppe](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html) zu löschen. CodeDeploy 

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

1. Verwenden Sie den Befehl [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html), um die Anwendung zu löschen. CodeDeploy 

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

1. Verwenden Sie den Befehl [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html), 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}}
   ```

1. Verwenden Sie den Befehl [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html), um den Amazon-ECS-Cluster zu löschen.

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

1. Verwenden Sie den Befehl [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html), um die AppSpec Datei aus dem Amazon S3 S3-Bucket zu löschen.

   ```
   aws s3 rm s3://{{tutorial-bluegreen-bucket/appspec.yaml}}
   ```

1. Verwenden Sie den Befehl [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) zum Löschen des Amazon S3-Buckets.

   ```
   aws s3 rb s3://{{tutorial-bluegreen-bucket}}
   ```

1. Um Ihren Application Load Balancer zu löschen, verwenden Sie den Befehl [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html).

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

1. Verwenden Sie den Befehl [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html), um die zwei 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}}
   ```