Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-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 repository Amazon ECR e inviare la tua immagine

1. Crea un repository Amazon ECR per archiviare l'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 file AppSpec

• 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'artefatto di origine creato dalla procedura guidata Create pipeline (Crea pipeline) per l'operazione 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 CodeCommit repository:

         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 il VPC predefinito e le sottoreti pubbliche

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

2. Verifica il VPC predefinito da utilizzare. Nel riquadro di navigazione, scegli Your VPCs. Controlla quale VPC mostra Yes (Sì) nella colonna Default VPC (VPC predefinito). Questo è il VPC predefinito. 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 sottorete IDs. 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 (Protocollo del sistema di bilanciamento del carico), 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 (Protocollo del sistema di bilanciamento del carico) per il secondo listener, scegli HTTP. In Load Balancer Port (Porta del sistema di bilanciamento del carico), immetti 8080.

9. In Availability Zones (Zone di disponibilità), in VPC, scegli il VPC predefinito. 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 Protocol (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 Amazon EC2 . 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 Protocol (Protocollo), scegli HTTP. In Port (Porta), immetti 8080.

6. In VPC, scegli il VPC predefinito.

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. È necessario solo annotare l'ARN del primo gruppo di destinazione. Questo ARN è utilizzato nel file JSON create-service nella prossima fase.

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.

Come creare un cluster Amazon ECS

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 servizio Amazon ECS

Usa il AWS CLI per creare il tuo servizio in Amazon ECS.

1. Crea un file JSON e denominalo create-service.json. Incolla quanto segue nel file JSON.

   Per il taskDefinition campo, quando registri una definizione di attività in Amazon ECS, 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

   È necessario includere l'ARN del gruppo di destinazione in questo file. Apri la EC2 console Amazon e dal pannello di navigazione, in LOAD BALANCING, scegli Target Groups. Scegli il primo gruppo di destinazione. Copia l'ARN dalla scheda Description (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 comando create-service e specifica il file JSON:

   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. In Compute platform (Piattaforma di calcolo), scegli Amazon ECS.

4. Scegli Crea applicazione.

Per creare un gruppo CodeDeploy di 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 garantisca CodeDeploy l'accesso ad Amazon ECS. Per creare un nuovo ruolo del servizio, attenersi alla seguente procedura:

   1. Apri la console IAM 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à affidabile, seleziona Servizio AWS. 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. In Configurazione dell'ambiente, scegli il nome del cluster Amazon ECS 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 (Porta del listener di produzione), scegli la porta e il protocollo per il listener che serve il traffico di produzione al 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 ECS aggiornata.

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. Nella pagina Passaggio 1: Scegli l'opzione di creazione, in Opzioni di creazione, scegli l'opzione Crea pipeline personalizzata. Scegli Next (Successivo).

4. Nel Passaggio 2: Scegliete le impostazioni della pipeline, in Nome della tubazione, immettete. MyImagePipeline

5. CodePipeline fornisce condotte di tipo V1 e V2, che differiscono per caratteristiche e prezzo. Il tipo V2 è l'unico tipo che puoi scegliere nella console. Per ulteriori informazioni, consulta i tipi di pipeline. Per informazioni sui prezzi di CodePipeline, consulta la sezione Prezzi.

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

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

8. Nel passaggio 3: Aggiungi la fase di origine, in Provider di origine, scegli AWS CodeCommit. In Repository name (Nome repository), scegliere il nome del repository CodeCommit creato in Passaggio 1: crea un CodeCommit repository. In Branch name (Nome ramo), scegliere il nome del ramo che contiene l'aggiornamento di codice più recente.

   Scegli Next (Successivo).

9. Nel passaggio 4: Aggiungi la fase di compilazione, scegli Ignora fase di compilazione, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora. Scegli Next (Successivo).

10. Nel passaggio 5: aggiungi la fase di test, scegli Ignora fase di test, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.

    Scegli Next (Successivo).

11. Nel passaggio 6: aggiungi la fase di implementazione:

    1. In Deploy provider (Distribuisci provider), scegli Amazon ECS (Blue/Green) (Blu/verde)). 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. Nella definizione delle attività di Amazon ECS, 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).

12. Nel passaggio 7: rivedi, esamina le informazioni, quindi scegli Crea pipeline.

Per aggiungere un'azione sorgente Amazon ECR alla tua pipeline

Visualizza la tua pipeline e aggiungi un'azione sorgente Amazon ECR 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 Action provider (Provider operazione), scegli Amazon ECR.

   

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

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

8. In Output artifacts (Artefatti di output), scegli l'artefatto di output predefinito (ad esempio MyImage), che include il nome dell'immagine e le informazioni di URI del repository che desideri sia utilizzato nella prossima fase.

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'azione sorgente di Amazon ECR.

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 repository Amazon ECR (ad esempio,). MyImage

3. In Task Definition, scegli SourceArtifact, quindi inserisci la verifica. taskdef.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 Input Artifact with Image URI, 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à.