Tutorial: crea una pipeline con un ECR codice sorgente Amazon e la ECS relativa distribuzione CodeDeploy

Per creare un'immagine

1. Accedi all'istanza Linux in cui è installato Docker.

   Seleziona un'immagine per nginx. Questo comando fornisce l'immagine: nginx:latest

   docker pull nginx

2. Esegui docker images. Dovresti poter visualizzare l'immagine nell'elenco.

   docker images

Per creare un ECR repository Amazon e inviare la tua immagine

1. Crea un ECR repository Amazon per archiviare la tua immagine. Prendi nota del valore di repositoryUri nell'output.

   aws ecr create-repository --repository-name nginx

   Output:

   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }

2. Applica un tag all'immagine con il valore repositoryUri ricavato nella fase precedente.

   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

3. Esegui il aws ecr get-login-password comando, come mostrato in questo esempio per la us-west-2 regione e l'ID dell'account 111122223333.

   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx

4. Invia l'immagine ad Amazon ECR utilizzando il repositoryUri passaggio precedente.

   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

Per creare una definizione di attività per l'immagine

1. Crea un file denominato taskdef.json con i seguenti contenuti. Per image, immetti il nome dell'immagine, ad esempio nginx. Tale valore viene aggiornato quando la pipeline viene eseguita.

   Nota

   Assicurati che il ruolo di esecuzione specificato nella definizione dell'attività contenga AmazonECSTaskExecutionRolePolicy. Per ulteriori informazioni, consulta Amazon ECS Task Execution IAM Role nella Amazon ECS Developer Guide.

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }

2. Registra la definizione dell'attività con il file taskdef.json.

   aws ecs register-task-definition --cli-input-json file://taskdef.json

3. Una volta registrata la definizione dell'attività, modifica il file per rimuovere il nome dell'immagine e includi il testo segnaposto <IMAGE1_NAME> nel campo dell'immagine.

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }

Per creare un AppSpec file

• Il AppSpec file viene utilizzato per le CodeDeploy distribuzioni. Il file, che comprende campi opzionali, utilizza questo formato:

  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"

  Per ulteriori informazioni sul AppSpec file, inclusi esempi, vedere CodeDeploy AppSpec File Reference.

  Crea un file denominato appspec.yaml con i seguenti contenuti. Per TaskDefinition, non modificare il testo segnaposto <TASK_DEFINITION>. Tale valore viene aggiornato quando la pipeline viene eseguita.

  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80

Per inviare file al tuo CodeCommit repository

1. Invia o carica i file nel tuo CodeCommit repository. Questi file sono l'elemento sorgente creato dalla procedura guidata Create pipeline per l'azione di distribuzione in. CodePipeline I file dovrebbero avere questo aspetto nella directory locale:

   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json

2. Scegli un metodo per caricare i file:

   1. Per usare la riga di comando git da un repository clonato sul computer locale:

      1. Cambia le directory nel repository locale:

         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo

      2. Esegui il comando seguente per posizionare tutti i file contemporaneamente:

         git add -A

      3. Esegui il comando seguente per eseguire il commit dei file con un messaggio di commit:

         git commit -m "Added task definition files"

      4. Esegui il comando seguente per inviare i file dal repository locale al tuo repository: CodeCommit

         git push

   2. Per utilizzare la CodeCommit console per caricare i file:

      1. Apri la CodeCommit console e scegli il tuo repository dall'elenco Repository.

      2. Seleziona Add file (Aggiungi file), quindi scegli Upload file (Carica file).

      3. Seleziona Choose file (Scegli file), quindi seleziona il file. Conferma la modifica inserendo il tuo nome utente e indirizzo e-mail. Scegliere Commit changes (Applica modifiche).

      4. Ripeti questa fase per ogni file da caricare.

Per verificare le sottoreti predefinite VPC e pubbliche

1. Accedi a AWS Management Console e apri la VPC console Amazon all'indirizzo https://console.aws.amazon.com/vpc/.

2. Verifica l'impostazione predefinita VPC da utilizzare. Nel riquadro di navigazione, scegli Your VPCs. Nota che VPC mostra Sì nella VPC colonna Predefinito. Questa è l'impostazione predefinitaVPC. Contiene le sottoreti predefinite da selezionare.

3. Scegli Subnets (Sottoreti). Scegli due sottoreti che mostrano Yes (Sì) nella colonna Default subnet (Sottorete predefinita).

   Nota

   Prendi nota della tua sottoreteIDs. Saranno necessari più avanti in questo tutorial.

4. Scegli le sottoreti, quindi scegli la scheda Description (Descrizione). Verifica che le sottoreti da utilizzare siano in diverse zone di disponibilità.

5. Scegli le sottoreti, quindi scegli la scheda Route Table (Tabella di routing). Per verificare che ciascuna sottorete che desideri utilizzare sia una sottorete pubblica, controlla che una riga di gateway sia inclusa nella tabella di routing.

Per creare un Amazon EC2 Application Load Balancer

1. Accedi a AWS Management Console e apri la EC2 console Amazon all'indirizzo https://console.aws.amazon.com/ec2/.

2. Selezionare Sistemi di bilanciamento del carico nel riquadro di navigazione.

3. Seleziona Crea sistema di bilanciamento del carico.

4. Scegli Application Load Balancer, quindi scegli Create (Crea).

5. In Name (Nome), immetti il nome del sistema di bilanciamento del carico.

6. In Scheme (Schema), scegli internet-facing.

7. In IP address type (Tipo di indirizzo IP), scegli ipv4.

8. Configura due porte listener per il sistema di bilanciamento del carico:

   1. In Load Balancer Protocol, scegli. HTTP In Load Balancer Port (Porta del sistema di bilanciamento del carico), immetti 80.

   2. Scegli Add listener (Aggiungi listener).

   3. In Load Balancer Protocol per il secondo listener, scegliete. HTTP In Load Balancer Port (Porta del sistema di bilanciamento del carico), immetti 8080.

9. In Zone di disponibilità, in VPC, scegli l'impostazione predefinita. VPC Quindi, scegli le due sottoreti predefinite da utilizzare.

10. Seleziona Next: Configure Security Settings (Fase successiva: configurazione delle impostazioni di sicurezza).

11. Seleziona Next: Configure Security Groups (Fase successiva: configurazione dei gruppi di sicurezza).

12. Scegli Select an existing security group (Seleziona un gruppo di sicurezza esistente) e prendi nota dell'ID del gruppo di sicurezza.

13. Seleziona Successivo: Configurazione del routing.

14. In Target group (Gruppo di destinazione), scegli New target group (Nuovo gruppo di destinazione) e configura il primo gruppo di destinazione:

    1. In Name (Nome), immetti il nome di un gruppo di destinazione (ad esempio, target-group-1).

    2. In Target type (Tipo di destinazione), scegli IP.

    3. In Protocollo scegli HTTP. In Port (Porta), immetti 80.

    4. Seleziona Next: Register Targets (Fase successiva: registrazione delle destinazioni).

15. Scegli Next: Review (Fase successiva: revisione), quindi seleziona Create (Crea).

Per creare un secondo gruppo di destinazione per il sistema di bilanciamento del carico

1. Dopo aver effettuato il provisioning del sistema di bilanciamento del carico, apri la console AmazonEC2. Seleziona Gruppi di destinazioni nel riquadro di navigazione.

2. Scegliere Crea gruppo target.

3. In Name (Nome), immetti il nome di un gruppo di destinazione (ad esempio, target-group-2).

4. In Target type (Tipo di destinazione), scegli IP.

5. In Protocollo scegli. HTTP In Port (Porta), immetti 8080.

6. In VPC, scegli l'impostazione predefinitaVPC.

7. Scegli Create (Crea) .

   Nota

   È necessario disporre di due gruppi di destinazione creati per il sistema di bilanciamento del carico affinché la distribuzione si avvii. Devi solo prendere nota ARN del tuo primo gruppo target. Questo ARN viene utilizzato nel create-service JSON file nel passaggio successivo.

Per aggiornare il sistema di bilanciamento del carico per includere il secondo gruppo di destinazione

1. Apri la EC2 console Amazon. Selezionare Sistemi di bilanciamento del carico nel riquadro di navigazione.

2. Seleziona il sistema di bilanciamento del carico, quindi la scheda Listeners (Listener). Scegli il listener con porta 8080 e quindi scegli Edit (Modifica).

3. Seleziona l'icona della matita accanto a Forward to (Inoltra a). Scegli il secondo gruppo di destinazione e quindi seleziona il segno di spunta. Seleziona Update (Aggiorna) per salvare gli aggiornamenti.

Per creare un ECS cluster Amazon

1. Apri la console Amazon ECS Classic all'indirizzo https://console.aws.amazon.com/ecs/.

2. Nel pannello di navigazione scegliere Clusters (Cluster).

3. Scegli Crea cluster.

4. Scegli il modello di cluster Solo rete che utilizza AWS Fargate, quindi scegli Passaggio successivo.

5. Nella pagina Configure cluster (Configura cluster), immetti un nome di cluster. È possibile aggiungere un tag facoltativo per la risorsa. Scegli Create (Crea) .

Per creare un ECS servizio Amazon

Usa il AWS CLI per creare il tuo servizio in AmazonECS.

1. Crea un JSON file e assegnagli un nomecreate-service.json. Incolla quanto segue nel JSON file.

   Per il taskDefinition campo, quando registri una definizione di attività in AmazonECS, le dai una famiglia. L'operazione è analoga a un nome per più versioni della definizione di attività, specificato con un numero di revisione. In questo esempio, utilizza "ecs-demo:1" per la famiglia e il numero di revisione nel file. Utilizzare i nomi di sottorete, il gruppo di sicurezza e il valore del gruppo di destinazione creati con il sistema di bilanciamento del carico in Fase 3: creazione dell'Application Load Balancer e dei gruppi di destinazione .

   Nota

   Devi includere il tuo gruppo target ARN in questo file. Apri la EC2 console Amazon e dal pannello di navigazione, sotto LOADBALANCING, scegli Target Groups. Scegli il primo gruppo di destinazione. Copia il tuo ARN dalla scheda Descrizione.

   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }

2. Esegui il create-service comando, specificando il JSON file:

   Importante

   Assicurarsi di includere file:// prima del nome del file. Questo è obbligatorio in questo comando.

   Questo esempio crea un servizio denominato my-service.

   Nota

   In questo esempio il comando crea un servizio denominato my-service. Se si dispone già di un servizio con questo nome, il comando restituisce un errore.

   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json

   L'output restituisce i campi di descrizione per il servizio.

3. Esegui il comando describe-services per verificare l'avvenuta creazione del servizio.

   aws ecs describe-services --cluster cluster-name --services service-name

Per creare CodeDeploy un'applicazione

1. Apri la CodeDeploy console e scegli Crea applicazione.

2. In Application name (Nome applicazione), immetti il nome da utilizzare.

3. Nella piattaforma Compute, scegli Amazon ECS.

4. Scegli Crea applicazione.

Per creare un gruppo di CodeDeploy distribuzione

1. Nella pagina dell'applicazione, nella scheda Deployment groups (Gruppi di distribuzione), scegli Create deployment group (Crea gruppo di distribuzione).

2. In Deployment group name (Nome gruppo di distribuzione), inserire un nome che descriva il gruppo di distribuzione.

3. In Ruolo di servizio, scegli un ruolo di servizio che consenta l' CodeDeployaccesso ad AmazonECS. Per creare un nuovo ruolo del servizio, attenersi alla seguente procedura:

   1. Apri la IAM console all'indirizzo https://console.aws.amazon.com/iam/).

   2. Dal pannello di controllo della console, scegli Roles (Ruoli).

   3. Scegliere Crea ruolo.

   4. In Seleziona il tipo di entità attendibile, seleziona AWS servizio. In Scegli un caso d'uso, seleziona CodeDeploy. In Seleziona il tuo caso d'uso, seleziona CodeDeploy - ECS. Scegli Successivo: autorizzazioni. La policy gestita AWSCodeDeployRoleForECS è già collegata al ruolo.

   5. Scegli Next: Tags (Successivo: Tag) e Next: Review (Successivo: Verifica).

   6. Immetti un nome per il ruolo, ad esempio CodeDeployECSRole, quindi seleziona Create role (Crea ruolo).

4. Nella configurazione dell'ambiente, scegli il nome ECS del cluster Amazon e il nome del servizio.

5. In Load balancer, scegli il nome del load balancer che serve il traffico verso il tuo servizio Amazon. ECS

6. Da Production listener port, scegli la porta e il protocollo per il listener che fornisce il traffico di produzione al tuo servizio Amazon. ECS Da Test listener port (Porta listener test), scegli la porta e il protocollo per il listener test.

7. Da Target group 1 name (Nome gruppo di destinazione 1) e Target group 2 name (Nome gruppo di destinazione 2), scegli i gruppi di destinazione utilizzati per instradare il traffico durante la distribuzione. Assicurati che questi siano i gruppi di destinazione creati per il sistema di bilanciamento del carico.

8. Scegli Reindirizzare immediatamente il traffico per determinare quanto tempo dopo una corretta implementazione reindirizzare il traffico verso la tua attività Amazon aggiornata. ECS

9. Scegliere Create deployment group (Crea gruppo di distribuzione).

Per creare una pipeline a due fasi con la procedura guidata

1. Accedi AWS Management Console e apri la CodePipeline console all'indirizzo http://console.aws.amazon.com/codesuite/codepipeline/home.

2. Nella pagina Welcome (Benvenuto), pagina Getting started (Nozioni di base) o pagina Pipelines (Pipeline), scegliere Create pipeline (Crea pipeline).

3. In Step 1: Choose pipeline settings (Fase 1: scelta delle impostazioni della pipeline), in Pipeline name (Nome pipeline), immettere MyImagePipeline.

4. Nel tipo di pipeline, scegli V2. Per ulteriori informazioni, consulta Tipi di tubazioni. Scegli Next (Successivo).

5. In Ruolo di servizio, scegli Nuovo ruolo di servizio in cui consentire CodePipeline la creazione di un ruolo di servizio. IAM

6. Lasciare i valori predefiniti delle impostazioni in Advanced settings (Impostazioni avanzate), quindi scegliere Next (Successivo).

7. In Step 2: Add source stage (Fase 2: aggiunta della fase di origine), in Source provider (Provider origine), scegliere AWS CodeCommit. In Nome archivio, scegli il nome del CodeCommit repository in cui hai creato. Fase 1: Creare un CodeCommit repository In Branch name (Nome ramo), scegliere il nome del ramo che contiene l'aggiornamento di codice più recente.

   Scegli Next (Successivo).

8. In Step 3: Add build stage (Fase 3: aggiunta della fase di compilazione), scegli Skip build stage (Ignora fase di compilazione) e quindi accetta il messaggio di avviso scegliendo Skip (Ignora). Scegli Next (Successivo).

9. In Step 4: Add deploy stage (Fase 4: aggiunta della fase di distribuzione):

   1. In Deploy provider, scegli Amazon ECS (Blue/Green). In Application name (Nome applicazione) immetti o scegli il nome dell'applicazione dall'elenco, ad esempio codedeployapp. In Deployment group (Gruppo di distribuzione), immetti o scegli il gruppo di distribuzione dall'elenco, ad esempio codedeploydeplgroup.

      Nota

      Il nome "Deploy (Distribuzione)" è quello assegnato per impostazione predefinita alla fase creata in Fase 4: distribuzione, così come "Source (Origine)" è il nome assegnato alla prima fase della pipeline.

   2. In Amazon ECS task definition, scegli SourceArtifact. Nel campo, immetti taskdef.json.

   3. In AWS CodeDeploy AppSpec File, scegli SourceArtifact. Nel campo, immetti appspec.yaml.

      Nota

      In questa fase, non immettere nessuna informazione in Dynamically update task definition image (Aggiorna dinamicamente l'immagine di definizione dell'attività).

   4. Scegli Next (Successivo).

10. In Step 5: Review (Fase 5: revisione), esaminare le informazioni e quindi scegliere Create pipeline (Crea pipeline).

Per aggiungere un'azione ECR sorgente Amazon alla tua pipeline

Visualizza la tua pipeline e aggiungi un'azione ECR sorgente Amazon alla tua pipeline.

1. Seleziona la pipeline. In alto a sinistra, scegliere Edit (Modifica).

2. Nella fase di origine, scegli Edit stage (Modifica fase).

3. Aggiungi un'azione parallela selezionando + Aggiungi azione accanto all'azione CodeCommit sorgente.

4. In Action name (Nome operazione), immetti un nome (ad esempio, Image).

5. In Provider Action, scegli Amazon ECR.

   

6. In Nome repository, scegli il nome del tuo ECR repository Amazon.

7. In Image tag (Tag immagine), specifica il nome e la versione dell'immagine, se diverso da LATEST.

8. In Elementi di output, scegli l'elemento di output predefinito (ad esempio,MyImage) che contiene il nome dell'immagine e le URI informazioni del repository che desideri utilizzare nella fase successiva.

9. Scegli Save (Salva) nella schermata dell'operazione. Scegli Done (Fatto) nella schermata della fase. Scegli Save (Salva) nella pipeline. Un messaggio mostra la regola Amazon CloudWatch Events da creare per l'Amazon ECR source action.

Per collegare gli artefatti di origine all'operazione di distribuzione

1. Scegli Modifica nella fase di distribuzione e scegli l'icona per modificare l'azione Amazon ECS (blu/verde).

2. Scorri fino alla fine del riquadro. In Input artifacts (Artefatti di input), scegli Add (Aggiungi). Aggiungi l'elemento sorgente dal tuo nuovo ECR repository Amazon (ad esempio,). MyImage

3. In Task Definition, scegli SourceArtifact, quindi inserisci la verificataskdef.json.

4. In AWS CodeDeploy AppSpec File, scegliete SourceArtifact, quindi appspec.yaml viene inserita la verifica.

5. In Aggiorna dinamicamente l'immagine di definizione dell'attività, in Inserisci artifatto con URI immagine, MyImagescegli, quindi inserisci il testo segnaposto utilizzato nel file:. taskdef.json IMAGE1_NAME Seleziona Salva.

6. Nel AWS CodePipeline riquadro, scegliete Salva modifica alla pipeline, quindi scegliete Salva modifica. Visualizza la pipeline aggiornata.

   Dopo la creazione di questa pipeline di esempio, la configurazione dell'operazione per le voci della console viene visualizzata nella struttura della pipeline come segue:

   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   

7. Per inviare le modifiche e avviare una compilazione tramite pipeline, scegliere Release change (Rilascia modifica) e quindi scegliere Release (Rilascia).

8. Scegli l'azione di distribuzione in cui visualizzarla CodeDeploy e vedere l'avanzamento dello spostamento del traffico.

   Nota

   È possibile che venga visualizzato un passaggio di distribuzione che mostra un tempo di attesa opzionale. Per impostazione predefinita, CodeDeploy attende un'ora dopo una corretta distribuzione prima di terminare il set di attività originale. È possibile utilizzare questo tempo per ripristinare o terminare l'attività. La distribuzione viene completata al termine del set di attività.