Amazon non CodeCatalyst è più aperta a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [Come migrare da CodeCatalyst](migration.md).

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

# Distribuzione su Amazon ECS con un flusso di lavoro
<a name="deploy-action-ecs"></a>

Questa sezione descrive come distribuire un'applicazione containerizzata in un cluster Amazon Elastic Container Service utilizzando un flusso di lavoro. CodeCatalyst A tale scopo, devi aggiungere l'azione **Deploy to Amazon ECS** al tuo flusso di lavoro. Questa azione registra un file di [definizione delle attività fornito](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) dall'utente. Al momento della registrazione, la definizione dell'attività viene istanziata dal [servizio Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) in esecuzione nel cluster [Amazon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) ECS. «Istanziare una definizione di attività» equivale a distribuire un'applicazione in Amazon ECS.

Per utilizzare questa azione, è necessario disporre di un cluster Amazon ECS, di un servizio e di un file di definizione delle attività.

Per ulteriori informazioni su Amazon ECS, consulta la *Amazon Elastic Container Service Developer Guide*.

**Suggerimento**  
Per un tutorial che mostra come utilizzare l'azione **Deploy to Amazon ECS**, consulta. [Tutorial: distribuire un'applicazione su Amazon ECS](deploy-tut-ecs.md)

**Suggerimento**  
Per un esempio funzionante dell'azione **Deploy to Amazon ECS**, crea un progetto con l'**API Node.js con AWS Fargate o l'**API Java** con** blueprint. AWS Fargate Per ulteriori informazioni, consulta [Creare un progetto con un blueprint](projects-create.md#projects-create-console-template).

**Topics**
+ [Immagine di runtime utilizzata dall'azione «Deploy to Amazon ECS»](#deploy-action-ecs-runtime)
+ [Tutorial: distribuire un'applicazione su Amazon ECS](deploy-tut-ecs.md)
+ [Aggiungere l'azione «Deploy to Amazon ECS»](deploy-action-ecs-adding.md)
+ [Variabili «Distribuisci su Amazon ECS»](deploy-action-ecs-variables.md)
+ [Azione «Distribuisci su Amazon ECS» YAML](deploy-action-ref-ecs.md)

## Immagine di runtime utilizzata dall'azione «Deploy to Amazon ECS»
<a name="deploy-action-ecs-runtime"></a>

L'azione **Deploy to Amazon ECS** viene eseguita su un'immagine di [novembre 2022](build-images.md#build.previous-image). Per ulteriori informazioni, consulta [Immagini attive](build-images.md#build-curated-images).

# Tutorial: distribuire un'applicazione su Amazon ECS
<a name="deploy-tut-ecs"></a>

In questo tutorial, imparerai come distribuire un'applicazione serverless in Amazon Elastic Container Service (Amazon ECS) utilizzando un flusso di lavoro, Amazon ECS e alcuni altri servizi. AWS L'applicazione distribuita è un semplice sito Web Hello World costruito su un'immagine Docker del server Web Apache. Il tutorial illustra il lavoro di preparazione richiesto, ad esempio la configurazione di un cluster, e quindi descrive come creare un flusso di lavoro per creare e distribuire l'applicazione.

**Suggerimento**  
Invece di seguire questo tutorial, puoi utilizzare un blueprint che esegua una configurazione completa di Amazon ECS per te. Dovrai utilizzare l'**API Node.js con AWS Fargate o l'**API Java** con** blueprint. AWS Fargate Per ulteriori informazioni, consulta [Creare un progetto con un blueprint](projects-create.md#projects-create-console-template).

**Topics**
+ [Prerequisiti](#deploy-tut-ecs-prereqs)
+ [Passaggio 1: configurare un AWS utente e AWS CloudShell](#deploy-tut-ecs-user-cloudshell)
+ [Fase 2: distribuire un'applicazione segnaposto in Amazon ECS](#deploy-tut-ecs-placeholder)
+ [Fase 3: creare un repository di immagini Amazon ECR](#deploy-tut-ecs-ecr)
+ [Fase 4: Creare ruoli AWS](#deploy-tut-ecs-build-deploy-roles)
+ [Fase 5: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-ecs-import-roles)
+ [Fase 6: Creare un archivio di sorgenti](#deploy-tut-ecs-source-repo)
+ [Passaggio 7: Aggiungere i file sorgente](#deploy-tut-ecs-source-files)
+ [Fase 8: Creare ed eseguire un flusso di lavoro](#deploy-tut-ecs-workflow)
+ [Passaggio 9: apporta una modifica ai file sorgente](#deploy-tut-ecs-change)
+ [Eliminazione](#deploy-tut-ecs-cleanup)

## Prerequisiti
<a name="deploy-tut-ecs-prereqs"></a>

Prima di iniziare:
+ È necessario uno CodeCatalyst **spazio** con un AWS account connesso. Per ulteriori informazioni, consulta [Creazione di uno spazio](spaces-create.md).
+ Nel tuo spazio, hai bisogno di un progetto vuoto chiamato:

  ```
  codecatalyst-ecs-project
  ```

  Usa l'opzione **Inizia da zero** per creare questo progetto.

  Per ulteriori informazioni, consulta [Creare un progetto vuoto in Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Nel tuo progetto, hai bisogno di un CodeCatalyst **ambiente** chiamato:

  ```
  codecatalyst-ecs-environment
  ```

  Configura questo ambiente come segue:
  + Scegliete qualsiasi tipo, ad esempio **Non di produzione**.
  + Connect il tuo AWS account.
  + Per il **ruolo IAM predefinito**, scegli un ruolo qualsiasi. Specificherai un ruolo diverso in seguito.

  Per ulteriori informazioni, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md).

## Passaggio 1: configurare un AWS utente e AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

Il primo passaggio di questo tutorial consiste nel creare un utente in AWS IAM Identity Center e avviare un' AWS CloudShell istanza come tale utente. Per la durata di questo tutorial, CloudShell è il tuo computer di sviluppo ed è dove configuri AWS risorse e servizi. Elimina questo utente dopo aver completato il tutorial.

**Nota**  
Non usate il vostro utente root per questo tutorial. È necessario creare un utente separato, altrimenti potrebbero verificarsi problemi durante l'esecuzione di azioni nella AWS Command Line Interface (CLI) in un secondo momento.

Per ulteriori informazioni sugli utenti di IAM Identity Center e CloudShell, consulta la Guida per l'*AWS IAM Identity Center utente e la Guida per AWS CloudShell * *l'utente*. 

**Per creare un utente IAM Identity Center**

1. Accedi a Console di gestione AWS e apri la AWS IAM Identity Center console all'indirizzo [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).
**Nota**  
Assicurati di accedere utilizzando Account AWS il dispositivo connesso al tuo CodeCatalyst spazio. Puoi verificare quale account è connesso accedendo al tuo spazio e scegliendo la scheda **Account AWS**. Per ulteriori informazioni, consulta [Creazione di uno spazio](spaces-create.md).

1. Nel riquadro di navigazione, scegli **Users (Utenti)**, quindi scegli **Add user (Aggiungi utente)**.

1. In **Nome utente**, inserisci:

   ```
   CodeCatalystECSUser
   ```

1. In **Password**, scegli **Genera una password monouso da condividere con questo utente**.

1. In **Indirizzo e-mail** e **Conferma indirizzo e-mail**, inserisci un indirizzo e-mail che non esista già in IAM Identity Center.

1. In **Nome** e **cognome**, inserisci:

   ```
   CodeCatalystECSUser
   ```

1. In **Nome visualizzato**, mantieni il nome generato automaticamente:

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

1. Scegli **Next (Successivo)**.

1. Nella pagina **Aggiungi utente ai gruppi**, scegli **Avanti**.

1. Nella pagina **Rivedi e aggiungi utente**, esamina le informazioni e scegli **Aggiungi utente**.

   Viene visualizzata una finestra **di dialogo con password monouso**.

1. Scegli **Copia**, quindi incolla le informazioni di accesso, inclusi l'URL del portale di AWS accesso e la password monouso.

1. Scegli **Chiudi**.

**Per creare un set di autorizzazioni**

Assegnerai questo set di autorizzazioni a un secondo momento. `CodeCatalystECSUser`

1. Nel riquadro di navigazione, scegli **Set di autorizzazioni**, quindi scegli **Crea set di autorizzazioni**.

1. Scegli Set di **autorizzazioni predefinito**, quindi seleziona **AdministratorAccess**. Questa politica fornisce autorizzazioni complete a tutti. Servizi AWS

1. Scegli **Next (Successivo)**.

1. In **Nome del set di autorizzazioni**, inserisci:

   ```
   CodeCatalystECSPermissionSet
   ```

1. Scegli **Next (Successivo)**.

1. Nella pagina **Rivedi e crea**, esamina le informazioni e scegli **Crea**.

**Per assegnare il set di autorizzazioni a CodeCatalyst ECSUser**

1. Nel riquadro di navigazione, scegli **Account AWS**, quindi seleziona la casella di controllo accanto a Account AWS quella a cui hai attualmente effettuato l'accesso.

1. Scegli **Assegna utenti o gruppi**.

1. Scegli la scheda **Users** (Utenti);

1. Seleziona la casella di controllo accanto a. `CodeCatalystECSUser`

1. Scegli **Next (Successivo)**.

1. Seleziona la casella di controllo accanto a`CodeCatalystECSPermissionSet`.

1. Scegli **Next (Successivo)**.

1. Controlla le informazioni e scegli **Invia**.

   Ora le hai assegnate `CodeCatalystECSUser` e `CodeCatalystECSPermissionSet` Account AWS le hai assegnate insieme.

**Per disconnetterti e accedere nuovamente come CodeCatalyst ECSUser**

1. Prima di disconnetterti, assicurati di avere l'URL del portale di AWS accesso e il nome utente e la password monouso per`CodeCatalystECSUser`. In precedenza avresti dovuto copiare queste informazioni in un editor di testo.
**Nota**  
Se non disponi di queste informazioni, vai alla pagina dei `CodeCatalystECSUser` dettagli in IAM Identity Center, scegli **Reimposta password**, **Genera una password monouso [...]** e **Reimposta nuovamente la password** per visualizzare le informazioni sullo schermo.

1. Uscire da AWS.

1. Incolla l'URL del portale di AWS accesso nella barra degli indirizzi del browser.

1. Accedi con il nome utente e la password monouso per`CodeCatalystECSUser`.

1. In **Nuova password**, inserisci una password e scegli **Imposta nuova password**.

   Sullo schermo viene visualizzata una **Account AWS**casella.

1. Scegli **Account AWS**, quindi scegli il nome Account AWS a cui hai assegnato l'`CodeCatalystECSUser`utente e il set di autorizzazioni.

1. Accanto a`CodeCatalystECSPermissionSet`, scegli **Console di gestione**.

    Console di gestione AWS Appare. Ora hai effettuato l'accesso `CodeCatalystECSUser` con le autorizzazioni appropriate.

**Per avviare un'istanza AWS CloudShell**

1. Quindi`CodeCatalystECSUser`, nella barra di navigazione in alto, scegli l' AWS icona (![\[AWS icon\]](http://docs.aws.amazon.com/it_it/codecatalyst/latest/userguide/images/deploy/aws-logo.png)).

    Console di gestione AWS Viene visualizzata la pagina principale di.

1. Nella barra di navigazione in alto, scegli l' AWS CloudShell icona (![\[CloudShell icon\]](http://docs.aws.amazon.com/it_it/codecatalyst/latest/userguide/images/deploy/CloudShell.png)).

   CloudShell si apre. Attendi che l' CloudShell ambiente venga creato.
**Nota**  
Se non vedi l' CloudShell icona, assicurati di trovarti in una [regione supportata da CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). Questo tutorial presuppone che ti trovi nella regione degli Stati Uniti occidentali (Oregon).

**Per verificare che sia installato AWS CLI**

1. Nel CloudShell terminale, inserisci:

   ```
   aws --version
   ```

1. Verifica che venga visualizzata una versione.

    AWS CLI È già configurato per l'utente corrente`CodeCatalystECSUser`, quindi non è necessario configurare AWS CLI chiavi e credenziali, come avviene normalmente.

## Fase 2: distribuire un'applicazione segnaposto in Amazon ECS
<a name="deploy-tut-ecs-placeholder"></a>

In questa sezione, distribuisci manualmente un'applicazione segnaposto in Amazon ECS. Questa applicazione segnaposto verrà sostituita dall'applicazione Hello World distribuita dal tuo flusso di lavoro. L'applicazione segnaposto è Apache Web Server.

Per ulteriori informazioni su Amazon ECS, consulta la *Amazon Elastic Container Service Developer Guide*.

Completa la seguente serie di procedure per distribuire l'applicazione placeholder.<a name="deploy-tut-ecs-create-task-execution-role"></a>

**Per creare il ruolo di esecuzione dell'attività**

Questo ruolo concede ad Amazon ECS l' AWS Fargate autorizzazione a effettuare chiamate API per tuo conto. 

1. Crea una politica di fiducia:

   1. In AWS CloudShell, inserisci il seguente comando:

      ```
      cat > codecatalyst-ecs-trust-policy.json
      ```

      Nel terminale viene visualizzato un prompt lampeggiante. CloudShell 

   1. Immettete il seguente codice al prompt:

------
#### [ JSON ]

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. Posizionate il cursore dopo l'ultima parentesi riccia (). `}`

   1. **Enter**Premete e poi **Ctrl\$1d** per salvare il file e uscire da cat.

1. Crea un ruolo di esecuzione dell'attività:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Allega la `AmazonECSTaskExecutionRolePolicy` policy AWS gestita al ruolo:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
   ```

1. Visualizza i dettagli del ruolo:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role
   ```

1. Nota il `"Arn":` valore del ruolo, ad esempio`arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role`. Avrai bisogno di questo Amazon Resource Name (ARN) in un secondo momento.

**Come creare un cluster Amazon ECS**

Questo cluster conterrà l'applicazione placeholder Apache e, successivamente, l'applicazione Hello World. 

1. Ad esempio `CodeCatalystECSUser` AWS CloudShell, crea un cluster vuoto:

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (Facoltativo) Verifica che il cluster sia stato creato correttamente:

   ```
   aws ecs list-clusters
   ```

   L'ARN del `codecatalyst-ecs-cluster` cluster dovrebbe apparire nell'elenco, a indicare che la creazione è avvenuta con successo.

**Per creare un file di definizione delle attività**

Il file di definizione dell'attività indica di eseguire l'immagine Docker del [server Web Apache 2.4](https://hub.docker.com/_/httpd) (`httpd:2.4`) da cui viene estratta. DockerHub

1. Ad esempio `CodeCatalystECSUser` AWS CloudShell, crea un file di definizione dell'attività:

   ```
   cat > taskdef.json
   ```

1. Incolla il codice seguente al prompt:

   ```
   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }
   ```

   Nel codice precedente, sostituisci *arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role*

   con l'ARN del ruolo di esecuzione dell'attività in cui hai annotato. [Per creare il ruolo di esecuzione dell'attività](#deploy-tut-ecs-create-task-execution-role)

1. Posiziona il cursore dopo l'ultima parentesi riccia (). `}`

1. **Enter**Premete e poi **Ctrl\$1d** per salvare il file e uscire da cat.

**Per registrare il file di definizione delle attività con Amazon ECS**

1. Ad esempio `CodeCatalystECSUser` AWS CloudShell, registra la definizione dell'attività:

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

1. (Facoltativo) Verifica che la definizione dell'attività sia stata registrata:

   ```
   aws ecs list-task-definitions
   ```

   La definizione dell'`codecatalyst-ecs-task-def`attività dovrebbe apparire nell'elenco.

**Per creare il servizio Amazon ECS**

Il servizio Amazon ECS esegue le attività (e i contenitori Docker associati) dell'applicazione placeholder Apache e, successivamente, dell'applicazione Hello World.

1. Quindi`CodeCatalystECSUser`, passa alla console Amazon Elastic Container Service se non l'hai già fatto.

1. Scegli il cluster che hai creato in precedenza,`codecatalyst-ecs-cluster`.

1. Nella scheda **Servizi**, scegli **Crea**.

1. Nella pagina **Crea**, procedi come segue:

   1. Mantieni tutte le impostazioni predefinite ad eccezione di quelle elencate di seguito.

   1. In **Launch Type (Tipo di lancio)**, scegli **FARGATE**.

   1. In **Definizione dell'attività**, nell'elenco a discesa **Famiglia**, scegli:

      `codecatalyst-ecs-task-def`

   1. Per il **nome del servizio, inserisci**:

      ```
      codecatalyst-ecs-service
      ```

   1. Per **Attività desiderate**, inserisci:

      ```
      3
      ```

      In questo tutorial, ogni attività avvia un singolo contenitore Docker.

   1. Espandi la sezione **Rete**.

   1. Per **VPC, scegli un VPC** qualsiasi.

   1. Per le **sottoreti, scegli una sottorete**.
**Nota**  
Specificate solo una sottorete. Questo è tutto ciò che serve per questo tutorial.
**Nota**  
Se non disponi di un VPC e di una sottorete, creali. Consulta [Crea un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) e [Crea una sottorete nel tuo VPC nella *Amazon* VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet) User Guide.

   1. Per **Gruppo di sicurezza**, scegli **Crea un nuovo gruppo di sicurezza**, quindi procedi come segue:

      1. Per il **nome del gruppo di sicurezza**, inserisci:

         ```
         codecatalyst-ecs-security-group
         ```

      1. Per la **descrizione del gruppo di sicurezza**, inserisci:

         ```
         CodeCatalyst ECS security group
         ```

      1. Scegli **Aggiungi regola**. Per **Tipo**, scegli **HTTP** e per **Source**, scegli **Anywhere**.

   1. In basso, scegli **Crea**.

   1. Attendi che il servizio venga creato. Ciò può richiedere alcuni minuti.

1. Scegli la scheda **Attività**, quindi scegli il pulsante Aggiorna. Verifica che la colonna **Ultimo stato** di tutte e tre le attività sia impostata su In **esecuzione**.

**(Facoltativo) Per verificare che l'applicazione segnaposto Apache sia in esecuzione**

1. Nella scheda **Attività**, scegli una delle tre attività.

1. Nel campo **IP pubblico**, scegli **Apri indirizzo**.

   Viene visualizzata una `It Works!` pagina. Ciò indica che il servizio Amazon ECS ha avviato con successo un'attività che ha avviato un contenitore Docker con l'immagine Apache.

   A questo punto del tutorial, hai distribuito manualmente un cluster Amazon ECS, un servizio e una definizione di attività, oltre a un'applicazione segnaposto Apache. Con tutti questi elementi a disposizione, ora sei pronto per creare un flusso di lavoro che sostituirà l'applicazione segnaposto Apache con l'applicazione Hello World del tutorial.

## Fase 3: creare un repository di immagini Amazon ECR
<a name="deploy-tut-ecs-ecr"></a>

In questa sezione, crei un repository di immagini privato in Amazon Elastic Container Registry (Amazon ECR). Questo repository memorizza l'immagine Docker del tutorial che sostituirà l'immagine segnaposto Apache che hai distribuito in precedenza. 

Per ulteriori informazioni su Amazon ECR, consulta la *Amazon Elastic Container Registry User Guide*.

**Per creare un archivio di immagini in Amazon ECR**

1. Ad esempio `CodeCatalystECSUser` AWS CloudShell, crea un repository vuoto in Amazon ECR:

   ```
   aws ecr create-repository --repository-name codecatalyst-ecs-image-repo
   ```

1. Visualizza i dettagli del repository Amazon ECR:

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-ecs-image-repo
   ```

1. Nota il `“repositoryUri”:` valore, ad esempio,. `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo`

   Ne avrai bisogno in seguito quando aggiungerai il repository al tuo flusso di lavoro. 

## Fase 4: Creare ruoli AWS
<a name="deploy-tut-ecs-build-deploy-roles"></a>

In questa sezione, creerai i ruoli AWS IAM di cui il tuo CodeCatalyst flusso di lavoro avrà bisogno per funzionare. Questi ruoli sono:
+ **Ruolo di creazione**: concede all'azione di CodeCatalyst compilazione (nel flusso di lavoro) l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon ECR e Amazon EC2.
+ **Ruolo di distribuzione**: concede all'azione CodeCatalyst **Deploy to ECS** (nel flusso di lavoro) l'autorizzazione ad accedere al tuo account AWS , ad Amazon ECS e ad alcuni altri servizi. AWS 

[https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)

**Nota**  
Per risparmiare tempo, puoi creare un singolo ruolo, chiamato `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo, anziché i due ruoli elencati in precedenza. Per ulteriori informazioni, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo ha autorizzazioni molto ampie che possono rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. Questo tutorial presuppone che stiate creando i due ruoli elencati in precedenza.

Per creare i ruoli di compilazione e distribuzione, puoi utilizzare il Console di gestione AWS o il. AWS CLI

------
#### [ Console di gestione AWS ]

Per creare i ruoli di compilazione e distribuzione, completa la seguente serie di procedure.

**Per creare un ruolo di costruzione**

1. Crea una politica per il ruolo, come segue:

   1. Accedi a AWS.

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

   1. Nel riquadro di navigazione, scegli **Policy**.

   1. Scegli **Create Policy** (Crea policy).

   1. Scegliere la scheda **JSON**.

   1. Eliminare il codice esistente.

   1. Incolla il codice seguente:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ecr:*",
                      "ec2:*"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------
**Nota**  
La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.  

      ```
      "Resource": "*"
      ```

   1. Scegliere **Next: Tags (Successivo: Tag)**.

   1. Scegliere **Next:Review (Successivo: Rivedi)**.

   1. In **Nome**, inserisci:

      ```
      codecatalyst-ecs-build-policy
      ```

   1. Scegli **Crea policy**.

      Ora hai creato una politica di autorizzazioni.

1. Crea il ruolo di costruzione, come segue:

   1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**.

   1. Scegli una **politica di fiducia personalizzata**.

   1. Elimina la politica di fiducia personalizzata esistente.

   1. Aggiungi la seguente politica di fiducia personalizzata:

   1. Scegli **Next (Successivo)**.

   1. Nelle **politiche di autorizzazione**`codecatalyst-ecs-build-policy`, cerca e seleziona la relativa casella di controllo.

   1. Scegli **Next (Successivo)**.

   1. Per il **nome del ruolo**, inserisci:

      ```
      codecatalyst-ecs-build-role
      ```

   1. Per la **descrizione del ruolo**, inserisci:

      ```
      CodeCatalyst ECS build role
      ```

   1. Scegli **Crea ruolo**.

   Ora hai creato un ruolo di sviluppo con una politica di autorizzazioni e una politica di fiducia.

1. Ottieni l'ARN del ruolo di costruzione, come segue:

   1. Nel riquadro di navigazione, seleziona **Ruoli**.

   1. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (`codecatalyst-ecs-build-role`).

   1. Scegli il ruolo dall'elenco.

      Viene visualizzata la pagina di **riepilogo** del ruolo.

   1. In alto, copia il valore **ARN.** perché sarà necessaria in seguito.

**Per creare un ruolo di distribuzione**

1. Crea una politica per il ruolo, come segue:

   1. Accedi a AWS.

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

   1. Nel riquadro di navigazione, scegli **Policy**.

   1. Scegliere **Create Policy (Crea policy)**.

   1. Scegliere la scheda **JSON**.

   1. Eliminare il codice esistente.

   1. Incolla il codice seguente:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**Nota**  
La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizzate il carattere jolly nell'informativa sulla politica delle risorse. È quindi possibile definire l'ambito della politica inserendo il nome della risorsa una volta che è disponibile.  

      ```
      "Resource": "*"
      ```

   1. Scegliere **Next: Tags (Successivo: Tag)**.

   1. Scegliere **Next:Review (Successivo: Rivedi)**.

   1. In **Nome**, inserisci:

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. Scegli **Crea policy**.

      Ora hai creato una politica di autorizzazioni.

1. Crea il ruolo di distribuzione, come segue:

   1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**.

   1. Scegli una **politica di fiducia personalizzata**.

   1. Elimina la politica di fiducia personalizzata esistente.

   1. Aggiungi la seguente politica di fiducia personalizzata:

   1. Scegli **Next (Successivo)**.

   1. Nelle **politiche di autorizzazione**`codecatalyst-ecs-deploy-policy`, cerca e seleziona la relativa casella di controllo.

   1. Scegli **Next (Successivo)**.

   1. Per il **nome del ruolo**, inserisci:

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. Per la **descrizione del ruolo**, inserisci:

      ```
      CodeCatalyst ECS deploy role
      ```

   1. Scegli **Crea ruolo**.

   Ora hai creato un ruolo di distribuzione con una politica di fiducia.

1. Ottenere l'ARN del ruolo di distribuzione, come segue:

   1. Nel riquadro di navigazione, seleziona **Ruoli**.

   1. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato ()`codecatalyst-ecs-deploy-role`.

   1. Scegli il ruolo dall'elenco.

      Viene visualizzata la pagina di **riepilogo** del ruolo.

   1. In alto, copia il valore **ARN.** perché sarà necessaria in seguito.

------
#### [ AWS CLI ]

Per creare i ruoli di compilazione e distribuzione, completa la seguente serie di procedure.

**Per creare una politica di fiducia per entrambi i ruoli**

Ad esempio `CodeCatalystECSUser` AWS CloudShell, crea un file di criteri di fiducia:

1. Crea il file:

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. Al prompt del terminale, incolla il seguente codice:

1. Posizionate il cursore dopo l'ultima parentesi riccia (). `}`

1. **Enter**Premete e poi **Ctrl\$1d** per salvare il file e uscire da cat.

**Per creare la politica di costruzione e costruire il ruolo**

1. Crea la politica di compilazione:

   1. Quindi `CodeCatalystECSUser` AWS CloudShell, crea un file di policy di compilazione:

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

   1. Al prompt, inserisci il seguente codice:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ecr:*",
                      "ec2:*"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------

   1. Posizionate il cursore dopo l'ultima parentesi riccia (). `}`

   1. **Enter**Premete e poi **Ctrl\$1d** per salvare il file e uscire da cat.

1. Aggiungi la politica di compilazione a AWS:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-build-policy \
       --policy-document file://codecatalyst-ecs-build-policy.json
   ```

1. Nell'output del comando, annota il `"arn":` valore, ad esempio`arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy`. Questo ARN ti servirà più tardi.

1. Crea il ruolo di costruzione e allega ad esso la policy di fiducia:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-build-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Allega la policy di compilazione al ruolo di costruzione:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy
   ```

   Dove *arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy* viene sostituito dall'ARN della politica di compilazione che hai notato in precedenza.

1. Visualizza i dettagli del ruolo di compilazione:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-build-role
   ```

1. Nota il `"Arn":` valore del ruolo, ad esempio`arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role`. Questo ARN ti servirà più tardi.

**Per creare la politica di distribuzione e il ruolo di distribuzione**

1. Crea una politica di distribuzione:

   1. In AWS CloudShell, crea un file di policy di distribuzione:

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

   1. Al prompt, inserisci il codice seguente:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**Nota**  
La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizzate il carattere jolly nell'informativa sulla politica delle risorse, quindi definite la politica inserendo il nome della risorsa dopo che è stata resa disponibile.  

      ```
      "Resource": "*"
      ```

   1. Posizionate il cursore dopo l'ultima parentesi riccia (). `}`

   1. **Enter**Premete e poi **Ctrl\$1d** per salvare il file e uscire da cat.

1. Aggiungi la policy di distribuzione a AWS:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-deploy-policy \
       --policy-document file://codecatalyst-ecs-deploy-policy.json
   ```

1. Nell'output del comando, annota il `"arn":` valore della policy di distribuzione, ad esempio. `arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy` Questo ARN ti servirà più tardi.

1. Crea il ruolo di distribuzione e allega ad esso la policy di fiducia:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-deploy-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Allega la policy di distribuzione al ruolo di distribuzione, dove *arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy* viene sostituita con l'ARN della policy di distribuzione indicata in precedenza.

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy
   ```

1. Visualizza i dettagli del ruolo di distribuzione:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-deploy-role
   ```

1. Nota il `"Arn":` valore del ruolo, `arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role` ad esempio. Questo ARN ti servirà più tardi.

------

## Fase 5: Aggiungere AWS ruoli a CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

In questo passaggio, aggiungi build role (`codecatalyst-ecs-build-role`) e deploy role (`codecatalyst-ecs-deploy-role`) alla connessione dell' CodeCatalyst account nel tuo spazio.

**Per aggiungere ruoli, build e deploy alla connessione del tuo account**

1. Nel CodeCatalyst, accedi al tuo spazio.

1. Seleziona **AWS accounts (Account)**. Viene visualizzato un elenco di connessioni all'account.

1. Scegli la connessione all'account che rappresenta l' AWS account in cui hai creato i ruoli di compilazione e distribuzione.

1. Scegli **Gestisci ruoli dalla console AWS di gestione**.

   Viene visualizzata la pagina **Aggiungi ruolo IAM CodeCatalyst allo spazio Amazon**. Potrebbe essere necessario effettuare il login per accedere alla pagina.

1. Seleziona **Aggiungi un ruolo esistente che hai creato in IAM**.

   Viene visualizzato un elenco a discesa. L'elenco mostra tutti i ruoli IAM con una policy di fiducia che include i principali `codecatalyst-runner.amazonaws.com` di `codecatalyst.amazonaws.com` servizio.

1. **Nell'elenco a discesa`codecatalyst-ecs-build-role`, scegli e scegli Aggiungi ruolo.**
**Nota**  
Se vedi`The security token included in the request is invalid`, potrebbe essere perché non disponi delle autorizzazioni giuste. Per risolvere questo problema, esci e accedi nuovamente con l' AWS account che hai usato quando hai creato il tuo CodeCatalyst spazio. AWS 

1. Scegli **Aggiungi ruolo IAM**, scegli **Aggiungi un ruolo esistente che hai creato in IAM** e, nell'elenco a discesa, scegli. `codecatalyst-ecs-deploy-role` Scegliere **Add role (Aggiungi ruolo)**.

   Ora hai aggiunto i ruoli di creazione e distribuzione al tuo spazio.

1. Copia il valore del **nome CodeCatalyst visualizzato di Amazon**. Questo valore ti servirà in seguito, durante la creazione del tuo flusso di lavoro.

## Fase 6: Creare un archivio di sorgenti
<a name="deploy-tut-ecs-source-repo"></a>

In questo passaggio, creerai un repository di sorgenti in. CodeCatalyst Questo repository memorizza i file sorgente del tutorial, come il file di definizione delle attività.

Per ulteriori informazioni sui repository dei sorgenti, consulta. [Creazione di un repository di sorgenti](source-repositories-create.md)

**Per creare un archivio di sorgenti**

1. Apri la CodeCatalyst console all'indirizzo [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Vai al tuo progetto,`codecatalyst-ecs-project`.

1. Nel riquadro di navigazione, scegli **Codice**, quindi scegli **Archivi di origine.** 

1. Scegli **Aggiungi repository**, quindi scegli **Crea** repository.

1. Nel **nome del repository, inserisci:**

   ```
   codecatalyst-ecs-source-repository
   ```

1. Scegli **Create** (Crea).

## Passaggio 7: Aggiungere i file sorgente
<a name="deploy-tut-ecs-source-files"></a>

In questa sezione, aggiungi i file sorgente di Hello World al tuo CodeCatalyst repository,. `codecatalyst-ecs-source-repository` Sono costituiti da:
+ Un `index.html` file: visualizza un messaggio Hello World nel browser. 
+ Un Dockerfile: descrive l'immagine di base da utilizzare per l'immagine Docker e i comandi Docker da applicarvi. 
+ Un `taskdef.json` file: definisce l'immagine Docker da utilizzare per l'avvio di attività nel cluster.

La struttura delle cartelle è la seguente:

```
.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
```

**Nota**  
Le seguenti istruzioni mostrano come aggiungere i file usando la CodeCatalyst console, ma puoi usare Git se preferisci. Per informazioni dettagliate, vedi [Clonazione di un repository di origine](source-repositories-clone.md). 

**Topics**
+ [index.html](#deploy-tut-ecs-source-files-index)
+ [Dockerfile](#deploy-tut-ecs-source-files-dockerfile)
+ [taskdef.json](#deploy-tut-ecs-source-files-taskdef)

### index.html
<a name="deploy-tut-ecs-source-files-index"></a>

Il `index.html` file visualizza un messaggio Hello World nel browser. 

**Per aggiungere il file index.html**

1. Nella CodeCatalyst console, vai al tuo repository di origine,`codecatalyst-ecs-source-repository`.

1. In **File**, scegli **Crea file**.

1. Per **Nome file**, inserisci:

   ```
   public-html/index.html
   ```
**Importante**  
Assicurati di includere il `public-html/` prefisso per creare una cartella con lo stesso nome. `index.html`Si prevede che si trovi in questa cartella.

1. Nella casella di testo, inserisci il seguente codice:

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello World</h1>
     </body>
   </html>
   ```

1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.

   `index.html`Viene aggiunto al tuo repository in una `public-html` cartella. 

### Dockerfile
<a name="deploy-tut-ecs-source-files-dockerfile"></a>

Il Dockerfile descrive l'immagine Docker di base da utilizzare e i comandi Docker da applicarvi. [Per ulteriori informazioni sul Dockerfile, consulta il Dockerfile Reference.](https://docs.docker.com/engine/reference/builder/)

Il Dockerfile specificato qui indica di utilizzare l'immagine di base di Apache 2.4 (). `httpd` Include anche istruzioni per copiare un file sorgente chiamato `index.html` in una cartella sul server Apache che serve le pagine Web. L'`EXPOSE`istruzione nel Dockerfile indica a Docker che il contenitore è in ascolto sulla porta 80.

**Per aggiungere il Dockerfile**

1. **Nel tuo repository di origine, scegli Crea file.**

1. Per **Nome file**, inserisci:

   ```
   Dockerfile
   ```

   Non includere un'estensione di file.
**Importante**  
Il Dockerfile deve risiedere nella cartella principale del repository. Il `Docker build` comando del flusso di lavoro si aspetta che sia presente.

1. Nella casella di testo, inserisci il seguente codice:

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.

   Il Dockerfile viene aggiunto al tuo repository. 

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

Il `taskdef.json` file che aggiungi in questo passaggio è lo stesso di quello già specificato con la seguente differenza: [Fase 2: distribuire un'applicazione segnaposto in Amazon ECS](#deploy-tut-ecs-placeholder)

Invece di specificare un nome di immagine Docker codificato nel `image:` campo (`httpd:2.4`), la definizione dell'attività qui utilizza un paio di variabili per indicare l'immagine: and. `$REPOSITORY_URI` `$IMAGE_TAG` Queste variabili verranno sostituite con valori reali generati dall'azione di creazione del flusso di lavoro quando si esegue il flusso di lavoro in una fase successiva.

Per informazioni dettagliate sui parametri di definizione delle attività, consulta [Parametri di definizione delle attività](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) nella *Amazon Elastic Container Service Developer Guide*.

**Per aggiungere il file taskdef.json**

1. **Nel tuo repository di origine, scegli Crea file.**

1. Per **Nome file**, inserisci:

   ```
   taskdef.json
   ```

1. Nella casella di testo, inserisci il seguente codice:

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }
   ```

   Nel codice precedente, sostituisci

   *arn:aws:iam::account\$1ID:role/codecatalyst-ecs-task-execution-role*

   con l'ARN del ruolo di esecuzione dell'attività in cui hai annotato. [Per creare il ruolo di esecuzione dell'attività](#deploy-tut-ecs-create-task-execution-role)

1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.

   Il `taskdef.json` file viene aggiunto al tuo repository. 

## Fase 8: Creare ed eseguire un flusso di lavoro
<a name="deploy-tut-ecs-workflow"></a>

In questa fase, crei un flusso di lavoro che prende i tuoi file sorgente, li crea in un'immagine Docker e quindi distribuisce l'immagine nel tuo cluster Amazon ECS. Questa implementazione sostituisce l'applicazione placeholder Apache esistente.

Il flusso di lavoro è costituito dai seguenti elementi costitutivi eseguiti in sequenza:
+ Un trigger: questo trigger avvia l'esecuzione automatica del flusso di lavoro quando invii una modifica al tuo repository di origine. Per ulteriori informazioni sui trigger, consulta [L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger](workflows-add-trigger.md).
+ Un'azione di compilazione (`BuildBackend`): all'attivazione, l'azione crea l'immagine Docker utilizzando il Dockerfile e la invia ad Amazon ECR. L'azione di compilazione aggiorna inoltre il `taskdef.json` con il valore di `image` campo corretto, quindi crea un elemento di output di questo file. Questo artefatto viene utilizzato come input per l'azione di distribuzione, che viene successiva.

  Per ulteriori informazioni sull'azione di compilazione, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md)
+ Un'azione di distribuzione (`DeployToECS`): al termine dell'azione di creazione, l'azione di distribuzione cerca l'artefatto di output generato dall'azione di compilazione (`TaskDefArtifact`), ne trova il `taskdef.json` contenuto e lo registra con il servizio Amazon ECS. Il servizio segue quindi le istruzioni contenute nel `taskdef.json` file per eseguire tre attività Amazon ECS e i contenitori Hello World Docker associati all'interno del cluster Amazon ECS. 

**Come creare un flusso di lavoro**

1. ****Nella CodeCatalyst console, nel pannello di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.****

1. **Scegli Crea flusso di lavoro.**

1. Per **Source repository**, scegli`codecatalyst-ecs-source-repository`.

1. Per **Branch**, scegli`main`.

1. Scegli **Create** (Crea).

1. Eliminate il codice di esempio YAML.

1. Aggiungi il seguente codice YAML:
**Nota**  
Nel codice YAML che segue, puoi omettere le sezioni se lo `Connections:` desideri. Se ometti queste sezioni, devi assicurarti che il ruolo specificato nel campo **Default IAM role** nel tuo ambiente includa le autorizzazioni e le policy di fiducia di entrambi i ruoli descritte in. [Fase 5: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-ecs-import-roles) Per ulteriori informazioni sulla configurazione di un ambiente con un ruolo IAM predefinito, consulta. [Creazione di un ambiente](deploy-environments-creating-environment.md)

   ```
   Name: codecatalyst-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json
   ```

   Nel codice precedente, sostituisci:
   + Entrambe le istanze hanno *codecatalyst-ecs-environment* il nome dell'ambiente in cui avete creato. [Prerequisiti](#deploy-tut-ecs-prereqs)
   + Entrambe le istanze *codecatalyst-account-connection* con il nome visualizzato della connessione all'account. Il nome visualizzato potrebbe essere un numero. Per ulteriori informazioni, consulta [Fase 5: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-ecs-import-roles).
   + *codecatalyst-ecs-build-role*con il nome del ruolo di costruzione in cui hai creato[Fase 4: Creare ruoli AWS](#deploy-tut-ecs-build-deploy-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo*(nella `Value:` proprietà) con l'URI del repository Amazon ECR in cui hai creato. [Fase 3: creare un repository di immagini Amazon ECR](#deploy-tut-ecs-ecr)
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(nel `Run: aws ecr` comando) con l'URI del repository Amazon ECR senza il suffisso dell'immagine (). `/codecatalyst-ecs-image-repo`
   + *codecatalyst-ecs-deploy-role*con il nome del ruolo di distribuzione in cui hai creato. [Fase 4: Creare ruoli AWS](#deploy-tut-ecs-build-deploy-roles)
   + Entrambe le istanze *us-west-2* con il tuo codice AWS regionale. Per un elenco dei codici regionali, consulta [Endpoint regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) in. *Riferimenti generali di AWS*
**Nota**  
Se hai deciso di non creare ruoli, build and deploy, sostituisci «*codecatalyst-ecs-build-role*e» *codecatalyst-ecs-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 4: Creare ruoli AWS](#deploy-tut-ecs-build-deploy-roles).
**Suggerimento**  
Invece di utilizzare i `sed` comandi `find` e mostrati nel codice del flusso di lavoro precedente per aggiornare il repository e il nome dell'immagine, puoi utilizzare l'azione di **definizione delle attività di Render Amazon ECS** per questo scopo. Per ulteriori informazioni, consulta [Modifica della definizione di un'attività Amazon ECS](render-ecs-action.md).

1. (Facoltativo) Scegli **Convalida** per assicurarti che il codice YAML sia valido prima di eseguire il commit.

1. Scegli **Applica**.

1. Nella finestra di dialogo **Conferma flusso di lavoro**, inserisci quanto segue:

   1. Per il **messaggio** di conferma, rimuovi il testo e inserisci:

      ```
      Add first workflow
      ```

   1. Per **Repository**, scegli`codecatalyst-ecs-source-repository`.

   1. Per il **nome del ramo**, scegli principale.

   1. Scegli **Applica**.

   Ora hai creato un flusso di lavoro. L'esecuzione di un flusso di lavoro viene avviata automaticamente a causa del trigger definito nella parte superiore del flusso di lavoro. In particolare, quando hai eseguito il commit (e inviato) del `workflow.yaml` file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro.

**Per visualizzare l'avanzamento del flusso di lavoro, esegui**

1. **Nel pannello di navigazione della CodeCatalyst console, scegli **CI/CD**, quindi scegli Flussi di lavoro.**

1. Scegli il flusso di lavoro che hai appena creato,. `codecatalyst-ecs-workflow`

1. Scegli **BuildBackend**di vedere lo stato di avanzamento della costruzione.

1. Scegli **DeployToECS** per vedere lo stato di avanzamento della distribuzione.

   Per ulteriori informazioni sulla visualizzazione dei dettagli dell'esecuzione, consulta[Visualizzazione dello stato e dei dettagli dell'esecuzione del flusso di lavoro](workflows-view-run.md).

**Per verificare la distribuzione**

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

1. Scegli il tuo cluster,`codecatalyst-ecs-cluster`.

1. Selezionare la scheda **Tasks (Attività)**. 

1. Scegli una delle tre attività.

1. Nel campo **IP pubblico**, scegli **Apri indirizzo**.

   Nel browser viene visualizzata una pagina «Hello World» che indica che il servizio Amazon ECS ha distribuito correttamente l'applicazione.

## Passaggio 9: apporta una modifica ai file sorgente
<a name="deploy-tut-ecs-change"></a>

In questa sezione, apporti una modifica al `index.html` file nel tuo repository di origine. Questa modifica fa sì che il flusso di lavoro crei una nuova immagine Docker, la tagghi con un ID di commit, la invii ad Amazon ECR e la distribuisca in Amazon ECS. 

**Per modificare il file index.html**

1. Nella CodeCatalyst console, nel riquadro di navigazione, scegli **Codice**, quindi scegli **Archivi di origine** e quindi scegli il tuo repository,. `codecatalyst-ecs-source-repository`

1. Scegli `public-html` e quindi `index.html`.

   Vengono visualizzati i contenuti di. `index.html`

1. Scegli **Modifica**. 

1. Nella riga 14, modifica il `Hello World` testo in`Tutorial complete!`.

1. Scegli **Commetti**, quindi scegli di nuovo **Commetti**.

   Il commit provoca l'avvio di un nuovo flusso di lavoro. 

1. (Facoltativo) Vai alla pagina principale del tuo repository di origine, scegli **Visualizza i commit**, quindi annota l'ID di commit per la `index.html` modifica.

1. Guarda lo stato di avanzamento della distribuzione:

   1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**

   1. Scegli `codecatalyst-ecs-workflow` di visualizzare l'ultima esecuzione.

   1. Scegli **BuildBackend**ed **DeployToECS** per vedere lo stato di avanzamento del flusso di lavoro.

1. Verifica che l'applicazione sia stata aggiornata, come segue:

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

   1. Scegli il tuo cluster,`codecatalyst-ecs-cluster`.

   1. Selezionare la scheda **Tasks (Attività)**. 

   1. Scegli una delle tre attività.

   1. Nel campo **IP pubblico**, scegli **Apri indirizzo**.

      Viene visualizzata una `Tutorial complete!` pagina.

1. (Facoltativo) In AWS, passa alla console Amazon ECR e verifica che la nuova immagine Docker sia stata etichettata con l'ID di commit del passaggio 6.

## Eliminazione
<a name="deploy-tut-ecs-cleanup"></a>

Pulisci i file e i servizi utilizzati in questo tutorial per evitare che ti vengano addebitati dei costi.

Nel Console di gestione AWS, pulisci in questo ordine:

1. In Amazon ECS, esegui le seguenti operazioni:

   1. Eliminare`codecatalyst-ecs-service`.

   1. Eliminare`codecatalyst-ecs-cluster`.

   1. Annullare la registrazione`codecatalyst-ecs-task-definition`.

1. In Amazon ECR, elimina`codecatalyst-ecs-image-repo`.

1. In Amazon EC2, elimina. `codecatalyst-ecs-security-group`

1. In IAM Identity Center, elimina:

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

Nella CodeCatalyst console, esegui la pulizia come segue:

1. Eliminare`codecatalyst-ecs-workflow`.

1. Eliminare`codecatalyst-ecs-environment`.

1. Eliminare`codecatalyst-ecs-source-repository`.

1. Eliminare`codecatalyst-ecs-project`.

In questo tutorial, hai imparato a distribuire un'applicazione su un servizio Amazon ECS utilizzando un CodeCatalyst flusso di lavoro e un'azione **Deploy to Amazon** ECS.

# Aggiungere l'azione «Deploy to Amazon ECS»
<a name="deploy-action-ecs-adding"></a>

Utilizza le seguenti istruzioni per aggiungere l'azione **Deploy to Amazon ECS** al tuo flusso di lavoro. 

------
#### [ Visual ]

**Per aggiungere l'azione «Deploy to Amazon ECS» utilizzando l'editor visuale**

1. [Apri la CodeCatalyst console all'indirizzo https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Scegliere il progetto.

1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**

1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.

1. Scegli **Modifica**.

1. Scegli **Visual**.

1. In alto a sinistra, scegli **\$1 Azioni** per aprire il catalogo delle azioni.

1. **Dall'elenco a discesa, scegli Amazon. CodeCatalyst**

1. Cerca l'azione **Deploy to Amazon ECS** ed esegui una delle seguenti operazioni:
   + Scegli il segno più (**\$1**) per aggiungere l'azione al diagramma del flusso di lavoro e apri il relativo riquadro di configurazione.

     Or
   + Scegli **Deploy to Amazon ECS**. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
     + (Facoltativo) Scegliete **Scarica** per [visualizzare il codice sorgente dell'azione](workflows-view-source.md#workflows-view-source.title).
     + Scegli **Aggiungi al flusso di lavoro** per aggiungere l'azione al diagramma del flusso di lavoro e aprirne il riquadro di configurazione.

1. Nelle schede **Ingressi** e **Configurazione**, completa i campi in base alle tue esigenze. Per una descrizione di ogni campo, consulta. [Azione «Distribuisci su Amazon ECS» YAML](deploy-action-ref-ecs.md) Questo riferimento fornisce informazioni dettagliate su ogni campo (e il valore della proprietà YAML corrispondente) così come appaiono sia nell'editor YAML che in quello visivo.

1. (Facoltativo) Scegliete **Convalida per convalidare il codice YAML** del flusso di lavoro prima di eseguire il commit.

1. **Scegliete **Commit**, inserite un messaggio di commit e scegliete nuovamente Commit.**

------
#### [ YAML ]

**Per aggiungere l'azione «Deploy to Amazon ECS» utilizzando l'editor YAML**

1. [Apri la console all'indirizzo https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)

1. Scegliere il progetto.

1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**

1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.

1. Scegli **Modifica**.

1. Scegli **YAML**.

1. In alto a sinistra, scegli **\$1 Azioni per aprire il catalogo delle azioni**.

1. **Dall'elenco a discesa, scegli Amazon. CodeCatalyst**

1. Cerca l'azione **Deploy to Amazon ECS** ed esegui una delle seguenti operazioni:
   + Scegli il segno più (**\$1**) per aggiungere l'azione al diagramma del flusso di lavoro e apri il relativo riquadro di configurazione.

     Or
   + Scegli **Deploy to Amazon ECS**. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
     + (Facoltativo) Scegliete **Scarica** per [visualizzare il codice sorgente dell'azione](workflows-view-source.md#workflows-view-source.title).
     + Scegli **Aggiungi al flusso di lavoro** per aggiungere l'azione al diagramma del flusso di lavoro e aprirne il riquadro di configurazione.

1. Modifica le proprietà del codice YAML in base alle tue esigenze. Una spiegazione di ogni proprietà disponibile è fornita in. [Azione «Distribuisci su Amazon ECS» YAML](deploy-action-ref-ecs.md)

1. (Facoltativo) Scegliete **Convalida per convalidare** il codice YAML del flusso di lavoro prima di eseguire il commit.

1. **Scegliete **Commit**, inserite un messaggio di commit e scegliete nuovamente Commit.**

------

# Variabili «Distribuisci su Amazon ECS»
<a name="deploy-action-ecs-variables"></a>

L'azione **Deploy to Amazon ECS** produce e imposta le seguenti variabili in fase di esecuzione. Queste sono note come variabili *predefinite*.

Per informazioni su come fare riferimento a queste variabili in un flusso di lavoro, vedere. [Utilizzo di variabili predefinite](workflows-using-predefined-variables.md)


| Chiave | Valore | 
| --- | --- | 
|  cluster  |  Il nome del cluster Amazon ECS su cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `codecatalyst-ecs-cluster`  | 
|  piattaforma di distribuzione  |  Il nome della piattaforma di distribuzione. Codificato in. `AWS:ECS`  | 
|  service  |  Il nome del servizio Amazon ECS su cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `codecatalyst-ecs-service`  | 
|  task-definition-arn  |  L'Amazon Resource Name (ARN) della definizione dell'attività registrata durante l'esecuzione del flusso di lavoro. Ad esempio: `arn:aws:ecs:us-west-2:111122223333:task-definition/codecatalyst-task-def:8`L'`:8`esempio precedente indica la revisione che è stata registrata.  | 
|  url di distribuzione  |  Un collegamento alla scheda **Eventi** della console Amazon ECS, in cui è possibile visualizzare i dettagli della distribuzione di Amazon ECS associata all'esecuzione del flusso di lavoro. Ad esempio: `https://console.aws.amazon.com/ecs/home?region=us-west-2#/clusters/codecatalyst-ecs-cluster/services/codecatalyst-ecs-service/events`  | 
|  region  |  Il codice regionale su Regione AWS cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `us-west-2`  | 

# Azione «Distribuisci su Amazon ECS» YAML
<a name="deploy-action-ref-ecs"></a>

Di seguito è riportata la definizione YAML dell'azione **Deploy to Amazon ECS**. Per informazioni su come utilizzare questa azione, consulta. [Distribuzione su Amazon ECS con un flusso di lavoro](deploy-action-ecs.md)

Questa definizione di azione esiste come sezione all'interno di un file di definizione del flusso di lavoro più ampio. Per ulteriori informazioni su questo file, consulta [Definizione YAML del flusso di lavoro](workflow-reference.md).

**Nota**  
La maggior parte delle proprietà YAML che seguono hanno elementi dell'interfaccia utente corrispondenti nell'editor visivo. **Per cercare un elemento dell'interfaccia utente, usa Ctrl\$1F.** L'elemento verrà elencato con la proprietà YAML associata.

```
# The workflow definition starts here.
# See Proprietà di primo livello for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  ECSDeployAction\$1nn: 
    Identifier: aws/ecs-deploy@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - task-definition-artifact
    Configuration: 
      region: us-east-1 
      cluster: ecs-cluster
      service: ecs-service
      task-definition: task-definition-path
      force-new-deployment: false|true
      codedeploy-appspec: app-spec-file-path
      codedeploy-application: application-name
      codedeploy-deployment-group: deployment-group-name
      codedeploy-deployment-description: deployment-description
```

## ECSDeployAction
<a name="deploy.action.ecs.name"></a>

(Obbligatorio)

Specificare il nome dell'azione. Tutti i nomi delle azioni devono essere univoci all'interno del flusso di lavoro. I nomi delle azioni sono limitati a caratteri alfanumerici (a-z, A-Z, 0-9), trattini (-) e caratteri di sottolineatura (\$1). Gli spazi non sono consentiti. Non è possibile utilizzare le virgolette per abilitare caratteri e spazi speciali nei nomi delle azioni.

Default: `ECSDeployAction_nn`.

Interfaccia utente corrispondente: scheda di configurazione/nome visualizzato **dell'azione**

## Identifier
<a name="deploy.action.ecs.identifier"></a>

(*ECSDeployAction*/**Identifier**)

(Obbligatorio)

Identifica l'azione. Non modificate questa proprietà a meno che non vogliate cambiare la versione. Per ulteriori informazioni, consulta [Specificare la versione dell'azione da utilizzare](workflows-action-versions.md).

Default: `aws/ecs-deploy@v1`.

**Interfaccia utente corrispondente: Workflow diagram/ ECSDeploy Action\$1NN/ aws/ecs-deploy @v1 label**

## DependsOn
<a name="deploy.action.ecs.dependson"></a>

(*ECSDeployAction*/**DependsOn**)

(Facoltativo)

Specificare un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente per eseguire questa azione.

Per ulteriori informazioni sulla funzionalità «dipende da», vedere. [Azioni di sequenziamento](workflows-depends-on.md)

**Interfaccia utente corrispondente: scheda Input/Dipende da - opzionale**

## Compute
<a name="deploy.action.ecs.computename"></a>

(*ECSDeployAction*/**Compute**)

(Facoltativo)

Il motore di calcolo utilizzato per eseguire le azioni del flusso di lavoro. È possibile specificare l'elaborazione a livello di flusso di lavoro o a livello di azione, ma non entrambi. Se specificata a livello di flusso di lavoro, la configurazione di calcolo si applica a tutte le azioni definite nel flusso di lavoro. A livello di flusso di lavoro, puoi anche eseguire più azioni sulla stessa istanza. Per ulteriori informazioni, consulta [Condivisione dell'elaborazione tra le azioni](compute-sharing.md).

Interfaccia utente corrispondente: *nessuna*

## Type
<a name="deploy.action.ecs.computetype"></a>

(*ECSDeployAction*/Compute/**Type**)

(Richiesto [Compute](#deploy.action.ecs.computename) se incluso)

Il tipo di motore di calcolo. È possibile utilizzare uno dei seguenti valori:
+ **EC2** (editor visivo) o `EC2` (editor YAML)

  Ottimizzato per la flessibilità durante le operazioni.
+ **Lambda** (editor visivo) o `Lambda` (editor YAML)

  Velocità di avvio delle azioni ottimizzate.

Per ulteriori informazioni sui tipi di calcolo, consulta [Tipi di calcolo](workflows-working-compute.md#compute.types).

**Interfaccia utente corrispondente: configurazione tab/Advanced : opzionale/tipo di calcolo**

## Fleet
<a name="deploy.action.ecs.computefleet"></a>

(*ECSDeployAction*/Compute/**Fleet**)

(Facoltativo)

Specificate la macchina o il parco macchine che eseguiranno il flusso di lavoro o le azioni del flusso di lavoro. Con le flotte on-demand, all'avvio di un'azione, il flusso di lavoro fornisce le risorse necessarie e le macchine vengono distrutte al termine dell'azione. Esempi di flotte on-demand:,. `Linux.x86-64.Large` `Linux.x86-64.XLarge` Per ulteriori informazioni sulle flotte on-demand, vedere. [Proprietà del parco istanze on demand](workflows-working-compute.md#compute.on-demand)

Con le flotte assegnate, puoi configurare una serie di macchine dedicate per eseguire le azioni del flusso di lavoro. Queste macchine rimangono inattive, pronte a elaborare immediatamente le azioni. Per ulteriori informazioni sulle flotte rifornite, vedere. [Proprietà del parco istanze con provisioning](workflows-working-compute.md#compute.provisioned-fleets)

Se `Fleet` viene omesso, l'impostazione predefinita è. `Linux.x86-64.Large`

**Interfaccia utente corrispondente: Configurazione tab/Advanced : parco opzionale/di calcolo**

## Timeout
<a name="deploy.action.ecs.timeout"></a>

(*ECSDeployAction*/**Timeout**)

(Facoltativo)

Specificate il periodo di tempo, in minuti (editor YAML) o in ore e minuti (editor visivo), che l'azione può essere eseguita prima che termini l'azione. CodeCatalyst Il minimo è 5 minuti e il massimo è descritto in. [Quote per i flussi di lavoro in CodeCatalyst](workflows-quotas.md) Il timeout predefinito è lo stesso del timeout massimo.

**Interfaccia utente corrispondente: scheda di configurazione/timeout - opzionale**

## Environment
<a name="deploy.action.ecs.environment"></a>

(*ECSDeployAction*/**Environment**)

(Obbligatorio)

Specificare l' CodeCatalyst ambiente da utilizzare con l'azione. L'azione si connette Account AWS all'Amazon VPC opzionale specificato nell'ambiente scelto. L'azione utilizza il ruolo IAM predefinito specificato nell'ambiente per connettersi a e utilizza il ruolo IAM specificato nella [connessione Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) per connettersi ad Amazon VPC. Account AWS

**Nota**  
Se il ruolo IAM predefinito non dispone delle autorizzazioni richieste dall'azione, puoi configurare l'azione per utilizzare un ruolo diverso. Per ulteriori informazioni, consulta [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md).

Per ulteriori informazioni sugli ambienti, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md) e[Creazione di un ambiente](deploy-environments-creating-environment.md).

**Interfaccia utente corrispondente: scheda di configurazione/ambiente**

## Name
<a name="deploy.action.ecs.environment.name"></a>

(*ECSDeployAction*/Environment/**Name**)

(Richiesto se [Environment](#deploy.action.ecs.environment) incluso)

Specificate il nome di un ambiente esistente che desiderate associare all'azione.

**Interfaccia utente corrispondente: scheda di configurazione/ambiente**

## Connections
<a name="deploy.action.ecs.environment.connections"></a>

(*ECSDeployAction*/Environment/**Connections**)

(Facoltativo nelle versioni più recenti dell'azione; richiesto nelle versioni precedenti)

Specificare la connessione dell'account da associare all'azione. È possibile specificare al massimo una connessione a un account in`Environment`.

Se non si specifica una connessione all'account:
+ L'azione utilizza la Account AWS connessione e il ruolo IAM predefinito specificati nell'ambiente della CodeCatalyst console. Per informazioni sull'aggiunta di una connessione all'account e del ruolo IAM predefinito all'ambiente, consulta[Creazione di un ambiente](deploy-environments-creating-environment.md).
+ Il ruolo IAM predefinito deve includere le policy e le autorizzazioni richieste dall'azione. Per determinare quali sono tali politiche e autorizzazioni, consulta la descrizione della proprietà **Role nella documentazione** sulla definizione YAML dell'azione.

Per ulteriori informazioni sulle connessioni degli account, vedere. [Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md) Per informazioni sull'aggiunta di una connessione tramite account a un ambiente, vedere[Creazione di un ambiente](deploy-environments-creating-environment.md).

Interfaccia utente corrispondente: una delle seguenti a seconda della versione dell'azione:
+ (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo**
+ **(Versioni precedenti) Scheda di configurazione/' '/ connessione all'account Environment/account/role AWS **

## Name
<a name="deploy.action.ecs.environment.connections.name"></a>

(*ECSDeployAction*/Environment/Connections/**Name**)

(Richiesto se incluso[Connections](#deploy.action.ecs.environment.connections))

Specificare il nome della connessione all'account.

Interfaccia utente corrispondente: una delle seguenti a seconda della versione dell'azione:
+ (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo**
+ **(Versioni precedenti) Scheda di configurazione/' '/ connessione all'account Environment/account/role AWS **

## Role
<a name="deploy.action.ecs.environment.connections.role"></a>

(*ECSDeployAction*/Environment/Connections/**Role**)

(Richiesto se incluso[Connections](#deploy.action.ecs.environment.connections))

Specificare il nome del ruolo IAM a cui l'azione **Deploy to Amazon ECS** utilizza per accedere. AWS Assicurati di aver [aggiunto il ruolo al tuo CodeCatalyst spazio](ipa-connect-account-addroles.md) e che il ruolo includa le seguenti politiche.

Se non specifichi un ruolo IAM, l'azione utilizza il ruolo IAM predefinito elencato nell'[ambiente](deploy-environments.md) nella CodeCatalyst console. Se utilizzi il ruolo predefinito nell'ambiente, assicurati che abbia le seguenti politiche.
+ La seguente politica di autorizzazioni:
**avvertimento**  
Limita le autorizzazioni a quelle mostrate nella seguente politica. L'utilizzo di un ruolo con autorizzazioni più ampie potrebbe rappresentare un rischio per la sicurezza.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [{
      "Action":[
        "ecs:DescribeServices",
        "ecs:CreateTaskSet",
        "ecs:DeleteTaskSet",
        "ecs:ListClusters",
        "ecs:RegisterTaskDefinition",
        "ecs:UpdateServicePrimaryTaskSet",
        "ecs:UpdateService",
        "elasticloadbalancing:DescribeTargetGroups",
        "elasticloadbalancing:DescribeListeners",
        "elasticloadbalancing:ModifyListener",
        "elasticloadbalancing:DescribeRules",
        "elasticloadbalancing:ModifyRule",
        "lambda:InvokeFunction",
        "lambda:ListFunctions",
        "cloudwatch:DescribeAlarms",
        "sns:Publish",
        "sns:ListTopics", 
        "s3:GetObject",
        "s3:GetObjectVersion",
        "codedeploy:CreateApplication", 
        "codedeploy:CreateDeployment", 
        "codedeploy:CreateDeploymentGroup", 
        "codedeploy:GetApplication", 
        "codedeploy:GetDeployment", 
        "codedeploy:GetDeploymentGroup", 
        "codedeploy:ListApplications", 
        "codedeploy:ListDeploymentGroups", 
        "codedeploy:ListDeployments", 
        "codedeploy:StopDeployment", 
        "codedeploy:GetDeploymentTarget", 
        "codedeploy:ListDeploymentTargets", 
        "codedeploy:GetDeploymentConfig", 
        "codedeploy:GetApplicationRevision", 
        "codedeploy:RegisterApplicationRevision", 
        "codedeploy:BatchGetApplicationRevisions", 
        "codedeploy:BatchGetDeploymentGroups", 
        "codedeploy:BatchGetDeployments", 
        "codedeploy:BatchGetApplications", 
        "codedeploy:ListApplicationRevisions", 
        "codedeploy:ListDeploymentConfigs", 
        "codedeploy:ContinueDeployment"           
     ],
     "Resource":"*",
     "Effect":"Allow"
  },{"Action":[
        "iam:PassRole"
     ],
     "Effect":"Allow",
     "Resource":"*",
     "Condition":{"StringLike":{"iam:PassedToService":[
              "ecs-tasks.amazonaws.com",
              "codedeploy.amazonaws.com"
           ]
        }
     }
  }]
  }
  ```

------
**Nota**  
La prima volta che il ruolo viene utilizzato, utilizza il seguente carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.  

  ```
  "Resource": "*"
  ```
+ La seguente politica di fiducia personalizzata:

**Nota**  
Puoi usare il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo con questa azione, se lo desideri. Per ulteriori informazioni su questo ruolo, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo dispone di autorizzazioni di accesso complete, il che può rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. 

Interfaccia utente corrispondente: una delle seguenti a seconda della versione di azione:
+ (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo**
+ **(Versioni precedenti) Scheda di configurazione/' '/ Ruolo Environment/account/role**

## Inputs
<a name="deploy.action.ecs.inputs"></a>

(*ECSDeployAction*/**Inputs**)

(Facoltativo)

La `Inputs` sezione definisce i dati `ECSDeployAction` necessari durante l'esecuzione di un flusso di lavoro.

**Nota**  
È consentito un solo input (fonte o artefatto) per azione **Deploy to Amazon ECS**.

**Interfaccia utente corrispondente: scheda Input**

## Sources
<a name="deploy.action.ecs.inputs.sources"></a>

(*ECSDeployAction*/Inputs/**Sources**)

(Richiesto se il file di definizione delle attività è archiviato in un repository di origine)

Se il file di definizione delle attività è archiviato in un repository di origine, specifica l'etichetta di tale repository di origine. Attualmente, l'unica etichetta supportata è. `WorkflowSource`

Se il file di definizione dell'attività non è contenuto in un repository di origine, deve risiedere in un artefatto generato da un'altra azione.

Per ulteriori informazioni sulle origini, consulta [Connessione degli archivi di origine ai flussi di lavoro](workflows-sources.md).

**Interfaccia utente corrispondente: scheda Input/Sources - opzionale**

## Artifacts - input
<a name="deploy.action.ecs.inputs.artifacts"></a>

(*ECSDeployAction*/Inputs/**Artifacts**)

(Richiesto se il file di definizione dell'attività è memorizzato in un elemento [di output di un'azione precedente](workflows-working-artifacts-output.md))

Se il file di definizione dell'attività che desideri distribuire è contenuto in un artefatto generato da un'azione precedente, specifica l'artefatto qui. Se il file di definizione dell'attività non è contenuto in un artefatto, deve risiedere nel repository di origine.

Per ulteriori informazioni sugli artefatti, inclusi esempi, vedere. [Condivisione di artefatti e file tra azioni](workflows-working-artifacts.md)

**Interfaccia utente corrispondente: scheda di configurazione/artefatti - opzionale**

## Configuration
<a name="deploy.action.ecs.configuration"></a>

(*ECSDeployAction*/**Configuration**)

(Obbligatorio)

Una sezione in cui è possibile definire le proprietà di configurazione dell'azione.

Interfaccia utente corrispondente: scheda **Configurazione**

## region
<a name="deploy.action.ecs.region"></a>

(Configuration/**region**)

(Obbligatorio)

Specificare la AWS regione in cui risiedono il cluster e il servizio Amazon ECS. Per un elenco dei codici regionali, consulta [Endpoint regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) nel. *Riferimenti generali di AWS*

**Interfaccia utente corrispondente: scheda/regione di configurazione**

## cluster
<a name="deploy.action.ecs.cluster"></a>

(*ECSDeployAction*/Configuration/**cluster**)

(Obbligatorio)

Specificare il nome di un cluster Amazon ECS esistente. L'azione **Deploy to Amazon ECS** distribuirà la tua applicazione containerizzata come attività in questo cluster. Per ulteriori informazioni sui cluster Amazon ECS, consulta [Clusters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) nella *Amazon Elastic Container Service* Developer Guide.

**Interfaccia utente corrispondente: scheda Configurazione/Cluster**

## service
<a name="deploy.action.ecs.service"></a>

(*ECSDeployAction*/Configuration/**service**)

(Obbligatorio)

Specificare il nome di un servizio Amazon ECS esistente che creerà un'istanza del file di definizione delle attività. Questo servizio deve risiedere nel cluster specificato nel campo. `cluster` Per ulteriori informazioni sui servizi Amazon ECS, consulta i servizi [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) nella *Amazon Elastic Container Service Developer Guide*.

**Interfaccia utente corrispondente: scheda di configurazione/servizio**

## task-definition
<a name="deploy.action.ecs.task.definition"></a>

(*ECSDeployAction*/Configuration/**task-definition**)

(Obbligatorio)

Specificare il percorso di un file di definizione delle attività esistente. Se il file si trova nel repository di origine, il percorso è relativo alla cartella principale del repository di origine. Se il file si trova in un elemento di un'azione precedente del flusso di lavoro, il percorso è relativo alla cartella principale dell'elemento. Per ulteriori informazioni sui file di definizione delle attività, consulta [Definizioni delle attività](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) nella *Amazon Elastic Container Service Developer Guide*.

Interfaccia utente corrispondente: scheda di configurazione/definizione dell'**attività**

## force-new-deployment
<a name="deploy.action.ecs.forcenewdeployment"></a>

(*ECSDeployAction*/Configuration/**force-new-deployment**)

(Obbligatorio)

Se abilitato, il servizio Amazon ECS è in grado di avviare nuove distribuzioni senza modifiche alla definizione del servizio. Forzare una distribuzione fa sì che il servizio interrompa tutte le attività attualmente in esecuzione e avvii nuove attività. Per ulteriori informazioni su come forzare nuove distribuzioni, consulta [Updating a service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service.html) nella *Amazon Elastic Container Service Developer Guide*.

Impostazione predefinita: `false`

Interfaccia utente corrispondente: scheda Configurazione/ **Forza una nuova distribuzione** del servizio

## codedeploy-appspec
<a name="deploy.action.ecs.codedeploy.appspec"></a>

(*ECSDeployAction*/Configuration/**codedeploy-appspec**)

(Obbligatorio se hai configurato il servizio Amazon ECS per utilizzare le blue/green distribuzioni, altrimenti omettilo)

Specificare il nome e il percorso di un file di specifiche CodeDeploy dell'applicazione () esistente. AppSpec Questo file deve risiedere nella directory principale del repository di CodeCatalyst origine. Per ulteriori informazioni sui AppSpec file, consultate i file [delle specifiche CodeDeploy dell'applicazione (AppSpec) nella Guida](https://docs.aws.amazon.com/codedeploy/latest/userguide/application-specification-files.html) per l'*AWS CodeDeploy utente*.

**Nota**  
Fornisci CodeDeploy informazioni solo se hai configurato il servizio Amazon ECS per eseguire blue/green distribuzioni. Per le distribuzioni di aggiornamento in sequenza (impostazione predefinita), ometti le informazioni. CodeDeploy Per ulteriori informazioni sulle distribuzioni di Amazon ECS, consulta i tipi di [distribuzione di Amazon ECS nella](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) *Amazon Elastic Container* Service Developer Guide.

**Nota**  
I **CodeDeploy**campi possono essere nascosti nell'editor visuale. Per farli apparire, vedi[Perché mancano CodeDeploy dei campi nell'editor visivo?](troubleshooting-workflows.md#troubleshooting-workflows-codedeploy).

Interfaccia utente corrispondente: scheda Configurazione/ **CodeDeploy AppSpec**

## codedeploy-application
<a name="deploy.action.ecs.codedeploy.application"></a>

(*ECSDeployAction*/Configuration/**codedeploy-application**)

(Richiesto se `codedeploy-appspec` incluso)

Specificate il nome di un' CodeDeploy applicazione esistente. Per ulteriori informazioni sulle CodeDeploy applicazioni, vedere [Lavorare con le applicazioni CodeDeploy nella](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) *Guida per l'AWS CodeDeploy utente*.

**Interfaccia utente corrispondente: scheda di configurazione/applicazione CodeDeploy **

## codedeploy-deployment-group
<a name="deploy.action.ecs.codedeploy.deploymentgroup"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-group**)

(Richiesto se `codedeploy-appspec` incluso)

Specificare il nome di un gruppo CodeDeploy di distribuzione esistente. Per ulteriori informazioni sui gruppi di CodeDeploy distribuzione, vedere [Lavorare con i gruppi di distribuzione CodeDeploy nella](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) *Guida per l'AWS CodeDeploy utente*.

Interfaccia utente corrispondente: scheda di configurazione/gruppo **CodeDeploy di distribuzione**

## codedeploy-deployment-description
<a name="deploy.action.ecs.codedeploy.deploymentdescription"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-description**)

(Facoltativo)

Specificare una descrizione della distribuzione che verrà creata con questa azione. Per ulteriori informazioni, consulta [Lavorare con le distribuzioni CodeDeploy nella Guida](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments.html) per l'*AWS CodeDeploy utente*.

**Interfaccia utente corrispondente: scheda di configurazione/descrizione della distribuzione CodeDeploy **