

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: creare una pipeline con una fonte e una distribuzione Amazon ECR ECS-to-CodeDeploy

In questo tutorial, configuri una pipeline in cui vengono distribuite applicazioni container utilizzando una blue/green distribuzione AWS CodePipeline che supporti le immagini Docker. In una blue/green distribuzione, puoi avviare la nuova versione dell'applicazione insieme alla vecchia versione e testare la nuova versione prima di reindirizzare il traffico. Puoi anche monitorare il processo di distribuzione e ripristinarlo rapidamente in caso di problemi.

**Importante**  
Come parte della creazione di una pipeline, per gli artefatti verrà utilizzato un bucket S3 fornito dal cliente. CodePipeline (Questo è diverso dal bucket utilizzato per un'azione sorgente S3). Se il bucket di artefatti S3 si trova in un account diverso dall'account della pipeline, assicurati che il bucket di artefatti S3 sia di proprietà di persone sicure e affidabili. Account AWS 

**Nota**  
Questo tutorial illustra l'azione di distribuzione di Amazon ECS per. CodeDeploy blue/green CodePipeline Per un tutorial che utilizza l'azione di distribuzione standard di Amazon ECS in, consulta. CodePipeline [Tutorial: distribuzione standard di Amazon ECS con CodePipeline](ecs-cd-pipeline.md)

La pipeline completata rileva le modifiche all'immagine, che viene archiviata in un repository di immagini come Amazon ECR e utilizzata CodeDeploy per indirizzare e distribuire il traffico verso un cluster Amazon ECS e un sistema di bilanciamento del carico. CodeDeploy utilizza un listener per reindirizzare il traffico verso la porta del contenitore aggiornato specificato nel file. AppSpec Per informazioni su come vengono utilizzati il load balancer, il listener di produzione, i gruppi target e l'applicazione Amazon ECS in una blue/green distribuzione, consulta [ Tutorial: Deploy an Amazon ECS Service. ](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html)

La pipeline è inoltre configurata per utilizzare una posizione di origine, ad esempio in cui è archiviata la definizione di attività di CodeCommit Amazon ECS. In questo tutorial, configuri ciascuna di queste AWS risorse e quindi crei la pipeline con fasi che contengono azioni per ciascuna risorsa.

La tua pipeline di distribuzione continua creerà e distribuirà automaticamente immagini di container ogni volta che il codice sorgente viene modificato o una nuova immagine di base viene caricata su Amazon ECR.

Questo flusso utilizza i seguenti artefatti:
+ Un file di immagine Docker che specifica il nome del contenitore e l'URI del repository di immagini Amazon ECR.
+ Una definizione di attività Amazon ECS che elenca il nome dell'immagine Docker, il nome del contenitore, il nome del servizio Amazon ECS e la configurazione del load balancer.
+ Un CodeDeploy AppSpec file che specifica il nome del file di definizione delle attività di Amazon ECS, il nome del contenitore dell'applicazione aggiornata e la porta del contenitore su cui reindirizza il traffico di produzione. CodeDeploy Puoi anche specificare la configurazione di rete opzionale e le funzioni Lambda che puoi eseguire durante gli hook di eventi del ciclo di vita di distribuzione.

**Nota**  
Quando esegui il commit di una modifica al tuo repository di immagini Amazon ECR, l'azione sorgente della pipeline crea un file per quel commit. `imageDetail.json` Per ulteriori informazioni sul file `imageDetail.json`, consulta [file di immagine per le azioni di distribuzione di Amazon ECS Detail.json blue/green](file-reference.md#file-reference-ecs-bluegreen).

Quando crei o modifichi la pipeline e aggiorni o specifichi artefatti di origine per la fase di distribuzione, assicurati di puntare agli artefatti di origine con il nome e la versione più recenti da utilizzare. Dopo aver configurato la pipeline, quando modifichi la definizione dell'immagine o dell'attività, potrebbe essere necessario aggiornare i file di artefatti di origine nei repository e quindi modificare la fase di distribuzione nella pipeline.

**Topics**
+ [Prerequisiti](#tutorials-ecs-ecr-codedeploy-prereq)
+ [Fase 1: Creare un'immagine e inviarla a un repository Amazon ECR](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [Fase 2: Creare la definizione delle attività e i file AppSpec di origine e inviarli a un repository CodeCommit](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [Fase 3: creazione dell'Application Load Balancer e dei gruppi di destinazione](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [Fase 4: Crea il tuo cluster e servizio Amazon ECS](#tutorials-ecs-ecr-codedeploy-cluster)
+ [Fase 5: Crea CodeDeploy l'applicazione e il gruppo di distribuzione (piattaforma di calcolo ECS)](#tutorials-ecs-ecr-codedeploy-deployment)
+ [Fase 6: creazione della pipeline](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [Fase 7: modifica della pipeline e verifica della distribuzione](#tutorials-ecs-ecr-codedeploy-update)

## Prerequisiti
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

Devi aver già creato le seguenti risorse:
+ Un repository. CodeCommit Puoi usare il AWS CodeCommit repository in cui hai creato. [Tutorial: creare una semplice pipeline (CodeCommit repository)](tutorials-simple-codecommit.md)
+ Avvia un'istanza Amazon EC2 Linux e installa Docker per creare un'immagine come mostrato in questo tutorial. Se disponi già di un'immagine che intendi utilizzare, puoi ignorare questo prerequisito.

## Fase 1: Creare un'immagine e inviarla a un repository Amazon ECR
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

In questa sezione, usi Docker per creare un'immagine e poi usi AWS CLI per creare un repository Amazon ECR e inviare l'immagine al repository.

**Nota**  
Se disponi già di un'immagine che intendi utilizzare, puoi ignorare questa fase.

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

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

   ```
   docker images
   ```

**Per creare un repository Amazon ECR e inviare l'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"
       }
   }
   ```

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

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

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

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

## Fase 2: Creare la definizione delle attività e i file AppSpec di origine e inviarli a un repository CodeCommit
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

In questa sezione, crei un file JSON di definizione delle attività e lo registri con Amazon ECS. Quindi crei un AppSpec file CodeDeploy e utilizzi il tuo client Git per inviare i file al tuo CodeCommit repository.

**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 il ruolo IAM di [ Amazon ECS Task Execution ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) 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"
   }
   ```

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

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

1. 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 alcuni esempi, vedere [ CodeDeploy AppSpec File Reference](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html).

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

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

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

         ```
         git add -A
         ```

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

         ```
         git commit -m "Added task definition files"
         ```

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

         ```
         git push
         ```

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

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

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

      1. 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)**.

      1. Ripeti questa fase per ogni file da caricare.

## Fase 3: creazione dell'Application Load Balancer e dei gruppi di destinazione
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

In questa sezione, crei un Application Load Balancer di Amazon EC2. Utilizzi i nomi delle subnet e i valori dei gruppi target creati con il load balancer in un secondo momento, quando crei il servizio Amazon ECS. Puoi creare un Application Load Balancer o un Network Load Balancer. Il sistema di bilanciamento del carico deve utilizzare un VPC con due sottoreti pubbliche in zone di disponibilità diverse. In queste fasi, confermerai il VPC predefinito, creerai un sistema di bilanciamento del carico, quindi due gruppi di destinazione per il sistema di bilanciamento del carico. Per ulteriori informazioni, consulta [Gruppi di destinazione per i Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html).

**Per verificare il VPC predefinito e le sottoreti pubbliche**

1. Accedi Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [ https://console.aws.amazon.com/vpc/ ](https://console.aws.amazon.com/vpc/)

1. Verifica il VPC predefinito da utilizzare. Nel pannello di navigazione, scegli **Your VPCs (I tuoi VPC)**. Controlla quale VPC mostra **Yes (Sì)** nella colonna **Default VPC (VPC predefinito)**. Questo è il VPC predefinito. Contiene le sottoreti predefinite da selezionare.

1. Scegli **Subnets (Sottoreti)**. Scegli due sottoreti che mostrano **Yes (Sì)** nella colonna **Default subnet (Sottorete predefinita)**.
**Nota**  
Annota gli ID delle sottoreti. Saranno necessari più avanti in questo tutorial.

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

1. 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 Application Load Balancer di Amazon EC2**

1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [ https://console.aws.amazon.com/ec2/ ](https://console.aws.amazon.com/ec2/)

1. Selezionare **Sistemi di bilanciamento del carico** nel riquadro di navigazione.

1. Seleziona **Crea sistema di bilanciamento del carico**.

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

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

1. In **Scheme (Schema)**, scegli **internet-facing**.

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

1. 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)**, immettere **80**.

   1. Scegli **Add listener (Aggiungi listener)**.

   1. 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)**, immettere **8080**.

1. In **Availability Zones (Zone di disponibilità)**, in **VPC**, scegli il VPC predefinito. Quindi, scegli le due sottoreti predefinite da utilizzare.

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

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

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

1. Seleziona **Successivo: Configurazione del routing**.

1. 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**).

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

   1. In **Protocol (Protocollo)**, scegli **HTTP**. In **Port (Porta)**, immetti **80**.

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

1. 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 load balancer, apri la console Amazon EC2. Seleziona **Gruppi di destinazioni** nel riquadro di navigazione.

1. Scegliere **Crea gruppo target**.

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

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

1. In **Protocol (Protocollo)**, scegli **HTTP**. In **Port (Porta)**, immetti **8080**.

1. In **VPC**, scegli il VPC predefinito.

1. Scegli **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. Aprire la console Amazon EC2. Selezionare **Sistemi di bilanciamento del carico** nel riquadro di navigazione.

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

1. 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.

## Fase 4: Crea il tuo cluster e servizio Amazon ECS
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

In questa sezione, crei un cluster e un servizio Amazon ECS in cui instrada il CodeDeploy traffico durante la distribuzione (verso un cluster Amazon ECS anziché verso le istanze EC2). Per creare il tuo servizio Amazon ECS, devi utilizzare i nomi delle subnet, il gruppo di sicurezza e il valore del gruppo target che hai creato con il tuo load balancer per creare il tuo servizio.

**Nota**  
Quando utilizzi questi passaggi per creare il tuo cluster Amazon ECS, utilizzi il modello di cluster ** Networking only, che fornisce i ** contenitori Fargate. AWS AWS Fargate è una tecnologia che gestisce la tua infrastruttura di istanze di container per te. Non è necessario scegliere o creare manualmente istanze Amazon EC2 per il cluster Amazon ECS.

**Come creare un cluster Amazon ECS**

1. Apri la console classica di Amazon ECS all'indirizzo. [ https://console.aws.amazon.com/ecs/ ](https://console.aws.amazon.com/ecs/)

1. Nel pannello di navigazione scegliere **Cluster**.

1. Scegli **Crea cluster**.

1. Scegli il modello di ** cluster dedicato esclusivamente alla ** rete che utilizza AWS Fargate, quindi scegli Passaggio ** successivo. **

1. Nella pagina **Configure cluster (Configura cluster)**, immetti un nome di cluster. È possibile aggiungere un tag facoltativo per la risorsa. Scegli **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 quanto riguarda il `taskDefinition` campo, quando registri una definizione di attività in Amazon ECS, le assegni 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](#tutorials-ecs-ecr-codedeploy-loadbal).
**Nota**  
È necessario includere l'ARN del gruppo di destinazione in questo file. Apri la console Amazon EC2 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"
           }
       }
   }
   ```

1. 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.

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

   ```
   aws ecs describe-services --cluster {{cluster-name}} --services {{service-name}}
   ```

## Fase 5: Crea CodeDeploy l'applicazione e il gruppo di distribuzione (piattaforma di calcolo ECS)
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

Quando crei un' CodeDeploy applicazione e un gruppo di distribuzione per la piattaforma di calcolo Amazon ECS, l'applicazione viene utilizzata durante una distribuzione per fare riferimento al gruppo di distribuzione, ai gruppi target, ai listener e al comportamento di reindirizzamento del traffico corretti.

**Per creare CodeDeploy un'applicazione**

1. Apri la CodeDeploy console e scegli ** Crea applicazione**.

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

1. In **Compute platform (Piattaforma di calcolo)**, scegli **Amazon ECS**.

1. 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)**.

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

1. In Ruolo ** di servizio**, scegli un ruolo di servizio che conceda CodeDeploy l'accesso ad Amazon ECS. Per creare un nuovo ruolo del servizio, attenersi alla seguente procedura:

   1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

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

   1. Scegliere **Crea ruolo**.

   1. In ** Seleziona il tipo di entità attendibile**, 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.

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

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

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

1. In ** Load balancer**, scegli il nome del load balancer che invia il traffico al tuo servizio Amazon ECS.

1. Dalla porta del listener ** di produzione**, scegli la porta e il protocollo per il listener che invia 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.

1. 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.

1. Scegli ** Reroute traffic immediatamente ** per determinare quanto tempo, dopo una corretta implementazione, reindirizzare il traffico verso l'attività Amazon ECS aggiornata.

1. Scegliere **Create deployment group (Crea gruppo di distribuzione)**.

## Fase 6: creazione della pipeline
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Un' CodeCommit azione in cui gli artefatti di origine sono la definizione dell'attività e il file. AppSpec 
+ Una fase sorgente con un'azione sorgente Amazon ECR in cui l'artefatto sorgente è il file di immagine.
+ Una fase di distribuzione con un'azione di distribuzione di Amazon ECS in cui la distribuzione viene eseguita con un'applicazione e un gruppo di distribuzione. CodeDeploy 

**Per creare una pipeline a due fasi con la procedura guidata**

1. Accedi a e apri la console all'indirizzo Console di gestione AWS . CodePipeline [ http://console.aws.amazon.com/codesuite/codepipeline/home ](https://console.aws.amazon.com/codesuite/codepipeline/home)

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

1. Nella ** pagina ** Passaggio 1: Scegli l'opzione di creazione, in Opzioni di ** creazione**, scegli l'**opzione ** Crea pipeline personalizzata. Scegli **Avanti**.

1. Nel ** passaggio 2: scegli le impostazioni della pipeline**, in Nome ** della ** pipeline, inserisci. **MyImagePipeline**

1. CodePipeline fornisce pipeline di tipo V1 e V2, che si differenziano per caratteristiche e prezzo. Il tipo V2 è l’unico tipo che puoi scegliere nella console. Per ulteriori informazioni, consulta [tipi di pipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Per informazioni sui prezzi di CodePipeline, vedi Prezzi. [https://aws.amazon.com/codepipeline/pricing/](https://aws.amazon.com/codepipeline/pricing/)

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

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

1. 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](tutorials-simple-codecommit.md#codecommit-create-repository). In **Branch name (Nome ramo)**, scegliere il nome del ramo che contiene l'aggiornamento di codice più recente.

   Scegli **Avanti**.

1. Nel ** passaggio 4: Aggiungi fase di compilazione**, scegli ** Ignora fase di compilazione**, quindi accetta il messaggio di avviso scegliendo nuovamente ** Ignora**. Scegli **Avanti**.

1. Nel ** passaggio 5: Aggiungi fase di test**, scegli ** Ignora fase di test**, quindi accetta il messaggio di avviso ** scegliendo nuovamente Ignora. ** 

   Scegli **Avanti**.

1. Nel ** passaggio 6: Aggiungere la 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.

   1. Nella definizione ** delle attività di ** Amazon ECS, scegli. ** SourceArtifact ** Nel campo, immetti **taskdef.json**.

   1. 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à)**.

   1. Scegli **Avanti**.

1. Nel ** passaggio 7: Rivedi**, rivedi le informazioni, quindi scegli ** Crea pipeline**.

**Per aggiungere un'azione sorgente Amazon ECR alla tua pipeline**

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

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

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

1. Aggiungi un'azione parallela scegliendo ** \+ Aggiungi azione ** accanto all'azione sorgente. CodeCommit 

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

1. In **Action provider (Provider operazione)**, scegli **Amazon ECR**.  
![Aggiungi un'azione sorgente Amazon ECR alla tua pipeline.](https://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ECR-source-action.png)

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

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

1. 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.

1. 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 ()Blue/Green. **

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

1. In ** Task Definition**, scegli ** SourceArtifact**, quindi inserisci la verifica. **taskdef.json**

1. In **AWS CodeDeploy AppSpec File**, scegli ** SourceArtifact**, quindi inserisci **appspec.yaml** la verifica.

1. In Aggiorna ** dinamicamente l'immagine di definizione dell'attività**, in ** Input Artifact with Image URI ** ** MyImage**, scegli e inserisci il testo segnaposto utilizzato nel file:. `taskdef.json` ** IMAGE1\_NAME** Selezionare **Salva**.

1. Nel AWS CodePipeline riquadro, scegli ** Salva modifica alla pipeline**, quindi scegli 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"
   },
   ```

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

1. Scegli l'azione di distribuzione per 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 l'avvenuta 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à.

## Fase 7: modifica della pipeline e verifica della distribuzione
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

Apporta una modifica all'immagine e poi invia la modifica al tuo repository Amazon ECR. In questo modo viene attivata la pipeline per l'esecuzione. Verifica che l'origine dell'immagine venga distribuita.