Prerequisiti Fase 1: Creazione di un Application Load Balancer Fase 2: creazione di un cluster Amazon ECS Fase 3: Registra una definizione di attività Fase 4: creazione di un servizio Amazon ECS Fase 5: Creare le risorse AWS CodeDeploy Fase 6: creazione e monitoraggio di una CodeDeploy distribuzione Fase 7: eliminare

Tutorial: creazione di un servizio utilizzando una distribuzione Blue/Green

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.

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 nella Guida per l'AWS CloudFormation utente.

Prerequisiti

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 di. AWS Command Line Interface
Hai completato le fasi descritte in Configurazione per l'uso di Amazon ECS.
L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM AmazonECS_ FullAccess.
Sono disponibili un VPC e un gruppo di sicurezza creati per l'uso. Per ulteriori informazioni, consulta Crea un cloud privato virtuale.
Viene creato il ruolo CodeDeploy IAM di Amazon ECS. Per ulteriori informazioni, consulta Ruolo CodeDeploy IAM di Amazon ECS.

Fase 1: Creazione di un Application Load Balancer

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

Utilizza il comando create-load-balancer 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
```

Utilizzare il comando create-target-group 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

Utilizzare il comando create-listener 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

Utilizzare il comando create-cluster 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à

Utilizza il comando register-task-definition 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.


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

Utilizza il comando create-service 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

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

Utilizzate il comando create-application 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"
}

Utilizzate il comando create-target-group 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

Utilizzate il comando create-deployment-group per creare un gruppo di distribuzione. CodeDeploy

Crea innanzitutto un file denominato tutorial-deployment-group.json con i seguenti contenuti. Questo esempio utilizza la risorsa che è stata creata. Per laserviceRoleArn, specifica l'ARN del tuo ruolo Amazon ECS IAM. CodeDeploy Per ulteriori informazioni, consulta Ruolo CodeDeploy IAM di Amazon ECS.


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

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

Crea e carica un AppSpec file utilizzando i seguenti passaggi.

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"

Usa il comando s3 mb per creare un bucket Amazon S3 per il file. AppSpec
```
aws s3 mb s3://tutorial-bluegreen-bucket
```
Usa il comando s3 cp per caricare il AppSpec file nel bucket Amazon S3.
```
aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
```

Crea la CodeDeploy distribuzione utilizzando i seguenti passaggi.

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

Utilizzare il comando create-deployment 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"
}

Utilizzare il comando get-deployment-target 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

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

Rimozione delle risorse del tutorial

Utilizzate il comando delete-deployment-group per eliminare il gruppo di distribuzione. CodeDeploy


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

Utilizzate il comando delete-application per eliminare l'applicazione. CodeDeploy


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

Utilizza il comando delete-service 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
```

Utilizza il comando delete-cluster per eliminare il cluster Amazon ECS.


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

Usa il comando s3 rm per eliminare il AppSpec file dal bucket Amazon S3.
```
aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
```
Utilizza il comando s3 rb per eliminare il bucket Amazon S3.
```
aws s3 rb s3://tutorial-bluegreen-bucket
```

Utilizza il comando delete-load-balancer 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

Utilizza il comando delete-target-group 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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzo dei AWS Deep Learning Containers

Service Quotas