Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tutorial: creazione di un servizio utilizzando una distribuzione Blue/Green
<a name="create-blue-green"></a>

Amazon ECS ha integrato le blue/green distribuzioni nella procedura guidata Create Service sulla console Amazon ECS. Per ulteriori informazioni, consulta [Creazione di un'implementazione di aggiornamenti continui di Amazon ECS](create-service-console-v2.md).

Il seguente tutorial mostra come creare un servizio Amazon ECS contenente un'attività Fargate che utilizza blue/green il tipo di distribuzione con. AWS CLI

**Nota**  
È stato aggiunto il supporto per l'esecuzione di una blue/green distribuzione per CloudFormation. *Per ulteriori informazioni, consulta [Eseguire le blue/green distribuzioni di Amazon ECS tramite CodeDeploy l'utilizzo CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) nella Guida per l'AWS CloudFormation utente.*

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

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ La versione più recente di AWS CLI è installata e configurata. Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, vedere [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) di. AWS Command Line Interface
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM [AmazonECS\_ FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Sono disponibili un VPC e un gruppo di sicurezza creati per l'uso. Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Viene creato il ruolo CodeDeploy IAM di Amazon ECS. Per ulteriori informazioni, consulta [Ruolo CodeDeploy IAM di Amazon ECS](codedeploy_IAM_role.md).

## Fase 1: Creazione di un Application Load Balancer
<a name="create-blue-green-loadbalancer"></a>

I servizi Amazon ECS che utilizzano il tipo di blue/green implementazione possono utilizzare Application Load Balancer, Network Load Balancer, Service Connect o essere headless. Per gestire lo spostamento del traffico, è necessario un sistema di bilanciamento del carico o Service Connect. In questa esercitazione viene utilizzato un Application Load Balancer.

**Per creare un Application Load Balancer**

1. Utilizza il comando [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html) per creare un Application Load Balancer. Specificare due sottoreti che non appartengono alla stessa zona di disponibilità, nonché un gruppo di sicurezza.

   ```
   aws elbv2 create-load-balancer \
        --name {{bluegreen-alb}} \
        --subnets {{subnet-abcd1234}} {{subnet-abcd5678}} \
        --security-groups {{sg-abcd1234}} \
        --region {{us-east-1}}
   ```

   L'output include l'Amazon Resource Name (ARN) del load balancer, con il formato seguente:

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

1. Utilizzare il comando [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html) per creare un gruppo target. Questo gruppo target instraderà il traffico verso il set di attività originale nel servizio.

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

   L'output include l'ARN del gruppo target, con il seguente formato:

   ```
   arn:aws:elasticloadbalancing:{{region}}:{{aws_account_id}}:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Utilizzare il comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) per creare un listener del load balancer con una regola predefinita che inoltra le richieste al gruppo target.

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

   L'output include l'ARN del listener, con il formato seguente:

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

## Fase 2: creazione di un cluster Amazon ECS
<a name="create-blue-green-cluster"></a>

Utilizzare il comando [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html) per creare un cluster denominato `tutorial-bluegreen-cluster` da utilizzare.

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

L'output include l'ARN del cluster, con il formato seguente:

```
arn:aws:ecs:{{region}}:{{aws_account_id}}:cluster/tutorial-bluegreen-cluster
```

## Fase 3: Registra una definizione di attività
<a name="create-blue-green-taskdef"></a>

Utilizza il comando [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html) per registrare una definizione di attività compatibile con Fargate. Devi usare la modalità di rete `awsvpc`. Di seguito è riportata la definizione di attività di esempio usata per questo tutorial.

Crea innanzitutto un file denominato `fargate-task.json` con i seguenti contenuti. Assicurati di utilizzare l'ARN del ruolo di esecuzione dell'attività. Per ulteriori informazioni, consulta [Ruolo IAM di esecuzione di attività Amazon ECS](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"
}
```

Quindi, registra la definizione di attività utilizzando il file `fargate-task.json` creato.

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

## Fase 4: creazione di un servizio Amazon ECS
<a name="create-blue-green-service"></a>

Utilizza il comando [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html) per creare un servizio. 

Crea innanzitutto un file denominato `service-bluegreen.json` con i seguenti contenuti.

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

Quindi, crea il servizio utilizzando il file `service-bluegreen.json` creato.

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

L'output include l'ARN del servizio, con il formato seguente:

```
arn:aws:ecs:{{region}}:{{aws_account_id}}:service/service-bluegreen
```

## Fase 5: Creare le risorse AWS CodeDeploy
<a name="create-blue-green-codedeploy"></a>

Utilizza i seguenti passaggi per creare CodeDeploy l'applicazione, il gruppo target Application Load Balancer per il gruppo di CodeDeploy distribuzione e il gruppo di CodeDeploy distribuzione.

**Per creare risorse CodeDeploy**

1. Utilizzate il comando [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html) per creare un' CodeDeploy applicazione. Specificare la piattaforma di calcolo `ECS`.

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

   L'output include l'ID applicazione, con il formato seguente:

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

1. Utilizzate il comando [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html) per creare un secondo gruppo target di Application Load Balancer, che verrà utilizzato durante la creazione del gruppo di distribuzione. CodeDeploy 

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

   L'output include l'ARN per il gruppo target, con il seguente formato:

   ```
   arn:aws:elasticloadbalancing:{{region}}:{{aws_account_id}}:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Utilizzate il comando [create-deployment-group per creare un gruppo di distribuzione](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html). CodeDeploy 

   Crea innanzitutto un file denominato `tutorial-deployment-group.json` con i seguenti contenuti. Questo esempio utilizza la risorsa che è stata creata. Per la`serviceRoleArn`, specifica l'ARN del tuo ruolo Amazon ECS IAM. CodeDeploy Per ulteriori informazioni, consulta [Ruolo CodeDeploy IAM di Amazon ECS](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}}"
          }
      ]
   }
   ```

   Quindi crea il gruppo di CodeDeploy distribuzione.

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

   L'output include l'ID del gruppo di distribuzione, con il formato seguente:

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

## Fase 6: creazione e monitoraggio di una CodeDeploy distribuzione
<a name="create-blue-green-verify"></a>

Utilizza i seguenti passaggi per creare e caricare un file di specifiche dell'applicazione (AppSpec file) e una CodeDeploy distribuzione.

**Per creare e monitorare una CodeDeploy distribuzione**

1. Crea e carica un AppSpec file utilizzando i seguenti passaggi.

   1. Creare un file denominato `appspec.yaml` con il contenuto del gruppo di distribuzione CodeDeploy . Questo esempio utilizza le risorse create in precedenza nel tutorial.

      ```
      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. Usa il comando [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) per creare un bucket Amazon S3 per il file. AppSpec 

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

   1. Usa il comando [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) per caricare il AppSpec file nel bucket Amazon S3.

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

1. Crea la CodeDeploy distribuzione utilizzando i seguenti passaggi.

   1. Crea un file denominato `create-deployment.json` con il contenuto della CodeDeploy distribuzione. Questo esempio utilizza le risorse create in precedenza nel tutorial.

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

   1. Utilizzare il comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) per creare l'implementazione.

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

      L'output include l'ID di distribuzione, con il formato seguente:

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Utilizzare il comando [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html) per ottenere i dettagli dell'implementazione, specificando il `deploymentId` dall'output precedente.

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

      Continuare a recuperare i dettagli di distribuzione fino a quando lo stato è `Succeeded`, come mostrato nel seguente output.

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

## Fase 7: eliminare
<a name="create-blue-green-cleanup"></a>

Una volta terminato questo tutorial, rimuovi le risorse associate per evitare costi aggiuntivi per risorse che non utilizzi.

**Rimozione delle risorse del tutorial**

1. Utilizzate il comando [delete-deployment-group per eliminare il gruppo di](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html) distribuzione. CodeDeploy 

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

1. Utilizzate il comando [delete-application per eliminare](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) l'applicazione. CodeDeploy 

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

1. Utilizza il comando [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html) per eliminare il servizio Amazon ECS. L'uso del flag `--force` consente di eliminare un servizio anche se il numero di attività non è stato ridotto a zero.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:{{region}}:{{aws_account_id}}:service/{{service-bluegreen}} \
        --force \
        --region {{us-east-1}}
   ```

1. Utilizza il comando [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html) per eliminare il cluster Amazon ECS.

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

1. Usa il comando [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) per eliminare il AppSpec file dal bucket Amazon S3.

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

1. Utilizza il comando [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) per eliminare il bucket Amazon S3.

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

1. Utilizza il comando [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html) per eliminare l'Application Load Balancer:

   ```
   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. Utilizza il comando [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html) per eliminare i due gruppi di destinazione di Application Load Balancer.

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