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

Tutorial: creazione di un servizio utilizzando una distribuzione blu/verde

Amazon ECS ha integrato le blue/green distribuzioni nella procedura guidata Create Service sulla console Amazon ECS. Per ulteriori informazioni, consulta Creazione di una distribuzione 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 AWS CloudFormation. Per ulteriori informazioni, consulta Eseguire le distribuzioni blu/green di Amazon ECS tramite l' CodeDeploy utilizzo AWS CloudFormation nella Guida per l'utente.AWS CloudFormation

Prerequisiti

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:

La versione più recente di è installata e configurata. AWS CLI 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.
Il tuo utente IAM dispone delle autorizzazioni richieste specificate nell'esempio di Amazon ECS_ FullAccess policy IAM.
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 richiedono l'uso di un Application Load Balancer o un Network Load Balancer. In questa esercitazione viene utilizzato un Application Load Balancer.

Per creare un Application Load Balancer

Utilizzate il create-load-balancercomando 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
```

Utilizzate il create-target-groupcomando 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: creare 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à

Utilizzate il register-task-definitioncomando 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: Creare 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: Creazione delle 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 create-target-groupcomando per creare un secondo gruppo target di Application Load Balancer, che verrà utilizzato durante la creazione del gruppo di CodeDeploy distribuzione.


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 create-deployment-groupcomando per creare un gruppo CodeDeploy di distribuzione.

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: creare e monitorare una distribuzione CodeDeploy

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

Utilizzate il get-deployment-targetcomando per ottenere i dettagli della distribuzione, specificando l'deploymentIdoutput 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

Usa il delete-deployment-groupcomando per eliminare il gruppo CodeDeploy di distribuzione.


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' CodeDeploy applicazione.


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

Utilizzate il delete-load-balancercomando 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

Utilizzate il delete-target-groupcomando per eliminare i due gruppi target 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

Quote del servizio