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

# Implementazione con flussi di lavoro
<a name="deploy"></a>



Utilizzando [CodeCatalyst i flussi](workflow.md) di lavoro, puoi distribuire applicazioni e altre risorse per vari obiettivi come Amazon ECS e altro ancora AWS Lambda. 

## Come posso distribuire un'applicazione?
<a name="deploy-concepts"></a>

Per distribuire un'applicazione o una risorsa CodeCatalyst, è innanzitutto necessario creare un flusso di lavoro e quindi specificare un'azione di distribuzione al suo interno. Un'*azione di distribuzione* è un elemento costitutivo del flusso di lavoro che definisce *cosa* *si desidera distribuire, dove* distribuirlo e *come* lo si desidera (ad esempio, utilizzando uno schema). blue/green Puoi aggiungere un'azione di distribuzione al tuo flusso di lavoro utilizzando l'editor visivo della CodeCatalyst console o l'editor YAML.

I passaggi di alto livello per distribuire un'applicazione o una risorsa sono i seguenti.

**Per distribuire un'applicazione (attività di alto livello)**

1. Nel CodeCatalyst progetto, **aggiungi il codice sorgente** per un'applicazione che desideri distribuire. Per ulteriori informazioni, consulta [Memorizzazione del codice sorgente nei repository per un progetto in CodeCatalyst](source-repositories.md).

1. Nel CodeCatalyst progetto, **aggiungi un ambiente** che definisce la destinazione Account AWS e l'opzione Amazon Virtual Private Cloud (VPC) su cui desideri effettuare la distribuzione. Per ulteriori informazioni, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md).

1. Nel tuo CodeCatalyst progetto, **crei un** flusso di lavoro. Il flusso di lavoro è il luogo in cui definisci come creare, testare e distribuire l'applicazione. Per ulteriori informazioni, consulta [Guida introduttiva ai flussi di lavoro](workflows-getting-started.md).

1. Nel flusso di lavoro, **aggiungi un trigger**, un'**azione di creazione** e, facoltativamente, un'azione di **test**. Per ulteriori informazioni, consultare [L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger](workflows-add-trigger.md), [Aggiungere l'azione di compilazione](build-add-action.md) e [Aggiungere l'azione di test](test-add-action.md).

1. Nel flusso di lavoro, **aggiungi un'azione di distribuzione.** Puoi scegliere tra diverse azioni CodeCatalyst di distribuzione fornite alla tua applicazione verso destinazioni diverse, come Amazon ECS. (Puoi anche utilizzare un'azione di compilazione o un' GitHub azione per distribuire la tua applicazione. Per ulteriori informazioni sull'azione di compilazione e sulle GitHub azioni, consulta[Alternative all'implementazione delle azioni](#deploy-concepts-alternatives).)

1. **Il flusso di lavoro viene avviato** manualmente o automaticamente tramite un trigger. Il flusso di lavoro esegue le azioni di compilazione, test e distribuzione in sequenza per distribuire l'applicazione e le risorse sulla destinazione. Per ulteriori informazioni, consulta [Avvio manuale dell’esecuzione di un flusso di lavoro](workflows-manually-start.md).

## Elenco delle azioni di distribuzione
<a name="deploy-concepts-action-supported"></a>

Sono disponibili le seguenti azioni di distribuzione:
+ [Distribuisci CloudFormation stack: questa azione crea uno CloudFormation stack in AWS base a uno o AWS Serverless Application Model più [CloudFormation modelli forniti](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) dall'utente.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) Per ulteriori informazioni, consulta [Implementazione di uno stack CloudFormation](deploy-action-cfn.md).
+ Distribuzione su Amazon ECS: 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. Per ulteriori informazioni, consulta [Distribuzione su Amazon ECS con un flusso di lavoro](deploy-action-ecs.md).
+ Distribuzione su cluster Kubernetes: questa azione distribuisce un'applicazione in un cluster Amazon Elastic Kubernetes Service. Per ulteriori informazioni, consulta [Implementazione su Amazon EKS con un flusso di lavoro](deploy-action-eks.md).
+ AWS CDK [deploy: questa azione distribuisce un'app in.AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_concepts) AWS Per ulteriori informazioni, consulta [Implementazione di un' AWS CDK app con un flusso di lavoro](cdk-dep-action.md).

**Nota**  
**Esistono altre CodeCatalyst azioni che possono distribuire risorse; tuttavia, non sono considerate azioni di *distribuzione* perché le relative informazioni sulla distribuzione non vengono visualizzate nella pagina Ambienti.** Per ulteriori informazioni sulla pagina **Ambienti** e sulla visualizzazione delle distribuzioni, consulta e. [Implementazione in e Account AWS VPCs](deploy-environments.md) [Visualizzazione delle informazioni sulla distribuzione](deploy-view-deployment-info.md)

## Vantaggi delle azioni di implementazione
<a name="deploy-concepts-why-use"></a>

L'utilizzo delle azioni di distribuzione all'interno di un flusso di lavoro offre i seguenti vantaggi:
+ **Cronologia di implementazione**: visualizza una cronologia delle distribuzioni per facilitare la gestione e la comunicazione delle modifiche al software distribuito. 
+ **Tracciabilità**: monitora lo stato delle tue implementazioni tramite la CodeCatalyst console e scopri quando e dove è stata distribuita ogni revisione dell'applicazione.
+ **Rollback**: ripristina automaticamente le distribuzioni in caso di errori. Puoi anche configurare gli allarmi per attivare i rollback di distribuzione.
+ **Monitoraggio: monitora** l'avanzamento della distribuzione nelle varie fasi del flusso di lavoro.
+ **Integrazione con altre CodeCatalyst funzionalità**: archivia il codice sorgente e quindi crealo, testalo e distribuiscilo, il tutto da un'unica applicazione.

## Alternative all'implementazione delle azioni
<a name="deploy-concepts-alternatives"></a>

Non è necessario utilizzare le azioni di distribuzione, sebbene siano consigliate perché offrono i vantaggi descritti nella sezione precedente. [Puoi invece utilizzare le seguenti azioni: CodeCatalyst ](workflows-actions.md#workflows-actions-types-cc)
+ Un'azione di **costruzione**.

  In genere, si utilizzano le azioni di compilazione se si desidera eseguire la distribuzione su una destinazione per la quale non esiste un'azione di distribuzione corrispondente o se si desidera un maggiore controllo sulla procedura di distribuzione. Per ulteriori informazioni sull'utilizzo delle azioni di compilazione per distribuire risorse, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md)
+ Un'**GitHub azione.**

  È possibile utilizzare un'[GitHub azione](workflows-actions.md#workflows-actions-types-github) all'interno CodeCatalyst di un flusso di lavoro per distribuire applicazioni e risorse (anziché un' CodeCatalystazione). Per informazioni su come utilizzare GitHub Actions all'interno di un CodeCatalyst flusso di lavoro, consulta [Integrazione con GitHub Actions](integrations-github-actions.md)

Puoi anche utilizzare i seguenti AWS servizi per distribuire l'applicazione, se non desideri utilizzare un CodeCatalyst flusso di lavoro per farlo:
+ AWS CodeDeploy — vedi [Cos'è CodeDeploy?](https://docs.aws.amazon.com/codedeploy/latest/userguide/welcome.html)
+ AWS CodeBuild e AWS CodePipeline — vedi [Cos'è AWS CodeBuild?](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html) e [cos'è AWS CodePipeline?](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)
+ CloudFormation — vedi [Cos'è CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)

Utilizzo CodeDeploy CodeBuild e CodePipeline CloudFormation servizi per implementazioni aziendali complesse.

**Topics**
+ [Come posso distribuire un'applicazione?](#deploy-concepts)
+ [Elenco delle azioni di distribuzione](#deploy-concepts-action-supported)
+ [Vantaggi delle azioni di implementazione](#deploy-concepts-why-use)
+ [Alternative all'implementazione delle azioni](#deploy-concepts-alternatives)
+ [Distribuzione su Amazon ECS con un flusso di lavoro](deploy-action-ecs.md)
+ [Implementazione su Amazon EKS con un flusso di lavoro](deploy-action-eks.md)
+ [Implementazione di uno stack CloudFormation](deploy-action-cfn.md)
+ [Implementazione di un' AWS CDK app con un flusso di lavoro](cdk-dep-action.md)
+ [Avvio di un' AWS CDK app con un flusso di lavoro](cdk-boot-action.md)
+ [Pubblicazione di file su Amazon S3 con un flusso di lavoro](s3-pub-action.md)
+ [Implementazione in e Account AWS VPCs](deploy-environments.md)
+ [Visualizzazione dell'URL dell'app nel diagramma del flusso di lavoro](deploy-app-url.md)
+ [Rimozione di un obiettivo di distribuzione](deploy-remove-target.md)
+ [Monitoraggio dello stato di distribuzione tramite commit](track-changes.md)
+ [Visualizzazione dei log di distribuzione](deploy-deployment-logs.md)
+ [Visualizzazione delle informazioni sulla distribuzione](deploy-view-deployment-info.md)

# 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 **

# Implementazione su Amazon EKS con un flusso di lavoro
<a name="deploy-action-eks"></a>

**Suggerimento**  
Per un tutorial che mostra come utilizzare l'azione del cluster **Deploy to Kubernetes**, consulta. [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md)

Questa sezione descrive come distribuire un'applicazione containerizzata in un cluster Kubernetes utilizzando un flusso di lavoro. CodeCatalyst A tale scopo, è necessario aggiungere l'azione **Deploy to Kubernetes cluster al flusso** di lavoro. Questa azione distribuisce la tua applicazione in un cluster Kubernetes che hai configurato in Amazon Elastic Kubernetes Service (EKS) utilizzando uno o più file manifest Kubernetes. Per [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) un [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) manifesto di esempio, consulta in.

[Per ulteriori informazioni su Kubernetes, consulta la documentazione di Kubernetes.](https://kubernetes.io/docs/home/)

Per ulteriori informazioni su Amazon EKS, consulta [Cos'è Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) nella *Guida per l'utente di Amazon EKS*.

**Topics**
+ [Come funziona l'azione «Deploy to Kubernetes cluster»](#deploy-action-eks-howitworks)
+ [Immagine di runtime utilizzata dall'azione «Deploy to Amazon EKS»](#deploy-action-eks-runtime)
+ [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md)
+ [Aggiungere l'azione «Deploy to Kubernetes cluster»](deploy-action-eks-adding.md)
+ [Variabili «Distribuisci su cluster Kubernetes»](deploy-action-eks-variables.md)
+ [Azione «Distribuisci su cluster Kubernetes» YAML](deploy-action-ref-eks.md)

## Come funziona l'azione «Deploy to Kubernetes cluster»
<a name="deploy-action-eks-howitworks"></a>

Il cluster **Deploy to Kubernetes funziona come** segue:

1. In fase di esecuzione, l'azione installa l'`kubectl`utilità Kubernetes sulla macchina di elaborazione su cui è in esecuzione l' CodeCatalystazione. L'azione si configura in modo da `kubectl` puntare al cluster Amazon EKS fornito al momento della configurazione dell'azione. L'`kubectl`utilità è necessaria per eseguire il `kubectl apply` comando, quindi.

1. L'azione esegue il `kubectl apply -f my-manifest.yaml` comando, che esegue le istruzioni *my-manifest.yaml* per distribuire l'applicazione come set di contenitori e pod nel cluster configurato. *Per ulteriori informazioni su questo comando, consulta l'argomento [kubectl apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply) nella documentazione di riferimento di Kubernetes.*

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

L'azione **Deploy to Amazon EKS** 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: distribuzione di un'applicazione su Amazon EKS
<a name="deploy-tut-eks"></a>

In questo tutorial, imparerai come distribuire un'applicazione containerizzata in Amazon Elastic Kubernetes Service utilizzando un flusso di lavoro Amazon, CodeCatalyst Amazon EKS e alcuni altri servizi. AWS L'applicazione distribuita è un semplice «Hello, World\$1» sito web costruito su un'immagine Docker del server web Apache. Il tutorial illustra il lavoro di preparazione richiesto, ad esempio la configurazione di una macchina di sviluppo e di un cluster Amazon EKS, quindi descrive come creare un flusso di lavoro per creare l'applicazione e distribuirla nel cluster.

Una volta completata la distribuzione iniziale, il tutorial ti spiega come apportare una modifica all'origine dell'applicazione. Questa modifica fa sì che una nuova immagine Docker venga creata e inserita nel tuo archivio di immagini Docker con nuove informazioni di revisione. La nuova revisione dell'immagine Docker viene quindi distribuita in Amazon EKS.

**Suggerimento**  
Invece di seguire questo tutorial, puoi utilizzare un blueprint che esegua una configurazione completa di Amazon EKS per te. Dovrai utilizzare il blueprint **EKS App Deployment**. Per ulteriori informazioni, consulta [Creare un progetto con un blueprint](projects-create.md#projects-create-console-template).

**Topics**
+ [Prerequisiti](#deploy-tut-eks-prereqs)
+ [Passaggio 1: configura la tua macchina di sviluppo](#deploy-tut-eks-dev-env-create)
+ [Fase 2: creare un cluster Amazon EKS](#deploy-tut-eks-cluster)
+ [Fase 3: creare un repository di immagini Amazon ECR](#deploy-tut-eks-ecr)
+ [Passaggio 4: Aggiungere i file sorgente](#deploy-tut-eks-source-files)
+ [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles)
+ [Fase 6: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-eks-import-roles)
+ [Fase 7: Aggiornare il ConfigMap](#deploy-tut-eks-configmap)
+ [Passaggio 8: creare ed eseguire un flusso di lavoro](#deploy-tut-eks-workflow)
+ [Passaggio 9: apporta una modifica ai file sorgente](#deploy-tut-eks-change)
+ [Eliminazione](#deploy-tut-eks-cleanup)

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

Prima di iniziare questo tutorial:
+ È necessario uno CodeCatalyst **spazio** Amazon 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-eks-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 **repository di CodeCatalyst sorgenti** vuoto chiamato:

  ```
  codecatalyst-eks-source-repository
  ```

  Per ulteriori informazioni, consulta [Archivia e collabora sul codice con i repository di sorgenti in CodeCatalystArchivia e collabora sul codice con i repository di origine](source.md).
+ Nel tuo progetto, hai bisogno di un ambiente CodeCatalyst CI/CD (non un **ambiente** di sviluppo) chiamato:

  ```
  codecatalyst-eks-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: configura la tua macchina di sviluppo
<a name="deploy-tut-eks-dev-env-create"></a>

Il primo passo di questo tutorial è configurare una macchina di sviluppo con alcuni strumenti che utilizzerai durante questo tutorial. Questi strumenti sono:
+ l'`eksctl`utilità: per la creazione di cluster
+ l'`kubectl`utilità: un prerequisito per `eksctl`
+ il AWS CLI — anche un prerequisito per `eksctl`

Puoi installare questi strumenti sulla tua macchina di sviluppo esistente, se ne hai una, oppure puoi utilizzare un ambiente di CodeCatalyst sviluppo, basato su cloud. Il vantaggio di un ambiente di CodeCatalyst sviluppo è che è facile da avviare e smontare ed è integrato con altri CodeCatalyst servizi, consentendoti di completare questo tutorial in meno passaggi.

Questo tutorial presuppone che utilizzerai un ambiente di CodeCatalyst sviluppo.

Le seguenti istruzioni descrivono un modo rapido per avviare un ambiente di CodeCatalyst sviluppo e configurarlo con gli strumenti richiesti, ma se desideri istruzioni dettagliate, consulta:
+ [Creazione di un ambiente di sviluppo](devenvironment-create.md) in questa guida.
+ [Installazione di kubectl nella Guida](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) per l'utente di **Amazon EKS**.
+ [Installazione o aggiornamento di eksctl nella **Amazon** EKS](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) User Guide.
+ [Installazione o aggiornamento della versione più recente di AWS CLI nella Guida per l'utente](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)*.AWS Command Line Interface *

**Per avviare un ambiente di sviluppo**

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

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

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

1. Scegli il nome del tuo repository di origine,. `codecatalyst-eks-source-repository`

1. In alto scegli **Create Dev Environment**, quindi scegli **AWS Cloud9 (nel browser).**

1. Assicurati che le opzioni **Work in existing branch** e **main** siano selezionate, quindi scegli **Crea**.

   Il tuo ambiente di sviluppo viene avviato in una nuova scheda del browser e il tuo repository (`codecatalyst-eks-source-repository`) viene clonato al suo interno.

**Per installare e configurare kubectl**

1. Nel terminale Dev Environment, inserisci:

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. Inserisci:

   ```
   chmod +x ./kubectl
   ```

1. Inserisci:

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. Inserisci:

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. Inserisci:

   ```
   kubectl version --short --client
   ```

1. Verifica che venga visualizzata una versione.

   Ora hai installato`kubectl`.

**Per installare e configurare eksctl**
**Nota**  
`eksctl`non è strettamente necessario perché è possibile `kubectl` utilizzarlo al suo posto. Tuttavia, `eksctl` ha il vantaggio di automatizzare gran parte della configurazione del cluster ed è quindi lo strumento consigliato per questo tutorial.

1. Nel terminale Dev Environment, inserisci:

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. Inserisci:

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Inserisci:

   ```
   eksctl version
   ```

1. Verifica che venga visualizzata una versione.

   Ora hai installato`eksctl`.

**Per verificare che AWS CLI sia installato**

1. Nel terminale Dev Environment, inserisci:

   ```
   aws --version
   ```

1. Verificate che appaia una versione per verificare che AWS CLI sia installata.

   Completa le procedure rimanenti per configurarlo AWS CLI con le autorizzazioni necessarie per l'accesso AWS.

**Per configurare il AWS CLI**

È necessario configurarlo AWS CLI con chiavi di accesso e un token di sessione per consentirgli di accedere ai AWS servizi. Le seguenti istruzioni forniscono un modo rapido per configurare le chiavi e il token, ma se desideri istruzioni dettagliate, consulta [Configurazione del AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) nella *Guida per l'AWS Command Line Interface utente*.

1. Crea un utente IAM Identity Center, come segue:

   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/).

      (Potresti dover scegliere **Abilita** se non hai mai effettuato l'accesso a IAM Identity Center prima.)
**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:

      ```
      codecatalyst-eks-user
      ```

   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**, inserisci:

      ```
      codecatalyst-eks-user
      ```

   1. In **Cognome**, inserisci:

      ```
      codecatalyst-eks-user
      ```

   1. In **Nome visualizzato**, mantieni:

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   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 in un file di testo. Le informazioni di accesso sono costituite dall'URL del portale di AWS accesso, un nome utente e una password monouso.

   1. Scegli **Chiudi**.

1. Crea un set di autorizzazioni, come segue:

   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**, rimuovi `AdministratorAccess` e inserisci:

      ```
      codecatalyst-eks-permission-set
      ```

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

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

1. Assegna il set di autorizzazioni a`codecatalyst-eks-user`, come segue:

   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. `codecatalyst-eks-user`

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

   1. Seleziona la casella di controllo accanto a`codecatalyst-eks-permission-set`.

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

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

      Ora le hai assegnate `codecatalyst-eks-user` e `codecatalyst-eks-permission-set` Account AWS le hai assegnate insieme.

1. Le chiavi `codecatalyst-eks-user` di accesso e il token di sessione di Ottain, come segue:

   1. Assicurati di avere l'URL del portale di AWS accesso e il nome utente e la password monouso per`codecatalyst-eks-user`. In precedenza avreste dovuto copiare queste informazioni in un editor di testo.
**Nota**  
Se non disponi di queste informazioni, vai alla pagina dei `codecatalyst-eks-user` 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:
      + **Nome utente**:

        ```
        codecatalyst-eks-user
        ```
      + **Password**:

        *one-time-password*

   1. In **Imposta nuova password**, inserisci una nuova 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'`codecatalyst-eks-user`utente e il set di autorizzazioni.

   1. Successivamente`codecatalyst-eks-permission-set`, scegli Riga di **comando o accesso programmatico**.

   1. Copia i comandi al centro della pagina. Sono simili ai seguenti:

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... *session-token* dov'è una lunga stringa casuale.

1. Aggiungi le chiavi di accesso e il token di sessione a AWS CLI, come segue:

   1. Tornate al vostro ambiente di CodeCatalyst sviluppo.

   1. Al prompt del terminale, incolla i comandi che hai copiato. Premere Invio.

      Ora lo hai configurato AWS CLI con chiavi di accesso e un token di sessione. Ora puoi AWS CLI utilizzarlo per completare le attività richieste da questo tutorial.
**Importante**  
Se in qualsiasi momento durante questo tutorial visualizzi messaggi simili a:  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
O:  
`ExpiredToken: The security token included in the request is expired`  
... è perché la tua AWS CLI sessione è scaduta. In questo caso, *non* eseguire il `aws configure` comando. Utilizzate invece le istruzioni riportate nel passaggio 4 di questa procedura che inizia con `Obtain codecatalyst-eks-user's access key and session token` per aggiornare la sessione.

## Fase 2: creare un cluster Amazon EKS
<a name="deploy-tut-eks-cluster"></a>

In questa sezione, crei un cluster in Amazon EKS. Le istruzioni seguenti descrivono un modo rapido per creare il cluster utilizzando`eksctl`, ma se desideri istruzioni dettagliate, consulta:
+ [Guida introduttiva a eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) nella **Amazon EKS** User Guide

  or
+ Guida [introduttiva alla console e AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) nella **Amazon EKS User Guide** (questo argomento fornisce `kubectl` istruzioni per la creazione del cluster) 

**Nota**  
[I cluster privati](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) non sono supportati dall' CodeCatalyst integrazione con Amazon EKS.

**Prima di iniziare**

Assicurati di aver completato le seguenti attività sulla tua macchina di sviluppo:
+ Installata l'`eksctl`utilità.
+ Installata l'`kubectl`utilità.
+ L'ha installata AWS CLI e configurata con chiavi di accesso e un token di sessione.

Per informazioni su come completare queste attività, vedere[Passaggio 1: configura la tua macchina di sviluppo](#deploy-tut-eks-dev-env-create).

**Come creare un cluster**
**Importante**  
Non utilizzare l'interfaccia utente del servizio Amazon EKS per creare il cluster perché il cluster non verrà configurato correttamente. Usa l'`eksctl`utilità, come descritto nei passaggi seguenti.

1. Vai al tuo ambiente di sviluppo.

1. Crea un cluster e dei nodi:

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   Dove:
   + *codecatalyst-eks-cluster*viene sostituito con il nome che vuoi assegnare al cluster.
   + *us-west-2*viene sostituito dalla tua regione.

   Dopo 10-20 minuti, viene visualizzato un messaggio simile al seguente: 

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**Nota**  
Vedrai più `waiting for CloudFormation stack` messaggi durante la AWS creazione del cluster. Si tratta di un comportamento normale.

1. Verifica che il cluster sia stato creato correttamente:

   ```
   kubectl cluster-info
   ```

   Verrà visualizzato un messaggio simile al seguente, che indica l'avvenuta creazione del cluster:

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

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

In questa sezione, crei un repository di immagini privato in Amazon Elastic Container Registry (Amazon ECR). Questo repository memorizza l'immagine Docker per il tutorial.

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

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

1. Accedi al tuo ambiente di sviluppo.

1. Crea un repository vuoto in Amazon ECR:

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

   Sostituisci *codecatalyst-eks-image-repo* con il nome che desideri assegnare al repository Amazon ECR.

   Questo tutorial presuppone che tu abbia dato un nome al tuo repository. `codecatalyst-eks-image-repo`

1. Visualizza i dettagli del repository Amazon ECR:

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

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

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

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

In questa sezione, aggiungete i file sorgente dell'applicazione al vostro repository di origine ()`codecatalyst-eks-source-repository`. Sono costituiti da:
+ Un `index.html` file: mostra un messaggio «Hello, World\$1» messaggio nel browser.
+ Un Dockerfile: descrive l'immagine di base da utilizzare per l'immagine Docker e i comandi Docker da applicarvi.
+ Un `deployment.yaml` file: il manifesto di Kubernetes che definisce il servizio e la distribuzione Kubernetes. 

La struttura delle cartelle è la seguente:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

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

Il `index.html` file mostra un messaggio «Hello, World\$1» messaggio nel browser. 

**Per aggiungere il file index.html**

1. Vai al tuo ambiente di sviluppo.

1. In`codecatalyst-eks-source-repository`, crea una cartella chiamata`public-html`.

1. In`/public-html`, crea un file chiamato `index.html` con il seguente contenuto:

   ```
   <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. Alla riga di comando del terminale, digitate:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. Aggiungi, esegui il commit e invia:

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

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

### Dockerfile
<a name="deploy-tut-eks-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. In`codecatalyst-eks-source-repository`, crea un file chiamato `Dockerfile` con il seguente contenuto:

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

   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. Aggiungi, esegui il commit e invia:

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

   Il Dockerfile viene aggiunto al tuo repository.

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

In questa sezione, aggiungi un file al tuo repository. `deployment.yaml` Il `deployment.yaml` file è un manifesto di Kubernetes che definisce due tipi o *tipi* di risorse Kubernetes da eseguire: un «servizio» e una «distribuzione».
+ Il «servizio» implementa un sistema di bilanciamento del carico in Amazon EC2. Il sistema di bilanciamento del carico fornisce un URL pubblico con accesso a Internet e una porta standard (porta 80) che puoi utilizzare per accedere a «Hello, World\$1» applicazione. 
+ La «distribuzione» utilizza tre pod e ogni pod conterrà un contenitore Docker con il comando «Hello, World\$1» applicazione. I tre pod vengono distribuiti sui nodi creati al momento della creazione del cluster.

Il manifesto di questo tutorial è breve; tuttavia, un manifesto può includere qualsiasi tipo di risorsa Kubernetes, come pod, job, ingress e policy di rete. Inoltre, puoi utilizzare più file manifest se la distribuzione è complessa.

**Per aggiungere un file deployment.yaml**

1. In`codecatalyst-eks-source-repository`, crea una cartella chiamata. `Kubernetes`

1. In`/Kubernetes`, crea un file chiamato `deployment.yaml` con il seguente contenuto:

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. Aggiungi, esegui il commit e invia:

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   Il `deployment.yaml` file viene aggiunto al tuo repository in una cartella chiamata`Kubernetes`. 

Ora hai aggiunto tutti i tuoi file sorgente.

Prenditi un momento per ricontrollare il tuo lavoro e assicurati di aver inserito tutti i file nelle cartelle corrette. La struttura delle cartelle è la seguente:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## Fase 5: Creare AWS ruoli
<a name="deploy-tut-eks-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 del **cluster CodeCatalyst Deploy to Kubernetes** (nel flusso di lavoro) l'autorizzazione ad accedere al tuo account e ad Amazon EKS. 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, completa la seguente serie di procedure.

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

1. Vai al tuo ambiente di sviluppo.

1. Nella `Cloud9-long-string` directory, crea un file chiamato `codecatalyst-eks-trust-policy.json` con il seguente contenuto:

**2. Per creare la politica di compilazione per il ruolo di compilazione**
+ Nella `Cloud9-long-string` directory, create un file chiamato `codecatalyst-eks-build-policy.json` con il seguente contenuto:

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

****  

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

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

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

**3. Per creare la politica di distribuzione per il ruolo di distribuzione**
+ Nella `Cloud9-long-string` directory, create un file chiamato `codecatalyst-eks-deploy-policy.json` con il seguente contenuto:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

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

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

Ora hai aggiunto tre documenti di policy al tuo Dev Environment. La struttura delle cartelle ora è simile a questa:

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. Per aggiungere la politica di compilazione a AWS**

1. Nel terminale Dev Environment, inserisci:

   ```
   cd /projects
   ```

1. Inserisci:

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

1. Premere **Invio**.

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

**5. Per aggiungere la politica di distribuzione a AWS**

1. Inserisci:

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

1. Premere **Invio**.

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

**6. Per creare il ruolo di costruzione**

1. Inserisci: 

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

1. Premere **Invio**.

1. Inserisci:

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

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

1. Premere **Invio**.

1. Alla riga di comando del terminale, inserisci:

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

1. Premere **Invio**.

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

**7. Per creare il ruolo di distribuzione**

1. Inserisci:

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

1. Premere **Invio**.

1. Inserisci:

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

   Dove *arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy* viene sostituito dall'ARN della politica di distribuzione indicata in precedenza.

1. Premere **Invio**.

1. Inserisci:

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

1. Premere **Invio**.

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

Ora hai creato i ruoli di compilazione e distribuzione e li hai annotati. ARNs

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

In questo passaggio, aggiungi build role (`codecatalyst-eks-build-role`) e deploy role (`codecatalyst-eks-deploy-role`) a Account AWS quello che hai collegato al tuo spazio. In questo modo i ruoli sono disponibili per l'uso nel flusso di lavoro.

**Per aggiungere ruoli, build e deploy al tuo Account AWS**

1. Nella CodeCatalyst console, accedi al tuo spazio.

1. In alto, scegli **Impostazioni**.

1. Nel riquadro di navigazione, scegli **AWS Account**. Viene visualizzato un elenco di account.

1. Nella colonna **Amazon CodeCatalyst display name**, copia il nome visualizzato del Account AWS luogo in cui hai creato i ruoli di build e deploy. (Potrebbe essere un numero). Questo valore ti servirà in seguito, durante la creazione del flusso di lavoro.

1. Scegli il nome visualizzato.

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 i ruoli di compilazione e distribuzione e tutti gli altri ruoli IAM con una policy di fiducia che include i `codecatalyst-runner.amazonaws.com` principali di servizio. `codecatalyst.amazonaws.com`

1. Dall'elenco a discesa, aggiungi:
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**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. Torna alla CodeCatalyst console e aggiorna la pagina.

   I ruoli di compilazione e distribuzione dovrebbero ora apparire nei ruoli **IAM**.

   Questi ruoli sono ora disponibili per l'uso nei flussi CodeCatalyst di lavoro.

## Fase 7: Aggiornare il ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Devi aggiungere il ruolo di distribuzione che hai creato nel `ConfigMap` file Kubernetes [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) per consentire all'azione del cluster **Deploy to Kubernetes (nel tuo flusso di lavoro) la possibilità di accedere e interagire con il cluster**. È possibile utilizzare o eseguire questa attività. `eksctl` `kubectl`

**Per configurare il file Kubernetes ConfigMap usando eksctl**
+ Nel terminale Dev Environment, inserisci: 

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  Dove:
  + *codecatalyst-eks-cluster*viene sostituito con il nome del cluster Amazon EKS.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*viene sostituito dall'ARN del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles)
  +  *codecatalyst-eks-deploy-role*(accanto a`--username`) viene sostituito dal nome del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles)
**Nota**  
Se hai deciso di non creare un ruolo di distribuzione, sostituiscilo *codecatalyst-eks-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles).
  +  *us-west-2*viene sostituito con la tua regione.

  Per i dettagli su questo comando, consulta [Gestire gli utenti e i ruoli IAM](https://eksctl.io/usage/iam-identity-mappings/).

  Viene visualizzato un messaggio simile al seguente:

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**Per configurare il file Kubernetes ConfigMap usando kubectl**

1. Nel terminale Dev Environment, inserisci:

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   Il ConfigMap file viene visualizzato sullo schermo.

1. Aggiungi il testo in corsivo rosso:

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   Dove:
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*viene sostituito dall'ARN del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles) 
   +  *codecatalyst-eks-deploy-role*(accanto a`username:`) viene sostituito dal nome del ruolo di distribuzione in cui è stato creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles)
**Nota**  
Se hai deciso di non creare un ruolo di distribuzione, sostituiscilo *codecatalyst-eks-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles).

   Per i dettagli, consulta [Abilitazione dell'accesso principale IAM al tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) nella **Guida per l'utente di Amazon EKS**.

Ora hai assegnato al ruolo di distribuzione e, per estensione, all'azione **Deploy to Amazon EKS**, `system:masters` le autorizzazioni per il tuo cluster Kubernetes.

## Passaggio 8: creare ed eseguire un flusso di lavoro
<a name="deploy-tut-eks-workflow"></a>

In questo passaggio, crei un flusso di lavoro che prende i tuoi file sorgente, li crea in un'immagine Docker e quindi distribuisce l'immagine in tree pod nel tuo cluster Amazon EKS.

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 si invia una modifica al 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 anche `$IMAGE_TAG` le variabili `$REPOSITORY_URI` and nel `deployment.yaml` file con i valori corretti, quindi crea un elemento di output di questo file e di qualsiasi altro file nella cartella. `Kubernetes` In questo tutorial, l'unico file nella `Kubernetes` cartella è, `deployment.yaml` ma è possibile includere altri file. L'artefatto viene utilizzato come input per l'azione di distribuzione, che viene successiva.

  Per ulteriori informazioni sull'azione di creazione, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md)
+ A deploy action (`DeployToEKS`): al termine dell'azione di compilazione, l'azione deploy cerca l'artefatto di output generato dall'azione di compilazione (`Manifests`) e trova il `deployment.yaml` file al suo interno. L'azione segue quindi le istruzioni contenute nel `deployment.yaml` file per eseguire tre pod, ciascuno contenente un singolo «Hello, World\$1» Contenitore Docker: all'interno del tuo cluster Amazon EKS. 

**Come creare un flusso di lavoro**

1. Vai alla console. CodeCatalyst 

1. Vai al tuo progetto (`codecatalyst-eks-project`).

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

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

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

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

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

1. Elimina il codice di esempio YAML.

1. Aggiungi il seguente codice YAML per creare un nuovo file di definizione del flusso di lavoro:
**Nota**  
Per ulteriori informazioni sul file di definizione del flusso di lavoro, vedere. [Definizione YAML del flusso di lavoro](workflow-reference.md)
**Nota**  
Nel codice YAML che segue, puoi omettere le `Connections:` sezioni se lo 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 6: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-eks-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-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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 deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   Nel codice precedente, sostituisci:
   + Entrambe le istanze hanno *codecatalyst-eks-environment* il nome dell'ambiente in cui avete creato. [Prerequisiti](#deploy-tut-eks-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 6: Aggiungere AWS ruoli a CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*con il nome del ruolo di costruzione in cui hai creato[Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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-eks-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-eks-image-repo`
   + *codecatalyst-eks-deploy-role*con il nome del ruolo di distribuzione in cui hai creato. [Fase 5: Creare AWS ruoli](#deploy-tut-eks-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) in. *Riferimenti generali di AWS*
**Nota**  
Se hai deciso di non creare ruoli, build and deploy, sostituisci «*codecatalyst-eks-build-role*e» *codecatalyst-eks-deploy-role* con il nome del `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo. Per ulteriori informazioni su questo ruolo, consulta [Fase 5: Creare AWS ruoli](#deploy-tut-eks-roles).

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

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

1. Scegli **DeployToEKS** per vedere lo stato di avanzamento dell'implementazione.

   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 EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. A sinistra, in basso, scegli **Load Balancers**.

1. Seleziona il load balancer che è stato creato come parte della tua implementazione Kubernetes. **Se non sei sicuro di quale bilanciamento del carico scegliere, cerca i seguenti tag nella scheda Tag:**
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Con il bilanciamento del carico corretto selezionato, scegli la **scheda Descrizione**.

1. Copia e incolla il valore del **nome DNS** nella barra degli indirizzi del browser.

   Il messaggio «Hello, World\$1» nel browser viene visualizzata una pagina Web che indica che l'applicazione è stata distribuita correttamente.

## Passaggio 9: apporta una modifica ai file sorgente
<a name="deploy-tut-eks-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. Vai al tuo ambiente di sviluppo.

1. Al prompt del terminale, passa al repository dei sorgenti:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Recupera le ultime modifiche al flusso di lavoro:

   ```
   git pull
   ```

1. Aprire `codecatalyst-eks-source-repository/public-html/index.html`.

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

1. Aggiungi, conferma e invia:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   L'esecuzione di un flusso di lavoro viene avviata automaticamente.

1. (Facoltativo) Inserisci:

   ```
   git show HEAD
   ```

   Annota l'ID di commit per la `index.html` modifica. Questo ID di commit verrà taggato nell'immagine Docker che verrà distribuita dall'esecuzione del flusso di lavoro appena avviata.

1. Guarda lo stato di avanzamento della distribuzione:

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

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

   1. Scegliete **BuildBackend**ed **DeployToEKS** 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 EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. A sinistra, in basso, scegli **Load Balancers**.

   1. Seleziona il load balancer che è stato creato come parte della tua implementazione Kubernetes.

   1. Copia e incolla il valore del **nome DNS** nella barra degli indirizzi del browser.

      Il «Tutorial completo\$1» Nel browser viene visualizzata una pagina Web che indica che è stata implementata correttamente una nuova revisione dell'applicazione.

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 7 di questa procedura.

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

È necessario ripulire l'ambiente in modo da non addebitare inutilmente i costi delle risorse di archiviazione e di elaborazione utilizzate in questo tutorial.

**Per eliminare**

1. Elimina il tuo cluster:

   1. Nel terminale Dev Environment, inserisci:

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Dove:
     + *us-west-2*viene sostituito dalla tua regione.
     + *codecatalyst-eks-cluster*viene sostituito dal nome del cluster creato.

     Dopo 5-10 minuti, il cluster e le risorse associate vengono eliminati, inclusi, a titolo esemplificativo, CloudFormation stack, gruppi di nodi (in Amazon EC2) e sistemi di bilanciamento del carico.
**Importante**  
Se il `eksctl delete cluster` comando non funziona, potrebbe essere necessario aggiornare le credenziali o le credenziali. AWS `kubectl` Se non sei sicuro di quali credenziali aggiornare, aggiorna prima le credenziali. AWS Per aggiornare le credenziali, consulta. AWS [Come posso correggere gli errori «Impossibile individuare le credenziali» e "ExpiredToken"?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks) Per aggiornare le `kubectl` credenziali, consulta. [Come posso correggere gli errori «Impossibile connettersi al server»?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks)

1. Nella AWS console, esegui la pulizia come segue:

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

   1. In IAM Identity Center, elimina:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. In IAM, elimina:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. Nella CodeCatalyst console, pulisci come segue:

   1. Elimina`codecatalyst-eks-workflow`.

   1. Eliminare`codecatalyst-eks-environment`.

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

   1. Elimina il tuo ambiente di sviluppo.

   1. Elimina`codecatalyst-eks-project`.

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

# Aggiungere l'azione «Deploy to Kubernetes cluster»
<a name="deploy-action-eks-adding"></a>

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

**Prima di iniziare**

Prima di aggiungere l'azione **Deploy to Kubernetes cluster** al flusso di lavoro, devi aver preparato quanto segue:

**Suggerimento**  
Per configurare rapidamente questi prerequisiti, segui le istruzioni riportate in. [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md)
+ Un cluster Kubernetes in Amazon EKS. Per informazioni sui cluster, consulta i cluster [Amazon EKS nella Guida per](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) **l'utente di Amazon EKS**.
+ Almeno un Dockerfile che descrive come assemblare l'applicazione in un'immagine Docker. [Per ulteriori informazioni su Dockerfiles, consulta il riferimento a Dockerfile.](https://docs.docker.com/engine/reference/builder/)
+ *Almeno un file manifest Kubernetes, chiamato file di configurazione o *configurazione* nella documentazione di Kubernetes.* Per ulteriori informazioni, consulta [Gestione](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/) delle risorse nella documentazione di Kubernetes.
+ Un ruolo IAM che offre all'azione del cluster **Deploy to Kubernetes la possibilità di accedere e interagire con il cluster** Amazon EKS. Per ulteriori informazioni, consulta l'argomento [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) nella [Azione «Distribuisci su cluster Kubernetes» YAML](deploy-action-ref-eks.md).

  Dopo aver creato questo ruolo, devi aggiungerlo a:
  + Il tuo file Kubernetes ConfigMap . Per informazioni su come aggiungere un ruolo a un ConfigMap file, consulta la sezione [Abilitazione dell'accesso principale IAM al cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) nella **Amazon EKS User Guide**.
  + CodeCatalyst. Per informazioni su come aggiungere un ruolo IAM a CodeCatalyst, consulta[Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md).
+ Uno CodeCatalyst spazio, un progetto e un ambiente. Lo spazio e l'ambiente devono essere entrambi collegati all' AWS account in cui verrà distribuita l'applicazione. Per ulteriori informazioni, consultare [Creazione di uno spazio](spaces-create.md), [Creare un progetto vuoto in Amazon CodeCatalyst](projects-create.md#projects-create-empty) e [Implementazione in e Account AWS VPCs](deploy-environments.md).
+ Un repository di sorgenti supportato da. CodeCatalyst Il repository memorizza i file sorgente dell'applicazione, i Dockerfile e i manifesti di Kubernetes. Per ulteriori informazioni, consulta [Archivia e collabora sul codice con i repository di sorgenti in CodeCatalystArchivia e collabora sul codice con i repository di origine](source.md).

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

**Per aggiungere l'azione «Distribuisci al cluster Kubernetes» utilizzando l'editor visivo**

1. Apri CodeCatalyst la console [all'](https://codecatalyst.aws/)indirizzo 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 Kubernetes cluster** 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 Kubernetes** cluster. 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 aprire il relativo 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 cluster Kubernetes» YAML](deploy-action-ref-eks.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 Kubernetes cluster» utilizzando l'editor YAML**

1. Apri CodeCatalyst la console [all'](https://codecatalyst.aws/)indirizzo 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 Kubernetes cluster** 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 Kubernetes** cluster. 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 aprire il relativo 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 cluster Kubernetes» YAML](deploy-action-ref-eks.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 cluster Kubernetes»
<a name="deploy-action-eks-variables"></a>

L'azione **cluster Deploy to Kubernetes** 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  |  L'Amazon.com Resource Name (ARN) del cluster Amazon EKS su cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  piattaforma di distribuzione  |  Il nome della piattaforma di distribuzione. Codificato in. `AWS:EKS`  | 
|  metadati  |  Riservata. Metadati in formato JSON relativi al cluster distribuito durante l'esecuzione del flusso di lavoro.  | 
|  namespace  |  Lo spazio dei nomi Kubernetes in cui è stato distribuito il cluster. Ad esempio: `default`  | 
|  risorse  |  Riservata. Metadati in formato JSON relativi alle risorse distribuite durante l'esecuzione del flusso di lavoro.  | 
|  server  |  Il nome dell'endpoint del server API che puoi utilizzare per comunicare con il cluster utilizzando strumenti di gestione come. `kubectl` Per ulteriori informazioni sull'endpoint del servizio API, consulta [Amazon EKS Cluster Endpoint Access Control](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) nella **Amazon EKS User Guide**. Ad esempio: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# Azione «Distribuisci su cluster Kubernetes» YAML
<a name="deploy-action-ref-eks"></a>

**Di seguito è riportata la definizione YAML dell'azione del cluster Deploy to Kubernetes.** Per informazioni su come utilizzare questa azione, consulta. [Implementazione su Amazon EKS con un flusso di lavoro](deploy-action-eks.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.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-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: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.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: `DeployToKubernetesCluster_nn`.

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

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

(*DeployToKubernetesCluster*/**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/kubernetes-deploy@v1`.

**Interfaccia utente corrispondente: Workflow diagram/ DeployToKubernetesCluster \$1nn/ aws/kubernetes-deploy @v1 label**

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

(*DeployToKubernetesCluster*/**DependsOn**)

(Facoltativo)

Specificate un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente affinché questa azione possa essere eseguita.

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

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

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

(*DeployToKubernetesCluster*/**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.eks.computetype"></a>

(*DeployToKubernetesCluster*/Compute/**Type**)

(Richiesto [Compute](#deploy.action.eks.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.eks.computefleet"></a>

(*DeployToKubernetesCluster*/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.eks.timeout"></a>

(*DeployToKubernetesCluster*/**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.eks.environment"></a>

(*DeployToKubernetesCluster*/**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.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

(Richiesto se [Environment](#deploy.action.eks.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.eks.environment.connections"></a>

(*DeployToKubernetesCluster*/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.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Facoltativo)

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.eks.environment.connections.role"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

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

Specificate il nome del ruolo IAM a cui l'azione **cluster Deploy to Kubernetes** 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 autorizzazione:
**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": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**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:

Assicurati che questo ruolo sia aggiunto a:
+ Connessione al tuo account. Per ulteriori informazioni sull'aggiunta di un ruolo IAM alla connessione di un account, consulta[Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md).
+ Il tuo Kubernetes ConfigMap. Per ulteriori informazioni sull'aggiunta di un ruolo IAM a ConfigMap, consulta [Gestire gli utenti e i ruoli IAM nella documentazione](https://eksctl.io/usage/iam-identity-mappings/). `eksctl`

**Suggerimento**  
Vedi anche [Tutorial: distribuzione di un'applicazione su Amazon EKS](deploy-tut-eks.md) per istruzioni su come aggiungere un ruolo IAM alla connessione di un account e ConfigMap.

**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.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

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

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

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

**Interfaccia utente corrispondente: scheda Input**

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

(*DeployToKubernetesCluster*/Inputs/**Sources**)

(Richiesto se il file manifest è archiviato in un repository di origine)

Se il file o i file manifest di Kubernetes sono archiviati in un repository di origine, specifica l'etichetta di tale repository di origine. Attualmente, l'unica etichetta supportata è. `WorkflowSource`

Se i file manifest non sono contenuti in un repository di origine, devono 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.eks.inputs.artifacts"></a>

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

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

Se il file o i file manifest di Kubernetes sono contenuti in un artefatto generato da un'azione precedente, specifica quell'artefatto qui. Se i tuoi file manifest non sono contenuti in un artefatto, devono risiedere nel tuo 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.eks.configuration"></a>

(*DeployToKubernetesCluster*/**Configuration**)

(Obbligatorio)

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

Interfaccia utente corrispondente: scheda **Configurazione**

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Facoltativo)

Specificate lo spazio dei nomi Kubernetes in cui verrà distribuita l'applicazione Kubernetes. Utilizzalo `default` se non utilizzi namespace con il tuo cluster. Per ulteriori informazioni sugli spazi dei nomi, consulta [Suddivisione del cluster utilizzando gli spazi dei nomi Kubernetes nella documentazione di Kubernetes](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces).

Se ometti lo spazio dei `default` nomi, viene utilizzato il valore di.

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

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

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Obbligatorio)

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

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

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

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Obbligatorio)

Specificare il nome di un cluster Amazon EKS esistente. L'azione **Deploy to Kubernetes cluster** distribuirà l'applicazione containerizzata in questo cluster. Per ulteriori informazioni sui cluster Amazon EKS, consulta [Clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) nella **Amazon EKS User Guide**.

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

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Obbligatorio)

*Specificate il percorso dei file manifest di Kubernetes in formato YAML, denominati file di configurazione, file di *configurazione o semplicemente configurazioni nella documentazione* di *Kubernetes*.*

Se utilizzi più file manifest, inseriscili in un'unica cartella e fai riferimento a quella cartella. I file manifest vengono elaborati in ordine alfanumerico da Kubernetes, quindi assicurati di anteporre ai nomi dei file numeri o lettere crescenti per controllare l'ordine di elaborazione. Esempio:

`00-namespace.yaml`

`01-deployment.yaml`

Se i file manifest risiedono nel repository di origine, il percorso è relativo alla cartella principale del repository di origine. Se i file si trovano in un elemento di un'azione precedente del workflow, il percorso è relativo alla cartella principale dell'artefatto. 

Esempi:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

Non utilizzate caratteri jolly (). `*`

**Nota**  
I [grafici Helm](https://helm.sh/docs/topics/charts/) e i file [di personalizzazione](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/) non sono supportati.

Per ulteriori informazioni sui file manifest, consulta [Organizzazione delle configurazioni delle risorse](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations) nella documentazione di Kubernetes.

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

# Implementazione di uno stack CloudFormation
<a name="deploy-action-cfn"></a>

Questa sezione descrive come distribuire uno AWS CloudFormation stack utilizzando un flusso di lavoro. CodeCatalyst A tale scopo, è necessario aggiungere l'azione **Deploy CloudFormation stack** al flusso di lavoro. L'azione distribuisce una CloudFormation pila di risorse in AWS base a un modello fornito dall'utente. Il modello può essere un:
+ CloudFormation modello: per ulteriori informazioni, consulta [Lavorare con CloudFormation i modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html).
+ AWS SAM modello — Per ulteriori informazioni, vedere la [specifica AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html).
**Nota**  
Per utilizzare un AWS SAM modello, dovete prima impacchettare l' AWS SAM applicazione utilizzando l'`[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)`operazione. Per un tutorial che mostra come eseguire automaticamente questa confezione come parte di un CodeCatalyst flusso di lavoro Amazon, consulta[Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md).

Se lo stack esiste già, l'azione esegue l' CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)`operazione e quindi l'`[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)`operazione. L'azione attende quindi che le modifiche vengano distribuite e si contrassegna come riuscita o non riuscita, a seconda dei risultati.

Utilizza l'azione **Deploy CloudFormation stack** se disponi già di un AWS SAM modello CloudFormation or che contiene risorse che desideri distribuire, oppure prevedi di generarne uno automaticamente come parte di un'azione di [creazione](build-add-action.md) del flusso di lavoro utilizzando strumenti come e. AWS SAM [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)

**Non ci sono restrizioni sul modello che puoi utilizzare, qualunque cosa tu possa creare CloudFormation o utilizzare con l'azione AWS SAM Deploy stack. CloudFormation **

**Suggerimento**  
**Per un tutorial che mostra come distribuire un'applicazione serverless utilizzando l'azione Deploy stack, consulta. CloudFormation ** [Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md)

**Topics**
+ [Immagine di runtime utilizzata dall'azione 'Deploy stack' CloudFormation](#deploy-action-cfn-runtime)
+ [Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md)
+ [Aggiungere l'azione «Deploy stack» CloudFormation](deploy-action-cfn-adding.md)
+ [Configurazione dei rollback](deploy-consumption-enable-alarms.md)
+ [Variabili 'Deploy CloudFormation stack'](deploy-action-cfn-variables.md)
+ [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)

## Immagine di runtime utilizzata dall'azione 'Deploy stack' CloudFormation
<a name="deploy-action-cfn-runtime"></a>

[L'azione **Deploy CloudFormation stack** 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: Implementazione di un'applicazione serverless
<a name="deploy-tut-lambda"></a>

In questo tutorial, imparerai come creare, testare e distribuire un'applicazione serverless come stack utilizzando un flusso di lavoro. CloudFormation 

L'applicazione in questo tutorial è una semplice applicazione web che emette un messaggio «Hello World». È costituito da una AWS Lambda funzione e da un Amazon API Gateway e lo si crea utilizzando [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html), che è un'estensione di [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

**Topics**
+ [Prerequisiti](#deploy-tut-lambda-cfn-prereqs)
+ [Fase 1: Creare un archivio di sorgenti](#deploy-tut-lambda-cfn-source)
+ [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles)
+ [Fase 3: Aggiungere ruoli a AWS CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [Fase 4: creare un bucket Amazon S3](#deploy-tut-lambda-cfn-s3)
+ [Passaggio 5: Aggiungere i file sorgente](#deploy-tut-lambda-cfn-files)
+ [Passaggio 6: creare ed eseguire un flusso di lavoro](#deploy-tut-lambda-cfn-workflow)
+ [Fase 7: Apportare una modifica](#deploy-tut-lambda-cfn-change)
+ [Eliminazione](#deploy-tut-lambda-cfn-clean-up)

## Prerequisiti
<a name="deploy-tut-lambda-cfn-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-cfn-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-cfn-environment
  ```

  Configura questo ambiente come segue:
  + Scegli 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).

## Fase 1: Creare un archivio di sorgenti
<a name="deploy-tut-lambda-cfn-source"></a>

In questo passaggio, creerai un repository di origine in. CodeCatalyst Questo repository viene utilizzato per archiviare i file sorgente del tutorial, come il file della funzione Lambda. 

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. Nel CodeCatalyst 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-cfn-source-repository
   ```

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

Ora hai creato un repository chiamato. `codecatalyst-cfn-source-repository`

## Fase 2: Creare ruoli AWS
<a name="deploy-tut-lambda-cfn-roles"></a>

In questo passaggio, crei i seguenti ruoli AWS IAM:
+ **Ruolo Deploy**: concede all'azione CodeCatalyst **Deploy CloudFormation stack** l'autorizzazione ad accedere al tuo AWS account e al CloudFormation servizio su cui distribuirai la tua applicazione serverless. L'azione **Deploy CloudFormation stack** fa parte del tuo flusso di lavoro.
+ **Ruolo di compilazione**: concede all'azione di CodeCatalyst compilazione l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon S3 dove verrà archiviato il pacchetto di applicazioni serverless. L'azione di compilazione fa parte del tuo flusso di lavoro.
+ **Ruolo Stack**: concede CloudFormation l'autorizzazione a leggere e modificare le risorse specificate nel AWS SAM modello che fornirai in seguito. Concede inoltre l'autorizzazione a. CloudWatch

Per ulteriori informazioni sui ruoli IAM, consulta i [ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) nella *Guida per l'AWS Identity and Access Management utente*.

**Nota**  
Per risparmiare tempo, puoi creare un singolo ruolo, chiamato `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo, anziché i tre 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 tre ruoli elencati in precedenza.

**Nota**  
È richiesto anche un [ruolo di esecuzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html), ma non è necessario crearlo ora perché il `sam-template.yml` file lo crea automaticamente quando si esegue il flusso di lavoro nel passaggio 5.



**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. Scegli **Create Policy** (Crea policy).

   1. Scegliere la scheda **JSON**.

   1. Eliminare il codice esistente.

   1. Incolla il codice seguente:
**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-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**, cerca `codecatalyst-deploy-policy` e seleziona la relativa casella di controllo.

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

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

      ```
      codecatalyst-deploy-role
      ```

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

      ```
      CodeCatalyst deploy role
      ```

   1. Scegli **Crea ruolo**.

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

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-deploy-role`.

   1. Scegli il ruolo dall'elenco.

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

   1. In alto, copia il valore **ARN.**

   Ora hai creato il ruolo di distribuzione con le autorizzazioni appropriate e ottenuto il relativo ARN.

**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:
**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-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**, cerca `codecatalyst-build-policy` e seleziona la relativa casella di controllo.

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

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

      ```
      codecatalyst-build-role
      ```

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

      ```
      CodeCatalyst build role
      ```

   1. Scegli **Crea ruolo**.

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

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-build-role`).

   1. Scegli il ruolo dall'elenco.

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

   1. In alto, copia il valore **ARN.**

   Ora hai creato il ruolo di costruzione con le autorizzazioni appropriate e ottenuto il relativo ARN.<a name="deploy-tut-lambda-cfn-roles-stack"></a>

**Per creare un ruolo stack**

1. Accedi AWS utilizzando l'account in cui desideri distribuire lo stack.

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

1. Crea il ruolo dello stack come segue:

   1. Nel pannello di navigazione, seleziona **Roles** (Ruoli).

   1. Selezionare **Create role (Crea ruolo)**.

   1. Scegli un servizio in **Servizio AWS **.

   1. Nella sezione **Caso d'uso**, scegli **CloudFormation**dall'elenco a discesa.

   1. Seleziona il pulsante **CloudFormation**radio.

   1. In basso, scegli **Avanti**.

   1. Utilizzando la casella di ricerca, trova le seguenti politiche di autorizzazione, quindi seleziona le rispettive caselle di controllo.
**Nota**  
Se cerchi una politica e questa non viene visualizzata, assicurati di scegliere **Cancella filtri** e riprova.
      + **CloudWatchFullAccess**
      + **AWS CloudFormationFullAccess**
      + **IAMFullAccesso**
      + **AWS Lambda\$1 FullAccess**
      + **APIGatewayAmministratore Amazon**
      + **Amazon S3 FullAccess**
      + **AmazonEC2ContainerRegistryFullAccess**

      La prima policy consente l'accesso per CloudWatch abilitare i rollback dello stack quando si verifica un allarme.

      Le politiche rimanenti consentono di accedere AWS SAM ai servizi e alle risorse dello stack che verrà distribuito in questo tutorial. *Per ulteriori informazioni, consulta [Autorizzazioni nella Guida](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html) per gli AWS Serverless Application Model sviluppatori.*

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

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

      ```
      codecatalyst-stack-role
      ```

   1. Scegli **Crea ruolo**.

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

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

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

   1. Scegli il ruolo dall'elenco.

   1. Nella sezione **Riepilogo**, copia il valore **ARN.** perché sarà necessaria in seguito.

   Ora hai creato il ruolo stack con le autorizzazioni appropriate e ne hai ottenuto l'ARN.

## Fase 3: Aggiungere ruoli a AWS CodeCatalyst
<a name="deploy-tut-lambda-cfn-roles-add"></a>

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

**Nota**  
Non è necessario aggiungere lo stack role (`codecatalyst-stack-role`) alla connessione. Questo perché il ruolo stack viene utilizzato da *CloudFormation*(non CodeCatalyst), *dopo* che è già stata stabilita una connessione tra CodeCatalyst e AWS utilizzando il ruolo deploy. Poiché il ruolo stack non viene utilizzato per accedere CodeCatalyst a AWS, non è necessario che sia associato a una connessione all'account.

**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-build-role`, scegli e scegli Aggiungi ruolo.**

1. Scegli **Aggiungi ruolo IAM**, scegli **Aggiungi un ruolo esistente che hai creato in IAM** e, nell'elenco a discesa, scegli. `codecatalyst-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 4: creare un bucket Amazon S3
<a name="deploy-tut-lambda-cfn-s3"></a>

In questa fase, crei un bucket Amazon S3 in cui archiviare il file.zip del pacchetto di distribuzione dell'applicazione serverless.

**Come creare un bucket Amazon S3.**

1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nel riquadro principale, scegli **Crea bucket**.

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

   ```
   codecatalyst-cfn-s3-bucket
   ```

1. In **AWS Region (Regione)**, scegliere una Regione. Questo tutorial presuppone che tu abbia scelto **US West (Oregon) us-west-2**. Per informazioni sulle regioni supportate da Amazon S3, consulta gli [endpoint e le quote di Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) nel. *Riferimenti generali di AWS*

1. **Nella parte inferiore della pagina, scegli Crea bucket.**

Ora hai creato un bucket chiamato **codecatalyst-cfn-s3-bucket** nella regione us-west-2 degli Stati Uniti occidentali (Oregon).

## Passaggio 5: Aggiungere i file sorgente
<a name="deploy-tut-lambda-cfn-files"></a>

In questo passaggio, aggiungi diversi file sorgente dell'applicazione al tuo repository CodeCatalyst di origine. La `hello-world` cartella contiene i file dell'applicazione che distribuirete. La `tests` cartella contiene i test unitari. La struttura delle cartelle è la seguente:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

### file.npmignore
<a name="deploy-tut-lambda-cfn-files-npmignore"></a>

Il `.npmignore` file indica quali file e cartelle npm deve escludere dal pacchetto dell'applicazione. In questo tutorial, npm esclude la `tests` cartella perché non fa parte dell'applicazione.

**Per aggiungere il file.npmignore**

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

1. Scegli il tuo progetto, `codecatalyst-cfn-project`

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

1. Dall'elenco dei repository di origine, scegli il tuo repository,. `codecatalyst-cfn-source-repository` 

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

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

   ```
   .npmignore
   ```

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

   ```
   tests/*
   ```

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

   Ora hai creato un file chiamato `.npmignore` nella radice del tuo repository.

### file package.json
<a name="deploy-tut-lambda-cfn-files-package-json"></a>

Il `package.json` file contiene importanti metadati sul progetto Node, come il nome del progetto, il numero di versione, la descrizione, le dipendenze e altri dettagli che descrivono come interagire ed eseguire l'applicazione.

`package.json`In questo tutorial sono inclusi un elenco di dipendenze e uno script. `test` Lo script di test esegue le seguenti operazioni:
+ Utilizzando [mocha](https://mochajs.org/), lo script di test esegue i test unitari specificati in `hello-world/tests/unit/` e scrive i risultati in un `junit.xml` file utilizzando il reporter [xunit]().
+ [Utilizzando [Istanbul (nyc)](https://istanbul.js.org/), lo script di test genera un rapporto sulla copertura del codice (`clover.xml`) utilizzando il clover reporter.](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html) Per ulteriori informazioni, consulta [Usare reporter alternativi](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover) nella documentazione di Istanbul.

**Per aggiungere il file package.json**

1. **Nel tuo repository, in **File, scegli Crea file**.**

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

   ```
   package.json
   ```

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

   ```
   {
     "name": "hello_world",
     "version": "1.0.0",
     "description": "hello world sample for NodeJS",
     "main": "app.js",
     "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
     "author": "SAM CLI",
     "license": "MIT",
     "dependencies": {
       "axios": "^0.21.1",
       "nyc": "^15.1.0"
     },
     "scripts": {
       "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
     },
     "devDependencies": {
       "aws-sdk": "^2.815.0",
       "chai": "^4.2.0",
       "mocha": "^8.2.1"
     }
   }
   ```

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

   Ora hai aggiunto un file chiamato `package.json` alla radice del repository.

### file sam-template.yml
<a name="deploy-tut-lambda-cfn-files-sam-template-yml"></a>

Il `sam-template.yml` file contiene le istruzioni per implementare la funzione Lambda e API Gateway e configurarli insieme. Segue la specifica del [AWS Serverless Application Model modello, che estende la specifica](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) del CloudFormation modello.

In questo tutorial utilizzi un AWS SAM modello invece di un CloudFormation modello normale perché AWS SAM offre un utile tipo di risorsa [AWS: :Serverless: :Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html). Questo tipo esegue molte behind-the-scenes configurazioni che normalmente è necessario scrivere per utilizzare la sintassi di base. CloudFormation Ad esempio, `AWS::Serverless::Function` crea una funzione Lambda, un ruolo di esecuzione Lambda e mappature delle sorgenti degli eventi che avviano la funzione. Devi codificare tutto questo se vuoi scriverlo usando basic. CloudFormation

Sebbene questo tutorial utilizzi un modello già scritto, puoi generarne uno come parte del tuo flusso di lavoro utilizzando un'azione di compilazione. Per ulteriori informazioni, consulta [Implementazione di uno stack CloudFormation](deploy-action-cfn.md).

**Per aggiungere il file sam-template.yml**

1. ****Nel tuo repository, in File, scegli Crea file.****

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

   ```
   sam-template.yml
   ```

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

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: >
     serverless-api
   
     Sample SAM Template for serverless-api
     
   # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
   Globals:
     Function:
       Timeout: 3
   
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
       Properties:
         CodeUri: hello-world/
         Handler: app.lambdaHandler
         Runtime: nodejs12.x
         Events:
           HelloWorld:
             Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
             Properties:
               Path: /hello
               Method: get
   
   Outputs:
     # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
     # Find out about other implicit resources you can reference within AWS SAM at
     # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
     HelloWorldApi:
       Description: "API Gateway endpoint URL for the Hello World function"
       Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
     HelloWorldFunction:
       Description: "Hello World Lambda function ARN"
       Value: !GetAtt HelloWorldFunction.Arn
     HelloWorldFunctionIamRole:
       Description: "Implicit Lambda execution role created for the Hello World function"
       Value: !GetAtt HelloWorldFunctionRole.Arn
   ```

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

   Ora hai aggiunto un file chiamato `sam-template.yml` nella cartella principale del tuo repository.

### file setup-sam.sh
<a name="deploy-tut-lambda-cfn-files-setup-sam"></a>

Il `setup-sam.sh` file contiene le istruzioni per scaricare e installare l'utilità AWS SAM CLI. Il flusso di lavoro utilizza questa utilità per impacchettare il `hello-world` codice sorgente.

**Per aggiungere il file setup-sam.sh**

1. Nel tuo repository, in **File**, scegli **Crea file**.

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

   ```
   setup-sam.sh
   ```

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

   ```
   #!/usr/bin/env bash
   echo "Setting up sam"
   
   yum install unzip -y
   
   curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
   unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
   
   ./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
   ```

   Nel codice precedente, sostituiscilo *us-west-2* con la tua AWS regione.

1. Scegli **Commit**, quindi scegli nuovamente **Commit**.

   Ora hai aggiunto un file chiamato `setup-sam.sh` alla radice del repository.

### file app.js
<a name="deploy-tut-lambda-cfn-files-app-js"></a>

`app.js`Contiene il codice della funzione Lambda. In questo tutorial, il codice restituisce il testo`hello world`.

**Per aggiungere il file app.js**

1. Nel tuo repository, in **File**, scegli **Crea file**.

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

   ```
   hello-world/app.js
   ```

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

   ```
   // const axios = require('axios')
   // const url = 'http://checkip.amazonaws.com/';
   let response;
   
   /**
    *
    * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
    * @param {Object} event - API Gateway Lambda Proxy Input Format
    *
    * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
    * @param {Object} context
    *
    * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
    * @returns {Object} object - API Gateway Lambda Proxy Output Format
    * 
    */
   exports.lambdaHandler = async (event, context) => {
       try {
           // const ret = await axios(url);
           response = {
               'statusCode': 200,
               'body': JSON.stringify({
                   message: 'hello world',
                   // location: ret.data.trim()
               })
           }
       } catch (err) {
           console.log(err);
           return err;
       }
   
       return response
   };
   ```

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

   Ora hai creato una cartella chiamata `hello-world` e un file chiamato`app.js`.

### file test-handler.js
<a name="deploy-tut-lambda-cfn-files-test-handler-js"></a>

Il `test-handler.js` file contiene test unitari per la funzione Lambda.

**Per aggiungere il file test-handler.js**

1. Nel tuo repository, in **File**, scegli **Crea file**.

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

   ```
   hello-world/tests/unit/test-handler.js
   ```

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

   ```
   'use strict';
   
   const app = require('../../app.js');
   const chai = require('chai');
   const expect = chai.expect;
   var event, context;
   
   describe('Tests index', function () {
       it('verifies successful response', async () => {
           const result = await app.lambdaHandler(event, context)
   
           expect(result).to.be.an('object');
           expect(result.statusCode).to.equal(200);
           expect(result.body).to.be.an('string');
   
           let response = JSON.parse(result.body);
   
           expect(response).to.be.an('object');
           expect(response.message).to.be.equal("hello world");
           // expect(response.location).to.be.an("string");
       });
   });
   ```

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

   Ora hai aggiunto un file chiamato `test-handler.js` sotto la `hello-world/tests/unit` cartella.

Ora hai aggiunto tutti i tuoi file sorgente.

Prenditi un momento per ricontrollare il tuo lavoro e assicurati di aver inserito tutti i file nelle cartelle corrette. La struttura delle cartelle è la seguente:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

## Passaggio 6: creare ed eseguire un flusso di lavoro
<a name="deploy-tut-lambda-cfn-workflow"></a>

In questo passaggio, crei un flusso di lavoro che impacchetta il codice sorgente Lambda e lo distribuisce. 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 test (`Test`): al momento del trigger, questa azione installa il [gestore di pacchetti Node (npm)](https://www.npmjs.com/), quindi esegue il comando. `npm run test` Questo comando dice a npm di eseguire lo `test` script definito nel file. `package.json` Lo `test` script, a sua volta, esegue gli unit test e genera due report: un test report (`junit.xml`) e un rapporto sulla copertura del codice (`clover.xml`). Per ulteriori informazioni, consulta [file package.json](#deploy-tut-lambda-cfn-files-package-json).

  Successivamente, l'azione di test trasforma i report XML in CodeCatalyst report e li visualizza nella CodeCatalyst console, nella scheda **Report** dell'azione di test.

  Per ulteriori informazioni sull'azione di test, vedere[Test con flussi di lavoroTest con flussi di lavoro](test-workflow-actions.md).
+ Un'azione di compilazione (`BuildBackend`): al termine dell'azione di test, l'azione di compilazione scarica e installa la AWS SAM CLI, impacchetta `hello-world` il codice sorgente e copia il pacchetto nel bucket Amazon S3, dove il servizio Lambda prevede che si trovi. L'azione genera anche un nuovo file AWS SAM modello chiamato `sam-template-packaged.yml` e lo inserisce in un elemento di output chiamato. `buildArtifact`

  Per ulteriori informazioni sull'azione di compilazione, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md)
+ A deploy action (`DeployCloudFormationStack`): al termine dell'azione di compilazione, l'azione deploy cerca l'artefatto di output generato dall'azione di compilazione (`buildArtifact`), trova il AWS SAM modello al suo interno e quindi esegue il modello. Il AWS SAM modello crea uno stack che distribuisce l'applicazione serverless.

**Come creare un flusso di lavoro**

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

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

1. Per **Source repository**, scegli`codecatalyst-cfn-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 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-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-cfn-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main   
   Actions:
     Test:
       Identifier: aws/managed-test@v1
       Inputs:
         Sources:
           - WorkflowSource
       Outputs:
         Reports:
           CoverageReport:
             Format: CLOVERXML
             IncludePaths:
               - "coverage/*"
           TestReport:
             Format: JUNITXML
             IncludePaths:
               - junit.xml
       Configuration:
         Steps:
           - Run: npm install
           - Run: npm run test  
     BuildBackend:
       Identifier: aws/build@v1
       DependsOn:
         - Test
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-build-role
       Inputs:
         Sources:
           - WorkflowSource
       Configuration: 
         Steps:
           - Run: . ./setup-sam.sh
           - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
       Outputs:
         Artifacts:
           - Name: buildArtifact
             Files:
               - "**/*"
     DeployCloudFormationStack:
       Identifier: aws/cfn-deploy@v1
       DependsOn: 
         - BuildBackend
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-deploy-role
       Inputs:
         Artifacts:
           - buildArtifact
         Sources: []
       Configuration:
         name: codecatalyst-cfn-stack
         region: us-west-2
         role-arn: arn:aws:iam::111122223333:role/StackRole
         template: ./sam-template-packaged.yml
         capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
   ```

   Nel codice precedente, sostituisci:
   + Entrambe le istanze *codecatalyst-cfn-environment* con il nome dell'ambiente.
   + 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 3: Aggiungere ruoli a AWS CodeCatalyst](#deploy-tut-lambda-cfn-roles-add).
   + *codecatalyst-build-role*con il nome del ruolo di build in cui hai creato[Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles).
   + *codecatalyst-cfn-s3-bucket*con il nome del bucket Amazon S3 in cui hai creato. [Fase 4: creare un bucket Amazon S3](#deploy-tut-lambda-cfn-s3)
   + Entrambe le istanze sono nella regione in cui risiede il bucket Amazon S3 (prima istanza) e in cui verrà distribuito lo stack (seconda istanza). *us-west-2* Queste regioni possono essere diverse. Questo tutorial presuppone che entrambe le regioni siano impostate su. `us-west-2` Per informazioni dettagliate sulle regioni supportate da Amazon S3 e CloudFormation, consulta [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) nel. *Riferimenti generali di AWS*
   + *codecatalyst-deploy-role*con il nome del ruolo di distribuzione in cui hai creato. [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles)
   + *codecatalyst-cfn-environment*con il nome dell'ambiente in [Prerequisiti](#deploy-tut-lambda-cfn-prereqs) cui hai creato.
   + *arn:aws:iam::111122223333:role/StackRole*con l'Amazon Resource Name (ARN) del ruolo stack in cui hai creato. [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles)
**Nota**  
Se avete deciso di non creare ruoli di compilazione, distribuzione e impilamento *codecatalyst-build-role**codecatalyst-deploy-role*, sostituiteli e *arn:aws:iam::111122223333:role/StackRole* inserite il nome o l'ARN del ruolo. `CodeCatalystWorkflowDevelopmentRole-spaceName` Per ulteriori informazioni su questo ruolo, consulta [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles).

   Per informazioni sulle proprietà del codice mostrato in precedenza, consulta la. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)

1. (Facoltativo) Scegliete **Convalida** per assicurarvi 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 **nome del file Workflow**, mantenete il valore predefinito,`codecatalyst-cfn-workflow`.

   1. Per il **messaggio** di conferma, inserisci:

      ```
      add initial workflow file
      ```

   1. Per **Repository**, scegli **codecatalyst-cfn-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 `codecatalyst-cfn-workflow.yaml` file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro.

**Per visualizzare il flusso di lavoro in corso**

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

1. Scegli il flusso di lavoro che hai appena creato:. `codecatalyst-cfn-workflow`

1. Scegli la scheda **Esecuzioni**.

1. Nella colonna **Run ID**, scegli l'ID di esecuzione.

1. Scegli **Test** per vedere l'avanzamento dei test.

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

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

1. Al termine dell'**DeployCloudFormationStack**azione, procedi come segue:
   + Se l'esecuzione del flusso di lavoro è riuscita, passate alla procedura successiva.
   + Se l'esecuzione del flusso di lavoro non è riuscita durante il **test** o **BuildBackend**l'azione, scegli **Registri** per risolvere il problema.
   + **Se l'esecuzione del flusso di lavoro non è riuscita nell'**DeployCloudFormationStack**azione, scegli l'azione di distribuzione, quindi scegli la scheda Riepilogo.** Scorri fino alla sezione **CloudFormation degli eventi** per visualizzare il messaggio di errore dettagliato. Se si è verificato un rollback, elimina lo `codecatalyst-cfn-stack` stack tramite la CloudFormation console AWS prima di eseguire nuovamente il flusso di lavoro.

**Per verificare la distribuzione**

1. Dopo una distribuzione riuscita, scegli **Variabili (7)** dalla barra dei menu orizzontale in alto. (Non scegliete **Variabili** nel riquadro a destra).

1. Successivamente **HelloWorldApi**, incolla l'`https://`URL in un browser.

   Viene visualizzato un messaggio JSON **hello world** dalla funzione Lambda, che indica che il flusso di lavoro ha distribuito e configurato correttamente la funzione Lambda e l'API Gateway.
**Suggerimento**  
È possibile CodeCatalyst visualizzare questo URL nel diagramma del flusso di lavoro con alcune piccole configurazioni. Per ulteriori informazioni, consulta [Visualizzazione dell'URL dell'app nel diagramma del flusso di lavoro](deploy-app-url.md).

**Per verificare i risultati dei test unitari e la copertura del codice**

1. Nel diagramma del flusso di lavoro, scegli **Test**, quindi scegli **Report**.

1. Scegliete di **TestReport**visualizzare i risultati del test unitario o scegliete di **CoverageReport**visualizzare i dettagli della copertura del codice dei file da testare, in questo caso, `app.js` e`test-handler.js`.

**Per verificare le risorse distribuite**

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

1. Osserva l'**codecatalyst-cfn-stack**API creata dal AWS SAM modello. Il nome dell'API deriva dal `Configuration/name` valore nel file di definizione del flusso di lavoro (`codecatalyst-cfn-workflow.yaml`).

1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

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

1. Scegli la tua funzione Lambda,. `codecatalyst-cfn-stack-HelloWorldFunction-string`

1. Puoi vedere come l'API Gateway funge da trigger per la funzione. Questa integrazione è stata configurata automaticamente in base al tipo di AWS SAM `AWS::Serverless::Function` risorsa.

## Fase 7: Apportare una modifica
<a name="deploy-tut-lambda-cfn-change"></a>

In questo passaggio, apporti una modifica al codice sorgente Lambda e la esegui il commit. Questo commit avvia l'esecuzione di un nuovo flusso di lavoro. Questa esecuzione implementa la nuova funzione Lambda in uno schema blu-verde che utilizza la configurazione di spostamento del traffico predefinita specificata nella console Lambda.

**Per apportare una modifica alla sorgente Lambda**

1. In CodeCatalyst, accedi al tuo progetto.

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

1. Scegli il tuo repository `codecatalyst-cfn-source-repository` di origine.

1. Cambia il file dell'applicazione:

   1. Scegliere la cartella `hello-world`.

   1. Scegli il `app.js` file.

   1. Scegli **Modifica**.

   1. Sulla riga 23, cambia `hello world` in**Tutorial complete\$1**.

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

      Il commit avvia l'esecuzione di un flusso di lavoro. Questa esecuzione avrà esito negativo perché non hai aggiornato gli unit test per riflettere la modifica del nome.

1. Aggiorna gli unit test:

   1. Scegli `hello-world\tests\unit\test-handler.js`.

   1. Scegli **Modifica**.

   1. Sulla riga 19, passare `hello world` a**Tutorial complete\$1**.

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

      Il commit provoca l'avvio di un altro workflow. L'esecuzione avrà esito positivo.

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

1. **Scegli`codecatalyst-cfn-workflow`, quindi scegli Esecuzioni.**

1. Scegli l'ID di esecuzione dell'ultima esecuzione. Dovrebbe essere ancora in corso.

1. Scegli **Test **BuildBackend****, e **DeployCloudFormationStack**per vedere l'avanzamento del flusso di lavoro viene eseguito.

1. Al termine del flusso di lavoro, scegli **Variabili (7)** nella parte superiore.

1. Successivamente **HelloWorldApi**, incolla l'`https://`URL in un browser.

   Nel browser viene visualizzato un `Tutorial complete!` messaggio che indica che la nuova applicazione è stata distribuita correttamente.

## Eliminazione
<a name="deploy-tut-lambda-cfn-clean-up"></a>

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

**Per pulire la CodeCatalyst console**

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

1. Elimina`codecatalyst-cfn-workflow`.

1. Eliminare`codecatalyst-cfn-environment`.

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

1. Eliminare`codecatalyst-cfn-project`.

**Per pulire in Console di gestione AWS**

1. Effettuare CloudFormation la pulizia nel modo seguente:

   1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)

   1. Eliminare il `codecatalyst-cfn-stack`.

      L'eliminazione dello stack rimuove tutte le risorse del tutorial dai servizi API Gateway e Lambda.

1. Esegui la pulizia in Amazon S3, come segue:

   1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

   1. Seleziona `codecatalyst-cfn-s3-bucket`.

   1. Elimina il contenuto del bucket.

   1. Elimina il bucket.

1. Esegui la pulizia in IAM, come segue:

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

   1. Eliminare il `codecatalyst-deploy-policy`.

   1. Eliminare il `codecatalyst-build-policy`.

   1. Eliminare il `codecatalyst-stack-policy`.

   1. Eliminare il `codecatalyst-deploy-role`.

   1. Eliminare il `codecatalyst-build-role`.

   1. Eliminare il `codecatalyst-stack-role`.

In questo tutorial, hai imparato a distribuire un'applicazione serverless come CloudFormation stack utilizzando un CodeCatalyst flusso di lavoro e un'azione ** CloudFormation Deploy** stack.

# Aggiungere l'azione «Deploy stack» CloudFormation
<a name="deploy-action-cfn-adding"></a>

Utilizza le seguenti istruzioni per aggiungere l'azione **Deploy stack al tuo flusso di lavoro CloudFormation **. 

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

**Per aggiungere l'azione 'Deploy CloudFormation stack' utilizzando l'editor visuale**

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 **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 CloudFormation stack** 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 stack. CloudFormation ** 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, vedi. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.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 CloudFormation stack' 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 CloudFormation stack** 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 stack. CloudFormation ** 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 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.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.**

------

# Configurazione dei rollback
<a name="deploy-consumption-enable-alarms"></a>

Per impostazione predefinita, se l'azione **Deploy CloudFormation stack** fallisce, lo stack CloudFormation verrà ripristinato all'ultimo stato stabile conosciuto. Puoi modificare il comportamento in modo che i rollback si verifichino non solo quando l'azione fallisce, ma anche quando si verifica uno specifico CloudWatch allarme Amazon. Per ulteriori informazioni sugli CloudWatch allarmi, consulta [Using Amazon CloudWatch alarms](https://docs.aws.amazon.com/) nella *Amazon CloudWatch User* Guide.

Puoi anche modificare il comportamento predefinito in modo da CloudFormation non ripristinare lo stack quando l'azione fallisce. 

Utilizza le seguenti istruzioni per configurare i rollback.

**Nota**  
Non è possibile avviare un rollback manualmente.

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

**Prima di iniziare**

1. Assicurati di disporre di un [flusso di lavoro](workflow.md) che includa un'azione **Deploy CloudFormation stack** funzionante. Per ulteriori informazioni, consulta [Implementazione di uno stack CloudFormation](deploy-action-cfn.md).

1. Nel ruolo specificato nel campo **Stack role - opzionale** dell'azione **Deploy CloudFormation stack**, assicurati di includere l'autorizzazione. **CloudWatchFullAccess** Per informazioni sulla creazione di questo ruolo con le autorizzazioni appropriate, consulta. [Fase 2: Creare ruoli AWS](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles)

**Per configurare gli allarmi di rollback per l'azione «Deploy stack» CloudFormation**

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 **Visual**.

1. Scegli la tua **azione Deploy CloudFormation stack**.

1. **Nel riquadro dei dettagli, scegli Configurazione.**

1. In basso, espandi **Avanzate**.

1. In **Monitora allarme ARNs**, scegli **Aggiungi allarme**.

1. Inserisci le informazioni nei seguenti campi.
   + **Allarme ARN**

     Specificare l'Amazon Resource Name (ARN) di un CloudWatch allarme Amazon da utilizzare come trigger di rollback. Ad esempio, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Puoi avere un massimo di cinque trigger di rollback.
**Nota**  
Se specifichi un ARN di CloudWatch allarme, dovrai anche configurare autorizzazioni aggiuntive per abilitare l'azione di accesso. CloudWatch Per ulteriori informazioni, consulta [Configurazione dei rollback](#deploy-consumption-enable-alarms).
   + **Tempo di monitoraggio**

     Specificare un periodo di tempo, da 0 a 180 minuti, durante il quale CloudFormation monitorare gli allarmi specificati. Il monitoraggio inizia *dopo che* tutte le risorse dello stack sono state distribuite. Se l'allarme si verifica entro il periodo di monitoraggio specificato, l'implementazione fallisce e CloudFormation ripristina l'intera operazione dello stack.

     Impostazione predefinita: 0. CloudFormation monitora gli allarmi solo mentre le risorse dello stack vengono distribuite, non dopo.

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

**Per configurare i trigger di rollback per l'azione «Deploy stack» CloudFormation**

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 di un flusso di lavoro che include l'azione ** CloudFormation Deploy** stack. È possibile 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. Aggiungi le `monitor-timeout-in-minutes` proprietà `monitor-alarm-arns` and nel codice YAML per aggiungere i trigger di rollback. Per una spiegazione di ciascuna proprietà, vedere. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)

1. Nel ruolo specificato nella `role-arn` proprietà dell'azione **Deploy CloudFormation stack**, assicurati di includere l'**CloudWatchFullAccess**autorizzazione. Per informazioni sulla creazione di questo ruolo con le autorizzazioni appropriate, consulta. [Fase 2: Creare ruoli AWS](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles)

------

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

**Per disattivare i rollback per l'azione 'Deploy stack' CloudFormation**

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 di un flusso di lavoro che include l'azione ** CloudFormation Deploy** stack. È possibile 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. Scegli la tua **azione Deploy CloudFormation stack**.

1. **Nel riquadro dei dettagli, scegli Configurazione.**

1. In basso, espandi **Avanzate**.

1. Attiva **Disabilita il rollback.**

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

**Per disattivare i rollback per l'azione «Deploy stack» CloudFormation**

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 di un flusso di lavoro che include l'azione ** CloudFormation Deploy** stack. È possibile 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. Aggiungi la `disable-rollback: 1` proprietà nel codice YAML per interrompere i rollback. Per una spiegazione di questa proprietà, vedere. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)

------

# Variabili 'Deploy CloudFormation stack'
<a name="deploy-action-cfn-variables"></a>

L'azione **Deploy CloudFormation stack** 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 | 
| --- | --- | 
|  piattaforma di distribuzione  |  Il nome della piattaforma di distribuzione. Codificato in. `AWS:CloudFormation`  | 
|  region  |  Il codice regionale su Regione AWS cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `us-west-2`  | 
|  stack-id  |  L'Amazon Resource Name (ARN) dello stack distribuito. Ad esempio: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 

# Azione 'Implementa CloudFormation stack' YAML
<a name="deploy-action-ref-cfn"></a>

Di seguito è riportata la definizione YAML dell'azione ** CloudFormation Deploy** stack. Per informazioni su come utilizzare questa azione, consulta. [Implementazione di uno stack CloudFormation](deploy-action-cfn.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.    
  DeployCloudFormationStack:  
    Identifier: aws/cfn-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: DeployRole
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - CloudFormation-artifact
    Configuration:
      name: stack-name
      region: us-west-2
      template: template-path
      role-arn: arn:aws:iam::123456789012:role/StackRole        
      capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
      parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
      no-execute-changeset: 1|0
      fail-on-empty-changeset: 1|0
      disable-rollback: 1|0
      termination-protection: 1|0
      timeout-in-minutes: minutes
      notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
      monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
      monitor-timeout-in-minutes: minutes       
      tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```

## DeployCloudFormationStack
<a name="deploy.action.cfn.deploycloudformationstack"></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: `DeployCloudFormationStack_nn`.

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

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

(*DeployCloudFormationStack*/**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/cfn-deploy@v1`.

**Interfaccia utente corrispondente: Workflow diagram/ DeployCloudFormationStack \$1nn/ aws/cfn-deploy @v1 label**

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

(*DeployCloudFormationStack*/**DependsOn**)

(Facoltativo)

Specificate un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente affinché questa azione venga eseguita.

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.cfn.computename"></a>

(*DeployCloudFormationStack*/**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.cfn.computetype"></a>

(*DeployCloudFormationStack*/Compute/**Type**)

(Obbligatorio se [Compute](#deploy.action.cfn.computename) 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.cfn.computefleet"></a>

(*DeployCloudFormationStack*/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.cfn.timeout"></a>

(*DeployCloudFormationStack*/**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** in minuti - opzionale

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

(*DeployCloudFormationStack*/**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.cfn.environment.name"></a>

(*DeployCloudFormationStack*/Environment/**Name**)

(Richiesto se [Environment](#deploy.action.cfn.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.cfn.environment.connections"></a>

(*DeployCloudFormationStack*/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.cfn.environment.connections.name"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Name**)

(Richiesto se incluso[Connections](#deploy.action.cfn.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.cfn.environment.connections.role"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Role**)

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

Specificate il nome del ruolo IAM **utilizzato dall'azione Deploy CloudFormation stack** per accedere AWS e al CloudFormation servizio. 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.
**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.cfn.inputs"></a>

(*DeployCloudFormationStack*/**Inputs**)

(Facoltativo)

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

**Nota**  
Sono consentiti un massimo di quattro input (una fonte e tre artefatti) per ogni azione dello stack ** CloudFormation Deploy**.

Se è necessario fare riferimento a file che risiedono in input diversi (ad esempio una sorgente e un artefatto), l'input di origine è l'input principale e l'artefatto è l'input secondario. I riferimenti ai file negli input secondari richiedono un prefisso speciale per distinguerli dal primario. Per informazioni dettagliate, vedi [Esempio: riferimento a file in più artefatti](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

**Interfaccia utente corrispondente: scheda Ingressi**

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

(*DeployCloudFormationStack*/Inputs/**Sources**)

(Richiesto se il AWS SAM modello CloudFormation o è archiviato in un repository di origine)

Se il AWS SAM modello CloudFormation o è archiviato in un repository di origine, specifica l'etichetta di tale repository di origine. Attualmente, l'unica etichetta supportata è. `WorkflowSource`

Se il AWS SAM modello CloudFormation o non è contenuto in un repository di origine, deve risiedere in un artefatto generato da un'altra azione o in un bucket Amazon S3.

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.cfn.inputs.artifacts"></a>

(*DeployCloudFormationStack*/Inputs/**Artifacts**)

(Richiesto se il AWS SAM modello CloudFormation o è memorizzato in un elemento [di output di un'azione precedente](workflows-working-artifacts-output.md))

Se il AWS SAM modello CloudFormation o che desideri distribuire è contenuto in un artefatto generato da un'azione precedente, specifica quell'artefatto qui. Se il CloudFormation modello non è contenuto in un artefatto, deve risiedere nel repository di origine o in un bucket Amazon S3.

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

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

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

(*DeployCloudFormationStack*/**Configuration**)

(Obbligatorio)

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

Interfaccia utente corrispondente: scheda **Configurazione**

## name
<a name="deploy.action.cfn.stackname"></a>

(*DeployCloudFormationStack*/Configuration/**name**)

(Obbligatorio)

Specificate un nome per lo CloudFormation stack creato o aggiornato dall'azione **Deploy CloudFormation stack**.

**Interfaccia utente corrispondente: scheda di configurazione/nome dello stack**

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

(*DeployCloudFormationStack*/Configuration/**region**)

(Obbligatorio)

Specificare Regione AWS in che modo verrà distribuito lo stack. Per un elenco dei codici regionali, consulta Endpoint [regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

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

## template
<a name="deploy.action.cfn.templatepath"></a>

(*DeployCloudFormationStack*/Configuration/**template**)

(Obbligatorio)

Specificate il nome e il percorso del file CloudFormation o AWS SAM del modello. Il modello può essere in formato JSON o YAML e può risiedere in un repository di origine, in un elemento di un'azione precedente o in un bucket Amazon S3. Se il file modello si trova in un repository o in un artefatto di origine, il percorso è relativo all'origine o alla radice dell'artefatto. Se il modello si trova in un bucket Amazon S3, il percorso è il valore dell'URL dell'**oggetto** del modello.

Esempi:

`./MyFolder/MyTemplate.json`

`MyFolder/MyTemplate.yml`

`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`

**Nota**  
Potrebbe essere necessario aggiungere un prefisso al percorso del file del modello per indicare in quale artefatto o fonte trovarlo. Per ulteriori informazioni, consultare [Riferimento ai file del repository di origine](workflows-sources-reference-files.md) e [Riferimento ai file in un artefatto](workflows-working-artifacts-refer-files.md).

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

## role-arn
<a name="deploy.action.cfn.stackrolearn"></a>

(*DeployCloudFormationStack*/Configuration/**role-arn**)

(Obbligatorio)

Specificare l'Amazon Resource Name (ARN) del ruolo dello stack. CloudFormation utilizza questo ruolo per accedere e modificare le risorse del tuo stack. Ad esempio: `arn:aws:iam::123456789012:role/StackRole`.

Assicurati che il ruolo dello stack includa:
+ Una o più politiche di autorizzazione. Le politiche dipendono dalle risorse presenti nello stack. Ad esempio, se lo stack include una AWS Lambda funzione, devi aggiungere le autorizzazioni che concedono l'accesso a Lambda. Se hai seguito il tutorial descritto in[Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md), include una procedura intitolata, [Per creare un ruolo stack](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack) che elenca le autorizzazioni necessarie allo stack role se stai distribuendo un tipico stack di applicazioni serverless.
**avvertimento**  
Limita le autorizzazioni a quelle richieste dal CloudFormation servizio per accedere alle risorse del tuo stack. L'utilizzo di un ruolo con autorizzazioni più ampie potrebbe rappresentare un rischio per la sicurezza.
+ La seguente politica di fiducia:

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

****  

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

------

Facoltativamente, associa questo ruolo alla connessione del tuo account. Per ulteriori informazioni sull'associazione di un ruolo IAM a una connessione all'account, consulta. [Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md) Se non associ il ruolo dello stack alla connessione dell'account, il ruolo dello stack non verrà visualizzato nell'elenco a discesa del **ruolo Stack** nell'editor visivo; tuttavia, il ruolo ARN può ancora essere specificato nel campo utilizzando l'editor YAML. `role-arn`

**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: scheda di configurazione/ruolo **Stack - opzionale**

## capabilities
<a name="deploy.action.cfn.capabilities"></a>

(*DeployCloudFormationStack*/Configuration/**capabilities**)

(Obbligatorio)

Specificate un elenco di funzionalità IAM necessarie per consentire la creazione CloudFormation di determinati stack. Nella maggior parte dei casi, puoi lasciare `capabilities` il valore predefinito di`CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`.

Se vedi `##[error] requires capabilities: [capability-name]` nei log delle azioni ** CloudFormation dello stack Deploy**, consulta [Come posso correggere gli errori relativi alle funzionalità IAM?](troubleshooting-workflows.md#troubleshooting-workflows-capabilities) per informazioni su come risolvere il problema.

*Per ulteriori informazioni sulle funzionalità IAM, consulta [Riconoscere le risorse IAM nei CloudFormation modelli nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities) per l'utente IAM.*

**Interfaccia utente corrispondente: Configuration Tab/Advanced/ Capabilities**

## parameter-overrides
<a name="deploy.action.cfn.parameter.overrides"></a>

(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)

(Facoltativo)

Specificate i parametri nel vostro AWS SAM modello CloudFormation o che non hanno valori predefiniti o per i quali desiderate specificare valori non predefiniti. Per ulteriori informazioni sui parametri, consultate [Parametri](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) nella *Guida per l' AWS CloudFormation utente*.

La `parameter-overrides` proprietà accetta:
+ Un file JSON contenente i parametri e i valori.
+ Un elenco di parametri e valori separati da virgole.

**Per specificare un file JSON**

1. Assicurati che il file JSON utilizzi una delle seguenti sintassi:

   ```
   {
     "Parameters": {
       "Param1": "Value1",
       "Param2": "Value2",
       ...
     }
   }
   ```

   Oppure...

   ```
   [
     {
        "ParameterKey": "Param1",
        "ParameterValue": "Value1"
     },
     ...
   ]
   ```

   (Esistono altre sintassi, ma non sono supportate da CodeCatalyst al momento della scrittura.) *Per ulteriori informazioni sulla specificazione CloudFormation dei parametri in un file JSON, vedete [Sintassi JSON supportata nel Command Reference](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax).AWS CLI *

1. Specificate il percorso del file JSON utilizzando uno dei seguenti formati:
   + Se il tuo file JSON si trova in un elemento di output di un'azione precedente, usa:

     `file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`

     Vedi l'**Esempio 1 per i dettagli**.
   + Se il tuo file JSON si trova nel tuo repository di origine, usa:

     `file:///sources/WorkflowSource/path-to-json-file`

     Vedi l'**Esempio 2** per i dettagli.

     **Esempio 1**: il file JSON risiede in un artefatto di output

     ```
     ##My workflow YAML
     ...
     Actions:
       MyBuildAction:
         Identifier: aws/build@v1
         Outputs:
           Artifacts:
             - Name: ParamArtifact
               Files:
                 - params.json
         Configuration:
         ...
       MyDeployCFNStackAction:
         Identifier: aws/cfn-deploy@v1
         Configuration:
           parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
     ```

     **Esempio 2**: il file JSON si trova nell'archivio di origine, in una cartella denominata `my/folder`

     ```
     ##My workflow YAML
     ...
     Actions:
       MyDeployCloudFormationStack:
         Identifier: aws/cfn-deploy@v1
         Inputs:
           Sources:
             - WorkflowSource
         Configuration:
           parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
     ```

**Per utilizzare un elenco di parametri separati da virgole**
+ Aggiungere coppie nome-valore dei parametri nella `parameter-overrides` proprietà utilizzando il seguente formato:

  `param-1=value-1,param-2=value-2`

  Ad esempio, supponendo il seguente modello: CloudFormation 

  ```
  ##My CloudFormation template
  
  Description: My CloudFormation template
  
  Parameters:
    InstanceType:
      Description: Defines the Amazon EC2 compute for the production server.
      Type: String
      Default: t2.micro
      AllowedValues:
        - t2.micro
        - t2.small
        - t3.medium
      
  Resources:
  ...
  ```

  ... potresti impostare la `parameter-overrides` proprietà come segue:

  ```
  ##My workflow YAML
  ...
  Actions:
  ...
    DeployCloudFormationStack:
      Identifier: aws/cfn-deploy@v1
      Configuration:
        parameter-overrides: InstanceType=t3.medium,UseVPC=true
  ```
**Nota**  
È possibile specificare il nome di un parametro senza un valore corrispondente `undefined` da utilizzare come valore. Esempio:  
`parameter-overrides: MyParameter=undefined`  
 L'effetto è che durante un aggiornamento dello stack, CloudFormation utilizza il valore del parametro esistente per il nome del parametro specificato.

Interfaccia utente corrispondente:
+ **Scheda di configurazione/Avanzata/ Sostituzioni dei parametri**
+ **Sostituzioni di configurazione/ Specificare le sostituzioni utilizzando un file tab/Advanced/Parameter**
+ **Sostituzioni di configurazione/ tab/Advanced/Parameter Specificare le sostituzioni utilizzando un set di valori**

## no-execute-changeset
<a name="deploy.action.cfn.noexecutechangeset"></a>

(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)

(Facoltativo)

Specificate se desiderate creare il set CodeCatalyst di CloudFormation modifiche e quindi interromperlo prima di eseguirlo. In questo modo è possibile rivedere il set di modifiche nella CloudFormation console. Se ritieni che il set di modifiche abbia un bell'aspetto, disabilita questa opzione e quindi riesegui il flusso di lavoro in modo da CodeCatalyst poter creare ed eseguire il set di modifiche senza interruzioni. L'impostazione predefinita prevede la creazione e l'esecuzione del set di modifiche senza interruzioni. Per ulteriori informazioni, vedete il parametro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) nel *AWS CLI Command* Reference. Per ulteriori informazioni sulla visualizzazione dei set di modifiche, vedere [Visualizzazione di un set di modifiche](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html) nella *Guida per l'AWS CloudFormation utente*.

**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/ Nessun set di modifiche da eseguire**

## fail-on-empty-changeset
<a name="deploy.action.cfn.failonemptychangeset"></a>

(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)

(Facoltativo)

Specificate se desiderate fallire CodeCatalyst l'azione **Deploy CloudFormation stack** se il set di modifiche è vuoto. CloudFormation (Se un set di modifiche è vuoto, significa che non sono state apportate modifiche allo stack durante l'ultima distribuzione.) L'impostazione predefinita prevede il proseguimento dell'azione se il set di modifiche è vuoto e la restituzione di un `UPDATE_COMPLETE` messaggio anche se lo stack non è stato aggiornato.

Per ulteriori informazioni su questa impostazione, vedete il parametro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) nel *AWS CLI Command* Reference. Per ulteriori informazioni sui set di modifiche, vedere [Aggiornamento degli stack utilizzando i set di modifiche nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html) per l'*AWS CloudFormation utente*.

**Interfaccia utente corrispondente: Configuration tab/Advanced/ Fail su changeset vuoto**

## disable-rollback
<a name="deploy.action.cfn.disablerollback"></a>

(*DeployCloudFormationStack*/Configuration/**disable-rollback**)

(Facoltativo)

Specificate se desiderate CodeCatalyst ripristinare la distribuzione dello stack se fallisce. Il rollback riporta lo stack all'ultimo stato stabile conosciuto. L'impostazione predefinita è abilitare i rollback. Per ulteriori informazioni su questa impostazione, vedete il parametro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) nel *AWS CLI Command* Reference.

Per ulteriori informazioni su come l'azione **Deploy CloudFormation stack** gestisce i rollback, consulta. [Configurazione dei rollback](deploy-consumption-enable-alarms.md)

*Per ulteriori informazioni sul rollback di uno stack, consulta [Stack failure options](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html) nella Guida per l'utente.AWS CloudFormation *

**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/ Disabilita il rollback**

## termination-protection
<a name="deploy.action.cfn.terminationprotection"></a>

(*DeployCloudFormationStack*/Configuration/**termination-protection**)

(Facoltativo)

Specificate se desiderate che lo stack **Deploy aggiunga la protezione dalla terminazione allo CloudFormation stack** che sta distribuendo. Se un utente tenta di eliminare uno stack con protezione da cessazione abilitata, l’eliminazione ha esito negativo e lo stack, incluso lo stato, rimane invariato. L'impostazione predefinita è disabilitare la protezione dalla terminazione. Per ulteriori informazioni, consulta [Proteggere uno stack dall'eliminazione nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html) per l'*AWS CloudFormation utente*.

**Interfaccia utente corrispondente: scheda di configurazione/Avanzata/Protezione da terminazione**

## timeout-in-minutes
<a name="deploy.action.cfn.timeoutinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)

(Facoltativo)

Specificate la quantità di tempo, in minuti, da dedicare prima di scadere le CloudFormation operazioni di creazione dello stack e impostare lo stato dello stack su. `CREATE_FAILED` Se CloudFormation non è in grado di creare l'intero stack nel tempo assegnato, produce un errore di timeout ed esegue il rollback dello stack.

Per impostazione predefinita, non è previsto alcun timeout per la creazione dello stack. Tuttavia, per la natura del servizio che implementano, alcune singole risorse possono avere un proprio timeout. Ad esempio, se una singola risorsa nello stack produce un timeout, anche la creazione dello stack viene arrestata, anche se il timeout specificato per la creazione dello stack non è ancora stato raggiunto.

**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/timeout CloudFormation**

## notification-arns
<a name="deploy.action.cfn.notificationarns"></a>

(*DeployCloudFormationStack*/Configuration/**notification-arns**)

(Facoltativo)

Specificate l'ARN di un argomento Amazon SNS a cui CodeCatalyst desiderate inviare messaggi di notifica. Ad esempio, `arn:aws:sns:us-east-1:111222333:MyTopic`. Quando viene eseguita l'azione **Deploy CloudFormation stack**, si CodeCatalyst coordina con CloudFormation per inviare una notifica per CloudFormation evento che si verifica durante il processo di creazione o aggiornamento dello stack. (Gli eventi sono visibili nella scheda **Eventi** della CloudFormation console relativa allo stack.) È possibile specificare fino a cinque argomenti. Per ulteriori informazioni, consulta [Cos'è Amazon SNS?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)

**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/Notifica ARNs**

## monitor-alarm-arns
<a name="deploy.action.cfn.monitoralarmarns"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)

(Facoltativo)

Specificare l'Amazon Resource Name (ARN) di un CloudWatch allarme Amazon da utilizzare come trigger di rollback. Ad esempio, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Puoi avere un massimo di cinque trigger di rollback.

**Nota**  
Se specifichi un ARN di CloudWatch allarme, dovrai anche configurare autorizzazioni aggiuntive per abilitare l'azione di accesso. CloudWatch Per ulteriori informazioni, consulta [Configurazione dei rollback](deploy-consumption-enable-alarms.md).

**Interfaccia utente corrispondente: scheda di configurazione/Avanzata/Monitor alarm ARNs**

## monitor-timeout-in-minutes
<a name="deploy.action.cfn.monitortimeinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)

(Facoltativo)

Specificare un periodo di tempo, da 0 a 180 minuti, durante il quale CloudFormation monitorare gli allarmi specificati. Il monitoraggio inizia *dopo che* tutte le risorse dello stack sono state distribuite. Se l'allarme si verifica entro il periodo di monitoraggio specificato, l'implementazione fallisce e CloudFormation ripristina l'intera operazione dello stack.

Impostazione predefinita: 0. CloudFormation monitora gli allarmi solo mentre le risorse dello stack vengono distribuite, non dopo.

**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/Tempo di monitoraggio**

## tags
<a name="deploy.action.cfn.tags"></a>

(*DeployCloudFormationStack*/Configuration/**tags**)

(Facoltativo)

Specificate i tag da allegare allo stack. CloudFormation I tag sono coppie chiave-valore arbitrarie che è possibile utilizzare per identificare lo stack per scopi quali l'allocazione dei costi. Per ulteriori informazioni sui tag e su come possono essere utilizzati, consulta l'argomento relativo al [tagging delle risorse](https://docs.aws.amazon.com/) nella *Guida per l'utente di Amazon EC2*. *Per ulteriori informazioni sull'inserimento dei tag CloudFormation, consulta [Impostazione delle opzioni CloudFormation dello stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) nella Guida per l'utente.AWS CloudFormation *

Una chiave può contenere caratteri alfanumerici o spazi e può contenere fino a 127 caratteri. Un valore può contenere caratteri alfanumerici o spazi e può contenere fino a 255 caratteri.

È possibile aggiungere fino a 50 tag univoci per ogni stack.

**Interfaccia utente corrispondente: Configuration Tab/Advanced/ Tags**

# Implementazione di un' AWS CDK app con un flusso di lavoro
<a name="cdk-dep-action"></a>

Questa sezione descrive come distribuire un' AWS Cloud Development Kit (AWS CDK) app nel tuo AWS account utilizzando un flusso di lavoro. A tale scopo, è necessario aggiungere l'azione di **AWS CDK distribuzione al flusso** di lavoro. L'azione di **AWS CDK distribuzione** sintetizza e distribuisce l'app in. AWS Cloud Development Kit (AWS CDK) AWS Se l'app esiste già in AWS, l'azione la aggiorna se necessario. 

Per informazioni generali sulla scrittura di app utilizzando il AWS CDK, vedi [Cos'è il AWS CDK?](https://docs.aws.amazon.com/cdk/v2/guide/home.html) nella *Guida per gli AWS Cloud Development Kit (AWS CDK) sviluppatori*.

**Topics**
+ [Quando utilizzare l'azione «AWS CDK deploy»](#cdk-dep-action-when-to-use)
+ [Come funziona l'azione 'AWS CDK deploy'](#cdk-dep-action-how-it-works)
+ [Versioni CDK CLI utilizzate dall'azione 'deploy'AWS CDK](#cdk-dep-action-cdk-version)
+ [Immagine di runtime utilizzata dall'azione 'deploy'AWS CDK](#cdk-dep-action-runtime)
+ [Quanti stack può dispiegare l'azione?](#cdk-dep-action-how-many-stacks)
+ [Esempio: distribuzione di un'app AWS CDK](cdk-dep-action-example-workflow.md)
+ [Aggiungere l'azione 'AWS CDK deploy'](cdk-dep-action-add.md)
+ [variabili 'AWS CDK deploy'](cdk-dep-action-variables.md)
+ [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.md)

## Quando utilizzare l'azione «AWS CDK deploy»
<a name="cdk-dep-action-when-to-use"></a>

Utilizza questa azione se hai sviluppato un'app utilizzando e ora desideri distribuirla AWS CDK automaticamente come parte del flusso di lavoro automatizzato di integrazione e distribuzione continue (CI/CD). Ad esempio, potresti voler distribuire la tua AWS CDK app automaticamente ogni volta che qualcuno unisce una pull request relativa alla fonte dell'app. AWS CDK 

## Come funziona l'azione 'AWS CDK deploy'
<a name="cdk-dep-action-how-it-works"></a>

La **AWS CDK distribuzione funziona nel modo seguente**:

1. [In fase di esecuzione, se hai specificato la versione 1.0.12 o precedente dell'azione, l'azione scarica l'ultima CLI CDK (chiamata anche Tookit) AWS CDK nell'immagine dell'ambiente di runtime. CodeCatalyst ](#cdk-dep-action-runtime)

   Se hai specificato la versione 1.0.13 o successiva, l'azione viene fornita in bundle con una [versione specifica](#cdk-dep-action-cdk-version) della CLI CDK, quindi non viene effettuato alcun download.

1. L'azione utilizza la CLI CDK per eseguire il comando`cdk deploy`. Questo comando sintetizza e distribuisce l'app in. AWS CDK AWS*Per ulteriori informazioni su questo comando, consultate l'argomento [AWS CDK Toolkit (comando cdk)](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) nella Guida per gli sviluppatori.AWS Cloud Development Kit (AWS CDK) *

## Versioni CDK CLI utilizzate dall'azione 'deploy'AWS CDK
<a name="cdk-dep-action-cdk-version"></a>

La tabella seguente mostra quale versione della CLI CDK viene utilizzata per impostazione predefinita dalle diverse versioni **AWS CDK dell'**azione di distribuzione.

**Nota**  
Potresti essere in grado di sovrascrivere l'impostazione predefinita. Per ulteriori informazioni, consulta [CdkCliVersion](cdk-dep-action-ref.md#cdk.dep.cdk.cli.version) nella [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.md).


| versione dell'AWS CDK azione 'deploy' | AWS CDK Versione CLI | 
| --- | --- | 
|  1.0.0 — 1.0.12  |  più recente  | 
|  1.0.13 o successivo  |  2.99.1  | 

## Immagine di runtime utilizzata dall'azione 'deploy'AWS CDK
<a name="cdk-dep-action-runtime"></a>

La tabella seguente mostra le immagini dell'ambiente di runtime CodeCatalyst utilizzate per eseguire diverse versioni dell'azione di **AWS CDK distribuzione.** Le immagini includono diversi set di strumenti preinstallati. Per ulteriori informazioni, consulta [Immagini attive](build-images.md#build-curated-images).

**Nota**  
Ti consigliamo di aggiornare l'azione di **AWS CDK distribuzione** alla versione 2.x per sfruttare gli strumenti più recenti disponibili nell'immagine di marzo 2024. Per aggiornare l'azione, impostane la `Identifier` proprietà su nel file di definizione del flusso di lavoro`aws/cdk-deploy@v2`. Per ulteriori informazioni, consulta [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.md). 


| versione dell'AWS CDK azione 'deploy' | Immagini dell'ambiente di runtime | 
| --- | --- | 
|  1.x  |  Immagini di novembre 2022  | 
|  2.x  |  Immagini di marzo 2024  | 

## Quanti stack può dispiegare l'azione?
<a name="cdk-dep-action-how-many-stacks"></a>

La **AWS CDK distribuzione può implementare solo un singolo stack**. Se la tua AWS CDK app è composta da più stack, devi creare uno stack principale con stack annidati e distribuire lo stack principale utilizzando questa azione.

# Esempio: distribuzione di un'app AWS CDK
<a name="cdk-dep-action-example-workflow"></a>

**Il seguente flusso di lavoro di esempio include l'azione **AWS CDK deploy**, insieme all'AWS CDK azione bootstrap.** 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. Questo repository contiene la tua AWS CDK app. 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 **AWS CDK bootstrap** (`CDKBootstrap`): all'attivazione, l'azione distribuisce lo stack di `CDKToolkit` bootstrap in. AWS Se lo `CDKToolkit` stack esiste già nell'ambiente, verrà aggiornato se necessario; in caso contrario, non succede nulla e l'azione viene contrassegnata come riuscita.
+ An **AWS CDK deploy** action (`AWS CDK Deploy`): al termine dell'azione **AWS CDK bootstrap**, l'azione **AWS CDK deploy** sintetizza il codice dell' AWS CDK app in un CloudFormation modello e distribuisce lo stack definito nel modello. AWS

**Nota**  
Il seguente esempio di flusso di lavoro è a scopo illustrativo e non funzionerà senza una configurazione aggiuntiva.

**Nota**  
Nel codice YAML che segue, puoi omettere le `Connections:` sezioni se lo 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 richieste dalle azioni bootstrap e deploy.AWS CDK AWS CDK **** Per ulteriori informazioni sulla configurazione di un ambiente con un ruolo IAM predefinito, consulta. [Creazione di un ambiente](deploy-environments-creating-environment.md) Per ulteriori informazioni sulle autorizzazioni e sulle politiche di attendibilità richieste dalle azioni **AWS CDK bootstrap** e **AWS CDK deploy**, consulta la descrizione della `Role` proprietà nel e. [azione 'AWS CDK bootstrap' YAML](cdk-boot-action-ref.md) [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.md)

```
Name: codecatalyst-cdk-deploy-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  CDKBootstrap:
    Identifier: aws/cdk-bootstrap@v2
    Inputs:
      Sources:
        - WorkflowSource
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-bootstrap-role
    Configuration:
      Region: us-west-2
        
  CDKDeploy:
    Identifier: aws/cdk-deploy@v2
    DependsOn: 
      - CDKBootstrap
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-deploy-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      StackName: my-app-stack
      Region: us-west-2
```

# Aggiungere l'azione 'AWS CDK deploy'
<a name="cdk-dep-action-add"></a>

 Utilizza le seguenti istruzioni per aggiungere l'azione di **AWS CDK distribuzione al tuo flusso di lavoro.** 

**Prima di iniziare**

Prima di aggiungere l'azione di **AWS CDK distribuzione** al flusso di lavoro, completa le seguenti attività:

1. **Tieni pronta un' AWS CDK app**. Puoi scrivere la tua AWS CDK app usando AWS CDK v1 o v2, in qualsiasi linguaggio di programmazione supportato da. AWS CDK Assicurati che i file della tua AWS CDK app siano disponibili in:
   + Un [archivio CodeCatalyst di sorgenti](source.md), oppure 
   + Un [artefatto CodeCatalyst di output](workflows-working-artifacts.md) generato da un'altra azione del flusso di lavoro

1. **Avvia il tuo ambiente. AWS ** Per eseguire il bootstrap, puoi:
   + Utilizza uno dei metodi descritti in [Come eseguire il bootstrap nella Guida](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-howto) per gli *AWS Cloud Development Kit (AWS CDK) sviluppatori*.
   + Usa l'azione **AWS CDK bootstrap.** Puoi aggiungere questa azione nello stesso flusso di lavoro della **AWS CDK distribuzione** o in uno diverso. Assicurati solo che l'azione bootstrap venga eseguita almeno una volta prima di eseguire l'azione di **AWS CDK distribuzione** in modo che siano disponibili le risorse necessarie. Per ulteriori informazioni sull'azione **AWS CDK bootstrap**, consulta. [Avvio di un' AWS CDK app con un flusso di lavoro](cdk-boot-action.md)

     *Per ulteriori informazioni sul bootstrap, consulta [Bootstrap](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) nella Developer Guide.AWS Cloud Development Kit (AWS CDK) *

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

**Per aggiungere l'azione 'AWS CDK deploy' 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 di **AWS CDK distribuzione** 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 **AWS CDK deploy**. Viene visualizzata la finestra di dialogo dei 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, vedi. [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.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, quindi scegliete nuovamente Commit.**
**Nota**  
Se l'azione di **AWS CDK distribuzione** fallisce con un `npm install` errore, consulta [Come posso correggere gli errori di «npm install»?](troubleshooting-workflows.md#troubleshooting-workflows-npm) per informazioni su come correggere l'errore.

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

**Per aggiungere l'azione 'AWS CDK deploy' 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 di **AWS CDK distribuzione** 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 **AWS CDK deploy**. Viene visualizzata la finestra di dialogo dei 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. [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.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, quindi scegliete nuovamente Commit.**
**Nota**  
Se l'azione di **AWS CDK distribuzione** fallisce con un `npm install` errore, consulta [Come posso correggere gli errori di «npm install»?](troubleshooting-workflows.md#troubleshooting-workflows-npm) per informazioni su come correggere l'errore.

------

# variabili 'AWS CDK deploy'
<a name="cdk-dep-action-variables"></a>

L'azione **AWS CDK deploy** 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 | 
| --- | --- | 
|  stack-id  |  L'Amazon Resource Name (ARN) dello stack di AWS CDK applicazioni su cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-app-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  piattaforma di distribuzione  |  Il nome della piattaforma di distribuzione. Codificato in. `AWS:CloudFormation`  | 
|  region  |  Il codice regionale su Regione AWS cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `us-west-2`  | 
|  SALTA LA DISTRIBUZIONE  |  Il valore di `true` indica che la distribuzione dello stack di AWS CDK applicazioni è stata ignorata durante l'esecuzione del flusso di lavoro. Una distribuzione dello stack verrà ignorata se non vi sono modifiche nello stack dall'ultima distribuzione. Questa variabile viene prodotta solo se il suo valore è. `true` Codificato in. `true`  | 
|  *CloudFormation variabili*  |  Oltre a generare le variabili elencate in precedenza, l'azione di **AWS CDK distribuzione** espone anche le variabili di *CloudFormation*output come variabili del *flusso* di lavoro da utilizzare nelle azioni successive del flusso di lavoro. Per impostazione predefinita, l'azione espone solo le prime quattro (o meno) CloudFormation variabili trovate. Per determinare quali sono esposte, esegui l'azione di **AWS CDK distribuzione** una volta, quindi consulta la scheda **Variabili** della pagina dei dettagli di esecuzione. Se le variabili elencate nella scheda **Variabili** non sono quelle desiderate, puoi configurarne di diverse utilizzando la proprietà `CfnOutputVariables` YAML. Per ulteriori informazioni, consultate la descrizione della [CfnOutputVariables](cdk-dep-action-ref.md#cdk.dep.cfn.out) proprietà in. [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.md)  | 

# AWS CDK azione 'distribuisci' YAML
<a name="cdk-dep-action-ref"></a>

Di seguito è riportata la definizione YAML dell'azione di **AWS CDK distribuzione**. Per informazioni su come utilizzare questa azione, consulta. [Implementazione di un' AWS CDK app con un flusso di lavoro](cdk-dep-action.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.   
  CDKDeploy\$1nn: 
    Identifier: aws/cdk-deploy@v2
    DependsOn:
      - CDKBootstrap
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_artifact
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      StackName: my-cdk-stack
      Region: us-west-2
      Tags: '{"key1": "value1", "key2": "value2"}'
      Context: '{"key1": "value1", "key2": "value2"}'
      CdkCliVersion: version
      CdkRootPath: directory-containing-cdk.json-file
      CfnOutputVariables: '["CnfOutputKey1","CfnOutputKey2","CfnOutputKey3"]'
      CloudAssemblyRootPath: path-to-cdk.out
```

## CDKDeploy
<a name="cdk.dep.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: `CDKDeploy_nn`.

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

## Identifier
<a name="cdk.dep.identifier"></a>

(*CDKDeploy*/**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).

**Nota**  
La specificazione `aws/cdk-deploy@v2` causa l'esecuzione dell'azione sull'[immagine di marzo 2024](build-images.md#build.default-image) che include strumenti più recenti come Node.js 18. La specifica `aws/cdk-deploy@v1` fa sì che l'azione venga eseguita sull'[immagine di novembre 2022](build-images.md#build.previous-image) che include strumenti meno recenti come Node.js 16.

Default: `aws/cdk-deploy@v2`.

**Interfaccia utente corrispondente: Workflow diagram/ \$1nn/ CDKDeploy aws/cdk-deploy @v2 label**

## DependsOn
<a name="cdk.dep.dependson"></a>

(*CDKDeploy*/**DependsOn**)

(Facoltativo)

**Specificare un'azione o un gruppo di azioni che deve essere eseguito correttamente per l'esecuzione dell'azione di distribuzione.AWS CDK ** Ti consigliamo di specificare l'azione **AWS CDK bootstrap** nella `DependsOn` proprietà, in questo modo:

```
CDKDeploy:
  Identifier: aws/cdk-deploy@v2
  DependsOn:
    - CDKBootstrap
```

**Nota**  
Il [bootstrap](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) è un prerequisito obbligatorio per la distribuzione di un'app. AWS CDK **Se non includi l'azione **AWS CDK Bootstrap** nel tuo flusso di lavoro, devi trovare un altro modo per distribuire lo stack AWS CDK bootstrap prima di eseguire l'azione di distribuzione.AWS CDK ** Per ulteriori informazioni, consulta [Aggiungere l'azione 'AWS CDK deploy'](cdk-dep-action-add.md) in [Implementazione di un' AWS CDK app con un flusso di lavoro](cdk-dep-action.md).

Per ulteriori informazioni sulla funzionalità 'depends on', consulta. [Azioni di sequenziamento](workflows-depends-on.md)

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

## Compute
<a name="cdk.dep.computename"></a>

(*CDKDeploy*/**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="cdk.dep.computetype"></a>

(*CDKDeploy*/Compute/**Type**)

(Obbligatorio se [Compute](#cdk.dep.computename) 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="cdk.dep.computefleet"></a>

(*CDKDeploy*/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="cdk.dep.timeout"></a>

(*CDKDeploy*/**Timeout**)

(Obbligatorio)

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

## Inputs
<a name="cdk.dep.inputs"></a>

(*CDKDeploy*/**Inputs**)

(Facoltativo)

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

**Nota**  
È consentito un solo input (una fonte o un artefatto) per ogni azione di **AWS CDK distribuzione**.

**Interfaccia utente corrispondente: scheda Ingressi**

## Sources
<a name="cdk.dep.inputs.sources"></a>

(*CDKDeploy*/Inputs/**Sources**)

(Richiesto se l' AWS CDK app che desideri distribuire è archiviata in un repository di origine)

Se AWS CDK l'app è archiviata in un repository di origine, specifica l'etichetta di tale repository di origine. L'azione **AWS CDK deploy** sintetizza l'app in questo repository prima di iniziare il processo di distribuzione. Attualmente, l'unica etichetta supportata è. `WorkflowSource`

Se AWS CDK l'app non è contenuta 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="cdk.dep.inputs.artifacts"></a>

(*CDKDeploy*/Inputs/**Artifacts**)

(Richiesto se l' AWS CDK app che desideri distribuire è archiviata in un elemento di [output di un'azione precedente](workflows-working-artifacts-output.md))

Se AWS CDK l'app è contenuta in un artefatto generato da un'azione precedente, specificalo qui. L'azione **AWS CDK deploy** sintetizza l'app nell'artefatto specificato in un modello prima di iniziare il processo di distribuzione. CloudFormation Se AWS CDK l'app non è contenuta 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 Input/Artifacts - opzionale**

## Outputs
<a name="cdk.dep.outputs"></a>

(*CDKDeploy*/**Outputs**)

(Facoltativo)

Definisce i dati emessi dall'azione durante l'esecuzione di un flusso di lavoro.

Interfaccia utente corrispondente: **scheda Output**

## Artifacts - output
<a name="cdk.dep.outputs.artifacts"></a>

(*CDKDeploy*/Outputs/**Artifacts**

(Facoltativo)

Specificate gli artefatti generati dall'azione. È possibile fare riferimento a questi artefatti come input in altre azioni.

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

**Interfaccia utente corrispondente: scheda Outputs/Artifacts**

## Name
<a name="cdk.dep.outputs.artifacts.name"></a>

(*CDKDeploy*/Outputs/Artifacts/**Name**)

(Richiesto se incluso) [Artifacts - output](#cdk.dep.outputs.artifacts)

Specificate il nome dell'artefatto che conterrà il CloudFormation modello sintetizzato dall'azione di **AWS CDK distribuzione** in fase di esecuzione. Il valore predefinito è `cdk_artifact`. Se non specificate un artefatto, l'azione sintetizza il modello ma non lo salva in un artefatto. Prendi in considerazione la possibilità di salvare il modello sintetizzato in un artefatto per conservarne una registrazione a scopo di test o risoluzione dei problemi.

**Interfaccia utente corrispondente: restituisce il nome dell'artefatto/crea il nome dell'artefatto tab/Artifacts/Add**

## Files
<a name="cdk.dep.outputs.artifacts.files"></a>

(*CDKDeploy*/Outputs/Artifacts/**Files**)

(Richiesto se incluso) [Artifacts - output](#cdk.dep.outputs.artifacts)

Specificate i file da includere nell'artefatto. È necessario specificare `"cdk.out/**/*"` di includere il modello sintetizzato CloudFormation dell' AWS CDK app.

**Nota**  
`cdk.out`è la directory predefinita in cui vengono salvati i file sintetizzati. Se avete specificato una directory di output diversa `cdk.out` da quella `cdk.json` del file, specificate quella directory qui invece di. `cdk.out`

**Interfaccia utente corrispondente: restituisce tab/Artifacts/Add artefatti/file prodotti da build**

## Environment
<a name="cdk.dep.environment"></a>

(*CDKDeploy*/**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="cdk.dep.environment.name"></a>

(*CDKDeploy*/Environment/**Name**)

(Richiesto se [Environment](#cdk.dep.environment) incluso)

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

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

## Connections
<a name="cdk.dep.environment.connections"></a>

(*CDKDeploy*/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="cdk.dep.environment.connections.name"></a>

(*CDKDeploy*/Environment/Connections/**Name**)

(Richiesto se è incluso[Connections](#cdk.dep.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="cdk.dep.environment.connections.role"></a>

(*CDKDeploy*/Environment/Connections/**Role**)

(Richiesto se è incluso[Connections](#cdk.dep.environment.connections))

Specificare il nome della connessione all'account.

Specificate il nome del ruolo IAM **AWS CDK utilizzato** dall'azione di distribuzione per accedere AWS e distribuire lo stack di AWS CDK applicazioni. 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": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "cloudformation:DescribeStackEvents",
                  "cloudformation:DescribeChangeSet",
                  "cloudformation:DescribeStacks",
                  "cloudformation:ListStackResources"
              ],
              "Resource": "*"
          },
          {
              "Sid": "VisualEditor1",
              "Effect": "Allow",
              "Action": "sts:AssumeRole",
              "Resource": "arn:aws:iam::111122223333:role/cdk-*"
          }
      ]
  }
  ```

------
+ 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**

## Configuration
<a name="cdk.dep.configuration"></a>

(*CDKDeploy*/**Configuration**)

(Obbligatorio)

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

Interfaccia utente corrispondente: scheda **Configurazione**

## StackName
<a name="cdk.dep.stack.name"></a>

(*CDKDeploy*/Configuration/**StackName**)

(Obbligatorio)

Il nome dello stack di AWS CDK app, così come appare nel file entrypoint nella directory AWS CDK dell'app. `bin` L'esempio seguente mostra il contenuto di un file TypeScript entrypoint, con il nome dello stack evidenziato in. *red italics* Se il file entrypoint è in una lingua diversa, avrà un aspetto simile.

```
import * as cdk from 'aws-cdk-lib';
import { CdkWorksopTypescriptStack } from '../lib/cdk_workshop_typescript-stack';

const app = new cdk.App();
new CdkWorkshopTypescriptStack(app, 'CdkWorkshopTypescriptStack');
```

Puoi specificare solo uno stack.

**Suggerimento**  
Se disponi di più stack, puoi creare uno stack principale con pile annidate. È quindi possibile specificare lo stack principale in questa azione per distribuire tutti gli stack.

**Interfaccia utente corrispondente: scheda di configurazione/nome dello stack**

## Region
<a name="cdk.dep.region"></a>

(*CDKDeploy*/Configuration/**Region**)

(Facoltativo)

Specificare Regione AWS in che modo verrà distribuito lo stack AWS CDK dell'applicazione. Per un elenco dei codici regionali, consulta Endpoint [regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

Se non specifichi una regione, l'azione di **AWS CDK distribuzione** viene distribuita nella regione specificata nel codice. AWS CDK Per ulteriori informazioni, consulta [Environments](https://docs.aws.amazon.com/cdk/v2/guide/environments.html) nella *AWS Cloud Development Kit (AWS CDK) Developer* Guide.

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

## Tags
<a name="cdk.dep.tags"></a>

(*CDKDeploy*/Configuration/**Tags**)

(Facoltativo)

Specificate i tag che desiderate applicare alle AWS risorse nello stack di AWS CDK applicazioni. I tag vengono applicati allo stack stesso e alle singole risorse dello stack. *Per ulteriori informazioni sui tag, consulta [Tagging](https://docs.aws.amazon.com/cdk/v2/guide/tagging.html) nella Developer Guide.AWS Cloud Development Kit (AWS CDK) *

**Interfaccia utente corrispondente: Configuration tab/Advanced - opzionale/ Tags**

## Context
<a name="cdk.dep.context"></a>

(*CDKDeploy*/Configuration/**Context**)

(Facoltativo)

Specificate i contesti, sotto forma di coppie chiave-valore, da associare allo stack dell'applicazione. AWS CDK *Per ulteriori informazioni sui contesti, consulta [Runtime contexts](https://docs.aws.amazon.com/cdk/v2/guide/context.html) nella Developer Guide.AWS Cloud Development Kit (AWS CDK) *

**Interfaccia utente corrispondente: Configurazione tab/Advanced - opzionale/ Context**

## CdkCliVersion
<a name="cdk.dep.cdk.cli.version"></a>

(*CDKDeploy*/Configuration/**CdkCliVersion**)

(Facoltativo)

**Questa proprietà è disponibile con la versione 1.0.13 o successiva dell'azione **AWS CDK deploy** e la versione 1.0.8 o successiva dell'azione bootstrap.AWS CDK **

Specifica una delle seguenti proprietà:
+ La versione completa dell'interfaccia a riga di AWS Cloud Development Kit (AWS CDK) comando (CLI) (chiamata anche AWS CDK Toolkit) che si desidera utilizzare con questa azione. Esempio: `2.102.1`. Valuta la possibilità di specificare una versione completa per garantire coerenza e stabilità durante la creazione e la distribuzione dell'applicazione.

  Or
+ `latest`. Valuta la possibilità `latest` di specificare se sfruttare le funzionalità e le correzioni più recenti della CLI CDK.

L'azione scaricherà la versione specificata (o la versione più recente) della AWS CDK CLI nell'[immagine di CodeCatalyst build](build-images.md), quindi utilizzerà questa versione per eseguire i comandi necessari per distribuire l'applicazione CDK o avviare il proprio ambiente. AWS 

[Per un elenco delle versioni CDK CLI supportate che puoi utilizzare,AWS CDK consulta Versioni.](https://docs.aws.amazon.com/cdk/api/versions.html)

Se si omette questa proprietà, l'azione utilizza una versione AWS CDK CLI predefinita descritta in uno dei seguenti argomenti:
+ [Versioni CDK CLI utilizzate dall'azione 'deploy'AWS CDK](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [Versioni CDK CLI utilizzate dall'azione AWS CDK "bootstrap»](cdk-boot-action.md#cdk-boot-action-cdk-version)

Interfaccia utente corrispondente: scheda di configurazione/versione **AWS CDK CLI**

## CdkRootPath
<a name="cdk.dep.cdk.root.path"></a>

(*CDKDeploy*/Configuration/**CdkRootPath**)

(Facoltativo)

Il percorso della directory che contiene il file del AWS CDK `cdk.json` progetto. L'azione **AWS CDK di distribuzione** viene eseguita da questa cartella e tutti gli output creati dall'azione verranno aggiunti a questa directory. Se non è specificata, l'azione di **AWS CDK distribuzione** presuppone che il `cdk.json` file si trovi nella radice del progetto. AWS CDK 

Interfaccia utente corrispondente: scheda di configurazione/ **Directory in cui risiede cdk.json**

## CfnOutputVariables
<a name="cdk.dep.cfn.out"></a>

(*CDKDeploy*/Configuration/**CfnOutputVariables**)

(Facoltativo)

Specificate quali `CfnOutput` costrutti del codice AWS CDK dell'applicazione desiderate esporre come variabili di output del flusso di lavoro. È quindi possibile fare riferimento alle variabili di output del flusso di lavoro nelle azioni successive del flusso di lavoro. Per ulteriori informazioni sulle variabili in CodeCatalyst, vedere[Utilizzo delle variabili nei flussi di lavoro](workflows-working-with-variables.md).

Ad esempio, se il codice AWS CDK dell'applicazione è simile al seguente:

```
import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';
import * as cdk from 'aws-cdk-lib';
export class HelloCdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: RemovalPolicy.DESTROY,
    });
    new CfnOutput(this, 'bucketName', {
      value: bucket.bucketName,
      description: 'The name of the s3 bucket',
      exportName: 'amzn-s3-demo-bucket',
    });
    const table = new dynamodb.Table(this, 'todos-table', {
      partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    })
    new CfnOutput(this, 'tableName', {
      value: table.tableName,
      description: 'The name of the dynamodb table',
      exportName: 'myDynamoDbTable',
    });
    ...
  }
}
```

... e la tua `CfnOutputVariables` proprietà ha questo aspetto:

```
Configuration:
  ...
  CfnOutputVariables: '["bucketName","tableName"]'
```

... quindi l'azione genera le seguenti variabili di output del flusso di lavoro:


| Chiave | Valore | 
| --- | --- | 
|  bucketName  |  `bucket.bucketName`  | 
|  tableName  |  `table.tableName`  | 

È quindi possibile fare riferimento alle `tableName` variabili `bucketName` and nelle azioni successive. Per informazioni su come fare riferimento alle variabili di output del flusso di lavoro nelle azioni successive, consulta[Riferimento a una variabile predefinita](workflows-working-with-variables-reference-output-vars.md).

Se non specificate alcun `CfnOutput` costrutto nella `CfnOutputVariables` proprietà, l'azione espone le prime quattro (o meno) variabili di output trovate come variabili di CloudFormation output del flusso di lavoro. Per ulteriori informazioni, consulta [variabili 'AWS CDK deploy'](cdk-dep-action-variables.md).

**Suggerimento**  
**Per ottenere un elenco di tutte le variabili di CloudFormation output prodotte dall'azione, esegui una volta il flusso di lavoro contenente l'azione di **AWS CDK distribuzione**, quindi consulta la scheda Registri dell'azione.** I log contengono un elenco di tutte le variabili di CloudFormation output associate all'app. AWS CDK Una volta che sapete quali sono tutte le CloudFormation variabili, potete specificare quelle che desiderate convertire in variabili di output del flusso di lavoro utilizzando la `CfnOutputVariables` proprietà.

Per ulteriori informazioni sulle variabili di CloudFormation output, consultate la documentazione relativa al `CfnOutput` costrutto, disponibile all'indirizzo [class CfnOutput (construct)](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html) nell'*AWS Cloud Development Kit (AWS CDK) API* Reference.

**Interfaccia utente corrispondente: scheda di configurazione/variabili di output CloudFormation **

## CloudAssemblyRootPath
<a name="cdk.dep.cloud"></a>

(*CDKDeploy*/Configuration/**CloudAssemblyRootPath**)

(Facoltativo)

Se hai già sintetizzato lo stack dell' AWS CDK app in un assembly cloud (utilizzando l'`cdk synth`operazione), specifica il percorso principale della directory dell'assembly cloud (). `cdk.out` Il CloudFormation modello che si trova nella directory di assemblaggio cloud specificata verrà distribuito dall'azione **AWS CDK deploy** nell'utente utilizzando il comando. Account AWS `cdk deploy --app` Quando l'`--app`opzione è presente, l'`cdk synth`operazione non viene eseguita.

Se non si specifica una directory di assemblaggio cloud, l'azione **AWS CDK deploy** eseguirà il `cdk deploy` comando senza l'`--app`opzione. Senza l'`--app`opzione, l'`cdk deploy`operazione sintetizzerà (`cdk synth`) e distribuirà l'app nel tuo AWS CDK . Account AWS

**Perché dovrei specificare un assembly cloud esistente e sintetizzato quando l'azione "AWS CDK deploy» può eseguire la sintesi in fase di esecuzione?**

Potresti voler specificare un assembly cloud esistente e sintetizzato per:
+ **Assicurati che venga distribuito lo stesso identico set di risorse ogni volta che viene eseguita l'azione "AWS CDK deploy»**

  Se non specifichi un assembly cloud, è possibile che l'azione di distribuzione sintetizzi e **AWS CDK distribuisca** file diversi a seconda di quando viene eseguita. Ad esempio, l'azione di **AWS CDK implementazione** potrebbe sintetizzare un assembly cloud con un set di dipendenze durante una fase di test e un altro set di dipendenze durante una fase di produzione (se tali dipendenze sono cambiate tra le fasi). Per garantire l'esatta parità tra ciò che viene testato e ciò che viene distribuito, consigliamo di eseguire la sintesi una volta e poi utilizzare il campo della **directory Path to cloud assembly** (editor visivo) o la `CloudAssemblyRootPath` proprietà (editor YAML) per specificare l'assembly cloud già sintetizzato.
+ **Usa AWS CDK gestori di pacchetti e strumenti non standard con l'app**

  Durante un'`synth`operazione, l'azione **AWS CDK deploy** tenta di eseguire l'app utilizzando strumenti standard come npm o pip. Se l'azione non riesce a eseguire correttamente l'app utilizzando tali strumenti, la sintesi non verrà eseguita e l'azione avrà esito negativo. Per risolvere questo problema, puoi specificare i comandi esatti necessari per eseguire correttamente l'app nel `cdk.json` file dell' AWS CDK app e quindi sintetizzare l'app utilizzando un metodo che non prevede l'azione di **AWS CDK distribuzione**. **Dopo che l'assembly cloud è stato generato, è possibile specificarlo nel campo **Path to cloud assembly directory** (editor visivo) o nella `CloudAssemblyRootPath` proprietà (editor YAML) dell'azione di distribuzione.AWS CDK ** 

Per informazioni sulla configurazione del `cdk.json` file per includere i comandi per l'installazione e l'esecuzione dell' AWS CDK app, consulta [Specificazione](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-app-command) del comando dell'app.

[https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-nosynth](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-nosynth)

[https://docs.aws.amazon.com/cdk/api/v2/docs/cloud-assembly-schema-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/cloud-assembly-schema-readme.html)

Interfaccia utente corrispondente: scheda di **configurazione/percorso della directory di assemblaggio cloud**

# Avvio di un' AWS CDK app con un flusso di lavoro
<a name="cdk-boot-action"></a>

Questa sezione descrive come avviare un'applicazione utilizzando un AWS CDK flusso di lavoro. CodeCatalyst A tale scopo, è necessario aggiungere l'azione **AWS CDK bootstrap** al flusso di lavoro. [L'azione **AWS CDK bootstrap** fornisce uno stack di bootstrap nell' AWS ambiente utilizzando il modello moderno.](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-template) Se esiste già uno stack di bootstrap, l'azione lo aggiorna se necessario. La presenza di uno stack di bootstrap AWS è un prerequisito per la distribuzione di un'app. AWS CDK 

[https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)

**Topics**
+ [Quando usare l'azione 'bootstrap'AWS CDK](#cdk-boot-action-when-to-use)
+ [Come funziona l'azione 'AWS CDK bootstrap'](#cdk-boot-action-how-it-works)
+ [Versioni CDK CLI utilizzate dall'azione AWS CDK "bootstrap»](#cdk-boot-action-cdk-version)
+ [Immagine di runtime utilizzata dall'azione 'bootstrap'AWS CDK](#cdk-boot-action-runtime)
+ [Esempio: avvio di un'app AWS CDK](cdk-boot-action-example-workflow.md)
+ [Aggiungere l'azione 'AWS CDK bootstrap'](cdk-boot-action-add.md)
+ [variabili 'AWS CDK bootstrap'](cdk-boot-action-variables.md)
+ [azione 'AWS CDK bootstrap' YAML](cdk-boot-action-ref.md)

## Quando usare l'azione 'bootstrap'AWS CDK
<a name="cdk-boot-action-when-to-use"></a>

Utilizza questa azione se disponi di un flusso di lavoro che distribuisce un' AWS CDK app e desideri distribuire (e aggiornare, se necessario) lo stack di bootstrap contemporaneamente. In questo caso, aggiungeresti l'azione **AWS CDK bootstrap** allo stesso flusso di lavoro di quello che distribuisce l'app. AWS CDK 

**Non** utilizzare questa azione se si verifica una delle seguenti condizioni:
+ Hai già distribuito uno stack di bootstrap utilizzando un altro meccanismo e desideri mantenerlo intatto (nessun aggiornamento).
+ **Vuoi usare un modello di [bootstrap personalizzato](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-customizing), che non è supportato con l'azione bootstrap.AWS CDK **

## Come funziona l'azione 'AWS CDK bootstrap'
<a name="cdk-boot-action-how-it-works"></a>

Il **AWS CDK bootstrap funziona** come segue:

1. [In fase di esecuzione, se hai specificato la versione 1.0.7 o precedente dell'azione, l'azione scarica l'ultima CLI CDK (chiamata anche AWS CDK Tookit) nell'immagine di build. CodeCatalyst ](build-images.md)

   Se hai specificato la versione 1.0.8 o successiva, l'azione viene fornita in bundle con una [versione specifica](cdk-dep-action.md#cdk-dep-action-cdk-version) della CLI CDK, quindi non viene effettuato alcun download.

1. L'azione utilizza la CLI CDK per eseguire il comando`cdk bootstrap`. *Questo comando esegue le attività di bootstrap descritte nell'argomento [Bootstrap](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) della Guida per gli sviluppatori.AWS Cloud Development Kit (AWS CDK) *

## Versioni CDK CLI utilizzate dall'azione AWS CDK "bootstrap»
<a name="cdk-boot-action-cdk-version"></a>

La tabella seguente mostra quale versione della CLI CDK viene utilizzata per impostazione predefinita da diverse versioni **AWS CDK dell'**azione bootstrap.

**Nota**  
Potresti essere in grado di sovrascrivere l'impostazione predefinita. Per ulteriori informazioni, consulta [CdkCliVersion](cdk-boot-action-ref.md#cdk.boot.cdk.cli.version) nella [azione 'AWS CDK bootstrap' YAML](cdk-boot-action-ref.md).


| versione d'azione 'AWS CDK bootstrap' | AWS CDK Versione CLI | 
| --- | --- | 
|  1.0.0 — 1.0.7  |  più recente  | 
|  1.0.8 o versione successiva  |  2.99.1  | 

## Immagine di runtime utilizzata dall'azione 'bootstrap'AWS CDK
<a name="cdk-boot-action-runtime"></a>

La tabella seguente mostra le immagini dell'ambiente di runtime CodeCatalyst utilizzate per eseguire diverse versioni dell'azione **AWS CDK bootstrap.** Le immagini includono diversi set di strumenti preinstallati. Per ulteriori informazioni, consulta [Immagini attive](build-images.md#build-curated-images).

**Nota**  
Ti consigliamo di aggiornare l'azione **AWS CDK bootstrap** alla versione 2.x per sfruttare gli strumenti più recenti disponibili nell'immagine di marzo 2024. Per aggiornare l'azione, impostane la `Identifier` proprietà su nel file di definizione del flusso di lavoro`aws/cdk-bootstrap@v2`. Per ulteriori informazioni, consulta [AWS CDK azione 'distribuisci' YAML](cdk-dep-action-ref.md). 


| versione d'azione 'AWS CDK bootstrap' | Immagini dell'ambiente di runtime | 
| --- | --- | 
|  1.x  |  Immagini di novembre 2022  | 
|  2.x  |  Immagini di marzo 2024  | 

# Esempio: avvio di un'app AWS CDK
<a name="cdk-boot-action-example-workflow"></a>

**Fate riferimento a [Esempio: distribuzione di un'app AWS CDK](cdk-dep-action-example-workflow.md) in [Implementazione di un' AWS CDK app con un flusso di lavoro](cdk-dep-action.md) per un flusso di lavoro che include l'AWS CDK azione bootstrap.**

# Aggiungere l'azione 'AWS CDK bootstrap'
<a name="cdk-boot-action-add"></a>

 **Utilizza le seguenti istruzioni per aggiungere l'azione bootstrap al tuo flusso di lavoro AWS CDK .** 

**Prima di iniziare**

Prima di poter utilizzare l'azione **AWS CDK bootstrap**, assicurati di avere un' AWS CDK app pronta. L'azione bootstrap sintetizzerà l'app prima del AWS CDK bootstrap. Puoi scrivere la tua app in qualsiasi linguaggio di programmazione supportato da. AWS CDK

Assicurati che i file AWS CDK dell'app siano disponibili in:
+ Un [archivio CodeCatalyst di sorgenti](source.md), oppure 
+ Un [artefatto CodeCatalyst di output](workflows-working-artifacts.md) generato da un'altra azione del flusso di lavoro

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

**Per aggiungere l'azione 'AWS CDK bootstrap' 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 **AWS CDK bootstrap** 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 **AWS CDK bootstrap**. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
     + (Facoltativo) Scegliete **Visualizza sorgente** 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 aprire il relativo riquadro di configurazione.

1. Nelle schede **Ingressi**, **Configurazione** e **Uscite**, completa i campi in base alle tue esigenze. Per una descrizione di ogni campo, vedi. [azione 'AWS CDK bootstrap' YAML](cdk-boot-action-ref.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, quindi scegliete nuovamente Commit.**
**Nota**  
Se l'operazione di **AWS CDK bootstrap** fallisce con un `npm install` errore, consulta [Come posso correggere gli errori di «npm install»?](troubleshooting-workflows.md#troubleshooting-workflows-npm) per informazioni su come correggere l'errore.

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

**Per aggiungere l'azione 'AWS CDK bootstrap' usando 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 **AWS CDK bootstrap** e scegli **\$1** per aggiungerla al diagramma del flusso di lavoro e aprire il relativo riquadro di configurazione.

1. Modifica le proprietà del codice YAML in base alle tue esigenze. Una spiegazione di ogni proprietà disponibile è fornita in. [azione 'AWS CDK bootstrap' YAML](cdk-boot-action-ref.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, quindi scegliete nuovamente Commit.**
**Nota**  
Se l'operazione di **AWS CDK bootstrap** fallisce con un `npm install` errore, consulta [Come posso correggere gli errori di «npm install»?](troubleshooting-workflows.md#troubleshooting-workflows-npm) per informazioni su come correggere l'errore.

------

# variabili 'AWS CDK bootstrap'
<a name="cdk-boot-action-variables"></a>

L'azione **AWS CDK bootstrap** 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 | 
| --- | --- | 
|  piattaforma di distribuzione  |  Il nome della piattaforma di distribuzione. Codificato in. `AWS:CloudFormation`  | 
|  region  |  Il codice regionale in cui è stato distribuito Regione AWS lo stack di AWS CDK bootstrap durante l'esecuzione del flusso di lavoro. Ad esempio: `us-west-2`  | 
|  stack-id  |  L'Amazon Resource Name (ARN) dello stack di bootstrap distribuito AWS CDK . Ad esempio: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-bootstrap-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  SALTA LA DISTRIBUZIONE  |  Il valore di `true` indica che la distribuzione dello stack di AWS CDK bootstrap è stata ignorata durante l'esecuzione del flusso di lavoro. Una distribuzione dello stack verrà ignorata se non vi sono modifiche nello stack dall'ultima distribuzione. Questa variabile viene prodotta solo se il suo valore è. `true` Codificato in. `true`  | 

# azione 'AWS CDK bootstrap' YAML
<a name="cdk-boot-action-ref"></a>

**Di seguito è riportata la definizione YAML dell'azione bootstrap.AWS CDK ** Per informazioni su come utilizzare questa azione, consulta. [Avvio di un' AWS CDK app con un flusso di lavoro](cdk-boot-action.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.    
  CDKBootstrapAction\$1nn: 
    Identifier: aws/cdk-bootstrap@v2
    DependsOn:
      - action-name
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_bootstrap_artifacts
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      Region: us-west-2
      CdkCliVersion: version
```

## CDKBootstrapAction
<a name="cdk.boot.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: `CDKBootstrapAction_nn`.

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

## Identifier
<a name="cdk.boot.identifier"></a>

(*CDKBootstrapAction*/**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).

**Nota**  
La specificazione `aws/cdk-bootstrap@v2` causa l'esecuzione dell'azione sull'[immagine di marzo 2024](build-images.md#build.default-image) che include strumenti più recenti come Node.js 18. La specifica `aws/cdk-bootstrap@v1` fa sì che l'azione venga eseguita sull'[immagine di novembre 2022](build-images.md#build.previous-image) che include strumenti meno recenti come Node.js 16.

Default: `aws/cdk-bootstrap@v2`.

**Interfaccia utente corrispondente: Workflow diagram/ \$1nn/ CDKBootstrapAction aws/cdk-bootstrap @v2 label**

## DependsOn
<a name="cdk.boot.dependson"></a>

(*CDKBootstrapAction*/**DependsOn**)

(Facoltativo)

Specificate un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente per l'esecuzione di 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="cdk.boot.computename"></a>

(*CDKBootstrapAction*/**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="cdk.boot.computetype"></a>

(*CDKBootstrapAction*/Compute/**Type**)

(Obbligatorio se [Compute](#cdk.boot.computename) 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="cdk.boot.computefleet"></a>

(*CDKBootstrapAction*/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="cdk.boot.timeout"></a>

(*CDKBootstrapAction*/**Timeout**)

(Obbligatorio)

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

## Inputs
<a name="cdk.boot.inputs"></a>

(*CDKBootstrapAction*/**Inputs**)

(Facoltativo)

La `Inputs` sezione definisce i dati necessari all'azione **AWS CDK bootstrap** durante l'esecuzione di un flusso di lavoro.

Interfaccia utente corrispondente: scheda **Input**

**Nota**  
**È consentito un solo input (fonte o artefatto) per ogni AWS CDK azione di bootstrap.**

## Sources
<a name="cdk.boot.inputs.sources"></a>

(*CDKBootstrapAction*/Inputs/**Sources**)

(Richiesto se AWS CDK l'app è archiviata in un archivio di origine)

Se AWS CDK l'app è archiviata in un repository di origine, specifica l'etichetta di tale repository di origine. L'azione **AWS CDK bootstrap** sintetizza l'app in questo repository prima di avviare il processo di bootstrap. Attualmente, l'unica etichetta di repository supportata è. `WorkflowSource`

Se AWS CDK l'app non è contenuta 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="cdk.boot.inputs.artifacts"></a>

(*CDKBootstrapAction*/Inputs/**Artifacts**)

(Richiesto se AWS CDK l'app è memorizzata in un elemento [di output di un'azione precedente](workflows-working-artifacts-output.md))

Se la tua AWS CDK app è contenuta in un artefatto generato da un'azione precedente, specifica quell'artefatto qui. L'azione **AWS CDK bootstrap** sintetizza l'app nell'artefatto specificato in un modello prima di iniziare il processo di avvio. CloudFormation Se AWS CDK l'app non è contenuta 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 Input/Artifacts - opzionale**

## Outputs
<a name="cdk.boot.outputs"></a>

(*CDKBootstrapAction*/**Outputs**)

(Facoltativo)

Definisce i dati emessi dall'azione durante l'esecuzione di un flusso di lavoro.

Interfaccia utente corrispondente: **scheda Output**

## Artifacts - output
<a name="cdk.boot.outputs.artifacts"></a>

(*CDKBootstrapAction*/Outputs/**Artifacts**)

(Facoltativo)

Specificate gli artefatti generati dall'azione. È possibile fare riferimento a questi artefatti come input in altre azioni.

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

**Interfaccia utente corrispondente: scheda Outputs/Artifacts**

## Name
<a name="cdk.boot.outputs.artifacts.name"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Name**)

(Richiesto se incluso) [Artifacts - output](#cdk.boot.outputs.artifacts)

Specificate il nome dell'elemento che conterrà il CloudFormation modello sintetizzato dall'azione **AWS CDK bootstrap** in fase di esecuzione. Il valore predefinito è `cdk_bootstrap_artifacts`. Se non specificate un artefatto, l'azione sintetizza il modello, ma non lo salva in un artefatto. Valuta la possibilità di salvare il modello sintetizzato in un artefatto per conservarne una registrazione a scopo di test o risoluzione dei problemi.

**Interfaccia utente corrispondente: restituisce il nome dell'artefatto/crea l'artefatto tab/Artifacts/Add**

## Files
<a name="cdk.boot.outputs.artifacts.files"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Files**)

(Obbligatorio se incluso) [Artifacts - output](#cdk.boot.outputs.artifacts)

Specificate i file da includere nell'artefatto. È necessario specificare `"cdk.out/**/*"` di includere il modello sintetizzato CloudFormation dell' AWS CDK app.

**Nota**  
`cdk.out`è la directory predefinita in cui vengono salvati i file sintetizzati. Se avete specificato una directory di output diversa `cdk.out` da quella `cdk.json` del file, specificate quella directory qui invece di. `cdk.out`

**Interfaccia utente corrispondente: restituisce tab/Artifacts/Add artefatti/file prodotti da build**

## Environment
<a name="cdk.boot.environment"></a>

(*CDKBootstrapAction*/**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="cdk.boot.environment.name"></a>

(*CDKBootstrapAction*/Environment/**Name**)

(Richiesto se [Environment](#cdk.boot.environment) incluso)

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

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

## Connections
<a name="cdk.boot.environment.connections"></a>

(*CDKBootstrapAction*/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="cdk.boot.environment.connections.name"></a>

(*CDKBootstrapAction*/Environment/Connections/**Name**)

(Richiesto se è incluso[Connections](#cdk.boot.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="cdk.boot.environment.connections.role"></a>

(*CDKBootstrapAction*/Environment/Connections/**Role**)

(Richiesto se è incluso[Connections](#cdk.boot.environment.connections))

Specificate il nome del ruolo IAM utilizzato dall'azione **AWS CDK bootstrap** per accedere AWS e aggiungere lo stack di bootstrap. 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 politiche appropriate.

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

## Configuration
<a name="cdk.boot.configuration"></a>

(*CDKBootstrapAction*/**Configuration**)

(Obbligatorio)

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

Interfaccia utente corrispondente: scheda **Configurazione**

## Region
<a name="cdk.boot.region"></a>

(*CDKBootstrapAction*/Configuration/**Region**)

(Obbligatorio)

Specificare Regione AWS in che modo verrà distribuito lo stack di bootstrap. Questa regione deve corrispondere a quella in cui viene distribuita AWS CDK l'app. Per un elenco dei codici regionali, consulta [Endpoint regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

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

## CdkCliVersion
<a name="cdk.boot.cdk.cli.version"></a>

(*CDKBootstrapAction*/Configuration/**CdkCliVersion**)

(Facoltativo)

**Questa proprietà è disponibile con la versione 1.0.13 o successiva dell'azione **AWS CDK deploy** e la versione 1.0.8 o successiva dell'azione bootstrap.AWS CDK **

Specifica una delle seguenti proprietà:
+ La versione completa dell'interfaccia a riga di AWS Cloud Development Kit (AWS CDK) comando (CLI) (chiamata anche AWS CDK Toolkit) che si desidera utilizzare con questa azione. Esempio: `2.102.1`. Valuta la possibilità di specificare una versione completa per garantire coerenza e stabilità durante la creazione e la distribuzione dell'applicazione.

  Or
+ `latest`. Valuta la possibilità `latest` di specificare se sfruttare le funzionalità e le correzioni più recenti della CLI CDK.

L'azione scaricherà la versione specificata (o la versione più recente) della AWS CDK CLI nell'[immagine di CodeCatalyst build](build-images.md), quindi utilizzerà questa versione per eseguire i comandi necessari per distribuire l'applicazione CDK o avviare il proprio ambiente. AWS 

[Per un elenco delle versioni CDK CLI supportate che puoi utilizzare,AWS CDK consulta Versioni.](https://docs.aws.amazon.com/cdk/api/versions.html)

Se si omette questa proprietà, l'azione utilizza una versione AWS CDK CLI predefinita descritta in uno dei seguenti argomenti:
+ [Versioni CDK CLI utilizzate dall'azione 'deploy'AWS CDK](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [Versioni CDK CLI utilizzate dall'azione AWS CDK "bootstrap»](cdk-boot-action.md#cdk-boot-action-cdk-version)

Interfaccia utente corrispondente: scheda di configurazione/versione **AWS CDK CLI**

# Pubblicazione di file su Amazon S3 con un flusso di lavoro
<a name="s3-pub-action"></a>

Questa sezione descrive come pubblicare file su Amazon S3 utilizzando un CodeCatalyst flusso di lavoro. A tale scopo, devi aggiungere l'azione di pubblicazione di **Amazon S3** al tuo flusso di lavoro. L'azione di **pubblicazione di Amazon S3** copia i file da una directory di origine a un bucket Amazon S3. La directory dei sorgenti può risiedere in:
+ Un [repository di origine](source.md), oppure 
+ Un [artefatto di output](workflows-working-artifacts.md) generato da un'altra azione del flusso di lavoro

**Topics**
+ [Quando usare l'azione «Pubblica su Amazon S3»](#s3-pub-action-when-to-use)
+ [Immagine di runtime utilizzata dall'azione 'Amazon S3 publish'](#s3-pub-action-runtime)
+ [Esempio: pubblicazione di file su Amazon S3](s3-pub-action-example-workflow.md)
+ [Aggiungere l'azione «Amazon S3 publish»](s3-pub-action-add.md)
+ [Azione «pubblicazione Amazon S3» YAML](s3-pub-action-ref.md)

## Quando usare l'azione «Pubblica su Amazon S3»
<a name="s3-pub-action-when-to-use"></a>

Usa questa azione se:
+ Hai un flusso di lavoro che genera file che desideri archiviare in Amazon S3.

  Ad esempio, potresti avere un flusso di lavoro che crea un sito Web statico da ospitare in Amazon S3. In questo caso, il flusso di lavoro includerebbe un'[azione di compilazione](build-add-action.md) per creare il codice HTML e i file di supporto del sito e un'azione di **pubblicazione di Amazon S3** per copiare i file su Amazon S3.
+ Hai un repository di origine che contiene i file che desideri archiviare in Amazon S3.

  Ad esempio, potresti avere un repository di sorgenti con i file sorgente delle applicazioni che desideri archiviare ogni notte su Amazon S3.

## Immagine di runtime utilizzata dall'azione 'Amazon S3 publish'
<a name="s3-pub-action-runtime"></a>

L'azione di **pubblicazione di Amazon S3** 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).

# Esempio: pubblicazione di file su Amazon S3
<a name="s3-pub-action-example-workflow"></a>

Il seguente flusso di lavoro di esempio include l'azione di **pubblicazione di Amazon S3**, insieme a un'azione di compilazione. Il flusso di lavoro crea un sito Web di documentazione statico e quindi lo pubblica su Amazon S3, dove è ospitato. 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** (`BuildDocs`): all'attivazione, l'azione crea un sito Web di documentazione statico (`mkdocs build`) e aggiunge i file HTML associati e i metadati di supporto a un elemento chiamato. `MyDocsSite` Per ulteriori informazioni sull'azione di compilazione, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md)
+ Un'azione di **pubblicazione di Amazon S3** (`PublishToS3`): al termine dell'azione di creazione, questa azione copia il sito nell'`MyDocsSite`artefatto su Amazon S3 per l'hosting.

**Nota**  
Il seguente esempio di flusso di lavoro è a scopo illustrativo e non funzionerà senza una configurazione aggiuntiva.

**Nota**  
Nel codice YAML che segue, puoi omettere la `Connections:` sezione se lo desideri. Se ometti questa sezione, devi assicurarti che il ruolo specificato nel campo Ruolo **IAM predefinito** nel tuo ambiente includa le autorizzazioni e le policy di fiducia richieste dall'azione di pubblicazione di **Amazon S3**. Per ulteriori informazioni sulla configurazione di un ambiente con un ruolo IAM predefinito, consulta. [Creazione di un ambiente](deploy-environments-creating-environment.md) Per ulteriori informazioni sulle autorizzazioni e sulle politiche di attendibilità richieste dall'azione di pubblicazione di **Amazon S3**, consulta la descrizione della proprietà [Role](s3-pub-action-ref.md#s3.pub.environment.connections.role) nel. [Azione «pubblicazione Amazon S3» YAML](s3-pub-action-ref.md)

```
Name: codecatalyst-s3-publish-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildDocs:
    Identifier: aws/build@v1
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo BuildDocs started on `date`
        - Run: pip install --upgrade pip
        - Run: pip install mkdocs
        - Run: mkdocs build
        - Run: echo BuildDocs completed on `date`
    Outputs:
      Artifacts:
      - Name: MyDocsSite
        Files:
          - "site/**/*"
        
  PublishToS3:
    Identifier: aws/s3-publish@v1
    Environment:
      Name: codecatalyst-s3-publish-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-s3-publish-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Artifacts:
        - MyDocsSite
    Configuration:      
      DestinationBucketName: amzn-s3-demo-bucket
      SourcePath: /artifacts/PublishToS3/MyDocSite/site
      TargetPath: my/docs/site
```

# Aggiungere l'azione «Amazon S3 publish»
<a name="s3-pub-action-add"></a>

 Utilizza le seguenti istruzioni per aggiungere l'azione di **pubblicazione di Amazon S3** al tuo flusso di lavoro. 

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

**Per aggiungere l'azione «Amazon S3 publish» utilizzando l'editor visuale**

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 **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 di **pubblicazione di Amazon S3** 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 **Amazon S3** Publish. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
     + (Facoltativo) Scegliete **Visualizza sorgente** 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 aprire il relativo riquadro di configurazione.

1. Nelle schede **Ingressi**, **Configurazione** e **Uscite**, completa i campi in base alle tue esigenze. Per una descrizione di ogni campo, consulta la. [Azione «pubblicazione Amazon S3» YAML](s3-pub-action-ref.md) Questo riferimento fornisce informazioni dettagliate su ogni campo (e sul 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, quindi scegliete nuovamente Commit.**

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

**Per aggiungere l'azione «Amazon S3 publish» 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 di **pubblicazione di Amazon S3** 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 **Amazon S3** Publish. Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
     + (Facoltativo) Scegliete **Visualizza sorgente** 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 aprire il relativo riquadro di configurazione.

1. Modifica le proprietà del codice YAML in base alle tue esigenze. Una spiegazione di ogni proprietà disponibile è fornita in. [Azione «pubblicazione Amazon S3» YAML](s3-pub-action-ref.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, quindi scegliete nuovamente Commit.**

------

# Azione «pubblicazione Amazon S3» YAML
<a name="s3-pub-action-ref"></a>

Di seguito è riportata la definizione YAML dell'azione di pubblicazione di **Amazon S3**. Per informazioni su come utilizzare questa azione, consulta. [Pubblicazione di file su Amazon S3 con un flusso di lavoro](s3-pub-action.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.    
  S3Publish\$1nn: 
    Identifier: aws/s3-publish@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
      Variables:
        - Name: variable-name-1
          Value: variable-value-1
        - Name: variable-name-2
          Value: variable-value-2
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      SourcePath: my/source
      DestinationBucketName: amzn-s3-demo-bucket
      TargetPath: my/target
```

## S3Publish
<a name="s3.pub.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: `S3Publish_nn`.

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

## Identifier
<a name="s3.pub.identifier"></a>

(*S3Publish*/**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/s3-publish@v1`.

**Interfaccia utente corrispondente: Workflow diagram/ S3Publish \$1nn/ aws/s3-publish @v1 label**

## DependsOn
<a name="s3.pub.dependson"></a>

(*S3Publish*/**DependsOn**)

(Facoltativo)

Specificate un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente affinché questa azione venga eseguita.

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="s3.pub.computename"></a>

(*S3Publish*/**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="s3.pub.computetype"></a>

(*S3Publish*/Compute/**Type**)

(Obbligatorio se [Compute](#s3.pub.computename) 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: scheda di configurazione/tipo di calcolo**

## Fleet
<a name="s3.pub.computefleet"></a>

(*S3Publish*/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: scheda di configurazione/parco di calcolo**

## Timeout
<a name="s3.pub.timeout"></a>

(*S3Publish*/**Timeout**)

(Obbligatorio)

Specificate il periodo di tempo, in minuti (editor YAML) o ore e minuti (editor visivo), che l'azione può essere eseguita prima CodeCatalyst che termini l'azione. 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**

## Inputs
<a name="s3.pub.inputs"></a>

(*S3Publish*/**Inputs**)

(Facoltativo)

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

**Nota**  
**Sono consentiti un massimo di quattro input (una fonte e tre artefatti) per ogni AWS CDK azione di distribuzione.** Le variabili non vengono conteggiate per questo totale.

Se è necessario fare riferimento a file che risiedono in input diversi (ad esempio una sorgente e un artefatto), l'input di origine è l'input principale e l'artefatto è l'input secondario. I riferimenti ai file negli input secondari richiedono un prefisso speciale per distinguerli dal primario. Per informazioni dettagliate, vedi [Esempio: riferimento a file in più artefatti](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

**Interfaccia utente corrispondente: scheda Ingressi**

## Sources
<a name="s3.pub.inputs.sources"></a>

(*S3Publish*/Inputs/**Sources**)

(Obbligatorio se i file che desideri pubblicare su Amazon S3 sono archiviati in un repository di origine)

Se i file che desideri pubblicare su Amazon S3 sono archiviati in un repository di origine, specifica l'etichetta di tale repository di origine. Attualmente, l'unica etichetta supportata è. `WorkflowSource`

Se i file che desideri pubblicare su Amazon S3 non sono contenuti in un repository di origine, devono 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="s3.pub.inputs.artifacts"></a>

(*S3Publish*/Inputs/**Artifacts**)

(Obbligatorio se i file che desideri pubblicare su Amazon S3 sono archiviati in un elemento [di output di un'azione precedente](workflows-working-artifacts-output.md))

Se i file che desideri pubblicare su Amazon S3 sono contenuti in un artefatto generato da un'azione precedente, specifica tale elemento qui. Se i tuoi file non sono contenuti in un artefatto, devono risiedere nel tuo 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**

## Variables - input
<a name="s3.pub.inputs.variables"></a>

(*S3Publish*/Inputs/**Variables**)

(Facoltativo)

Specificate una sequenza di name/value coppie che definisca le variabili di input che desiderate rendere disponibili all'azione. I nomi delle variabili 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 variabili.

Per ulteriori informazioni sulle variabili, inclusi esempi, vedere[Utilizzo delle variabili nei flussi di lavoro](workflows-working-with-variables.md).

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

## Environment
<a name="s3.pub.environment"></a>

(*S3Publish*/**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="s3.pub.environment.name"></a>

(*S3Publish*/Environment/**Name**)

(Richiesto se [Environment](#s3.pub.environment) incluso)

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

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

## Connections
<a name="s3.pub.environment.connections"></a>

(*S3Publish*/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="s3.pub.environment.connections.name"></a>

(*S3Publish*/Environment/Connections/**Name**)

(Richiesto se è incluso[Connections](#s3.pub.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="s3.pub.environment.connections.role"></a>

(*S3Publish*/Environment/Connections/**Role**)

(Richiesto se è incluso[Connections](#s3.pub.environment.connections))

Specificare il nome del ruolo IAM utilizzato dall'azione di **pubblicazione di Amazon S3** per accedere AWS e copiare i file su Amazon S3. 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": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "s3:PutObject",
                  "s3:ListBucket",
                  "s3:DeleteObject"
              ],
              "Resource": [
                  "arn:aws:s3:::bucket-name",
                  "arn:aws:s3:::bucket-name/*"
              ]
          }
      ]
  }
  ```

------
+ 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**

## Configuration
<a name="s3.pub.configuration"></a>

(*S3Publish*/**Configuration**)

(Obbligatorio)

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

Interfaccia utente corrispondente: scheda **Configurazione**

## SourcePath
<a name="s3.pub.source.directory"></a>

(*S3Publish*/Configuration/**SourcePath**)

(Obbligatorio)

Specificare il nome e il percorso di una directory o di un file che si desidera pubblicare su Amazon S3. La directory o il file possono risiedere in un repository di origine o in un elemento di un'azione precedente ed è relativo al repository di origine o alla radice dell'artefatto.

Esempi:

Specificando `./myFolder/` copia il contenuto di su Amazon S3 e `/myFolder` preserva la struttura di directory sottostante.

Specificare `./myFolder/myfile.txt` copie *solo* `myfile.txt` su Amazon S3. (La struttura delle cartelle viene rimossa).

Non è possibile utilizzare i caratteri jolly.

**Nota**  
Potrebbe essere necessario aggiungere un prefisso alla directory o al percorso del file per indicare in quale elemento o fonte trovarlo. Per ulteriori informazioni, consultare [Riferimento ai file del repository di origine](workflows-sources-reference-files.md) e [Riferimento ai file in un artefatto](workflows-working-artifacts-refer-files.md).

**Interfaccia utente corrispondente: scheda di configurazione/percorso di origine**

## DestinationBucketName
<a name="s3.pub.dest.bucket"></a>

(*S3Publish*/Configuration/**DestinationBucketName**)

(Obbligatorio)

Specificate il nome del bucket Amazon S3 in cui desiderate pubblicare i file.

Interfaccia utente corrispondente: scheda di configurazione/bucket di **destinazione** - opzionale

## TargetPath
<a name="s3.pub.dest.directory"></a>

(*S3Publish*/Configuration/**TargetPath**)

(Facoltativo)

Specificate il nome e il percorso della directory in Amazon S3 in cui desiderate pubblicare i file. Se la directory non esiste, verrà creata. Il percorso della directory non deve includere il nome del bucket.

Esempi:

`myS3Folder`

`./myS3Folder/myS3Subfolder`

Interfaccia utente corrispondente: scheda di **configurazione/directory di destinazione** - opzionale

# Implementazione in e Account AWS VPCs
<a name="deploy-environments"></a>

Utilizzando [CodeCatalyst i flussi](workflow.md) di lavoro, puoi distribuire applicazioni e altre risorse per targetizzare Account AWS s e Amazon VPCs nel AWS cloud. Per abilitare queste implementazioni, devi configurare ambienti. CodeCatalyst 

Un CodeCatalyst *ambiente*, da non confondere con un [ambiente di sviluppo](https://docs.aws.amazon.com/codecatalyst/latest/userguide/devenvironment.html), definisce l'Amazon VPC di destinazione Account AWS e opzionale a cui si connette un CodeCatalyst [flusso di lavoro](workflow.md). Un ambiente definisce anche il [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) necessario a un flusso di lavoro per accedere ai AWS servizi e alle risorse all'interno dell'account di destinazione.

È possibile configurare più ambienti e assegnare loro nomi come sviluppo, test, staging e produzione. Quando si esegue la distribuzione in questi ambienti, le informazioni sulle distribuzioni vengono visualizzate nelle schede CodeCatalyst **Deployment activity** e **Deployment targets** dell'ambiente.

## Come posso iniziare a usare gli ambienti?
<a name="deploy-environments-get-started"></a>

I passaggi di alto livello per aggiungere e utilizzare un CodeCatalyst ambiente sono i seguenti:

1. Nel tuo CodeCatalyst spazio, **collega uno o più AWS account**. Durante questo processo, aggiungi i ruoli IAM necessari al tuo flusso di lavoro per accedere alle risorse del tuo Account AWS. Per ulteriori informazioni, consulta [Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md).

1. Nel tuo CodeCatalyst progetto, **crea un ambiente** che includa uno dei ruoli Account AWS s e IAM della fase 1. Per ulteriori informazioni, consulta [Creazione di un ambiente](deploy-environments-creating-environment.md).

1. Nel tuo CodeCatalyst progetto, in un flusso di lavoro, **aggiungi un'[azione](workflows-actions.md) che rimanda all'ambiente** che hai creato nel passaggio 2. Per ulteriori informazioni, consulta [Aggiungere un'azione a un flusso di lavoro](workflows-add-action.md).

   Ora hai configurato un ambiente. L'azione può ora distribuire risorse nell'ambiente Account AWS specificato.

**Nota**  
Puoi anche aggiungere un Amazon VPC all'ambiente. Per ulteriori informazioni, vedere [Aggiungere connessioni VPC per uno spazio](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) nella *Guida all'CodeCatalyst amministrazione* e. [Associazione di un VPC a un ambiente](deploy-environments-associate-vpc.md)

## Possono esistere più ambienti all'interno di un unico flusso di lavoro?
<a name="deploy-environments-multiple"></a>

Sì. Se un flusso di lavoro include più azioni, a ciascuna di esse può essere assegnato un ambiente. Ad esempio, è possibile disporre di un flusso di lavoro che include due azioni di distribuzione, in cui a una viene assegnato un `my-staging-enviroment` ambiente e all'altra viene assegnato un `my-production-environment` ambiente.

## Quali azioni del flusso di lavoro supportano gli ambienti?
<a name="deploy-environments-supported"></a>

Qualsiasi azione del flusso di lavoro che distribuisce risorse nel AWS cloud o comunica con i AWS servizi per altri motivi (come il monitoraggio e il reporting), supporta gli ambienti.

## Quali azioni supportano la visualizzazione delle informazioni sulla distribuzione in? CodeCatalyst
<a name="deploy-environments-supported-targets"></a>

Tra le azioni del flusso di lavoro che supportano gli ambienti, solo alcune supportano la visualizzazione delle informazioni sulla **distribuzione nelle pagine Attività** di **distribuzione e Target** di distribuzione della CodeCatalyst console.

Le seguenti azioni del flusso di lavoro supportano la visualizzazione delle relative informazioni di distribuzione:
+ **Deploy CloudFormation stack**: per ulteriori informazioni, vedere [Implementazione di uno stack CloudFormation](deploy-action-cfn.md)
+ **Implementazione su Amazon ECS**: per ulteriori informazioni, consulta [Distribuzione su Amazon ECS con un flusso di lavoro](deploy-action-ecs.md)
+ **Esegui la distribuzione su un cluster Kubernetes**: per ulteriori informazioni, consulta [Implementazione su Amazon EKS con un flusso di lavoro](deploy-action-eks.md)
+ **AWS CDK deploy: per ulteriori informazioni,** consulta [Implementazione di un' AWS CDK app con un flusso di lavoro](cdk-dep-action.md)

## Regioni supportate
<a name="deploy-environments-supported-regions"></a>

La pagina **Ambienti** può visualizzare risorse in qualsiasi AWS regione.

## L'ambiente è obbligatorio?
<a name="deploy-environments-optional-or-mandatory"></a>

Un ambiente è obbligatorio se l'azione del flusso di lavoro a cui è assegnato distribuisce risorse nel AWS cloud o comunica con i AWS servizi per altri motivi (come il monitoraggio e il reporting).

Ad esempio, se hai un'azione di compilazione che crea un'applicazione ma non ha bisogno di comunicare con il tuo Account AWS o con Amazon VPC, non è necessario assegnare un ambiente all'azione. Se, tuttavia, l'azione di compilazione invia i log al CloudWatch servizio Amazon del tuo Account AWS, all'azione deve essere assegnato un ambiente. 

**Topics**
+ [Come posso iniziare a usare gli ambienti?](#deploy-environments-get-started)
+ [Possono esistere più ambienti all'interno di un unico flusso di lavoro?](#deploy-environments-multiple)
+ [Quali azioni del flusso di lavoro supportano gli ambienti?](#deploy-environments-supported)
+ [Quali azioni supportano la visualizzazione delle informazioni sulla distribuzione in? CodeCatalyst](#deploy-environments-supported-targets)
+ [Regioni supportate](#deploy-environments-supported-regions)
+ [L'ambiente è obbligatorio?](#deploy-environments-optional-or-mandatory)
+ [Creazione di un ambiente](deploy-environments-creating-environment.md)
+ [Associare un ambiente a un'azione](deploy-environments-add-app-to-environment.md)
+ [Associazione di un VPC a un ambiente](deploy-environments-associate-vpc.md)
+ [Associare un a Account AWS un ambiente](deploy-environments-associate-account.md)
+ [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md)

# Creazione di un ambiente
<a name="deploy-environments-creating-environment"></a>

Utilizzate le seguenti istruzioni per creare un ambiente da associare successivamente a un'azione del flusso di lavoro.

**Prima di iniziare**

È necessario quanto segue:
+ Uno CodeCatalyst spazio. Per ulteriori informazioni, consulta [Configura e accedi a CodeCatalystConfigura e accedi a CodeCatalyst](setting-up-topnode.md).
+ Un CodeCatalyst progetto. Per ulteriori informazioni, consulta [Creare un progetto con un blueprint](projects-create.md#projects-create-console-template).
+ Una connessione all' AWS account che include i ruoli IAM a cui dovrà accedere l'azione del workflow AWS. Per informazioni sulla creazione di una connessione all'account, consulta[Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md). È possibile utilizzare al massimo una connessione a un account per ambiente.
**Nota**  
È possibile creare un ambiente senza una connessione all'account; tuttavia, sarà necessario tornare indietro e aggiungere la connessione in un secondo momento.
+ Uno dei seguenti CodeCatalyst ruoli:
  + **Amministratore dello spazio**
  + **Amministratore del progetto**
  + **Collaboratore**
**Nota**  
Se hai il **ruolo di Collaboratore**, sarai in grado di creare un ambiente ma non potrai associarlo a una Account AWS connessione. Dovrai chiedere a qualcuno con il ruolo di **amministratore dello spazio** o di **amministratore del progetto** di associare l'ambiente a una Account AWS connessione.

   Per ulteriori informazioni su autorizzazioni e ruoli, consulta[Concessione delle autorizzazioni di progetto agli utenti](projects-members.md).

**Come creare un ambiente**

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 Ambienti.**

1. In **Nome ambiente**, inserisci un nome, ad esempio **Production** o. **Staging**

1. In **Tipo di ambiente**, selezionate una delle seguenti opzioni:
   + **Non di produzione**: un ambiente in cui è possibile testare l'applicazione per assicurarsi che funzioni come previsto prima di passare alla produzione.
   + **Produzione**: un ambiente «live» disponibile al pubblico che ospita l'applicazione definitiva.

     Se scegli **Produzione**, nell'interfaccia utente viene visualizzato un badge di **produzione** accanto a tutte le azioni a cui è associato l'ambiente. Il badge ti aiuta a vedere rapidamente quali azioni vengono implementate nella produzione. Oltre all'aspetto del badge, non ci sono differenze tra ambienti di produzione e non di produzione.

1. (Facoltativo) In **Descrizione**, inserisci una descrizione come. **Production environment for the hello-world app**

1. In **Account AWS Connessione: facoltativo**, scegli la connessione AWS dell'account che desideri associare a questo ambiente. Le azioni del flusso di lavoro assegnate a questo ambiente potranno connettersi a quello associato Account AWS. Per ulteriori informazioni sulla creazione di Account AWS connessioni in CodeCatalyst, vedere[Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md).

   Se la Account AWS connessione che desideri utilizzare non è elencata, è possibile che non sia consentita nel progetto. Per ulteriori informazioni, consulta [Configurazione delle connessioni di account con restrizioni del progetto](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) nella *Amazon CodeCatalyst * Administrator Guide.

1. Nel **ruolo IAM predefinito**, scegli il ruolo IAM che desideri associare a questo ambiente. Le azioni del flusso di lavoro assegnate a questo ambiente erediteranno questo ruolo IAM e potranno utilizzarlo per connettersi ai servizi e alle risorse del tuo Account AWS.

   Se devi assegnare l'ambiente a più azioni e tali azioni richiedono ruoli IAM diversi da quello predefinito qui specificato, puoi specificare i diversi ruoli nella scheda **Configurazione** di ciascuna azione, utilizzando l'**opzione Switch role**. Per ulteriori informazioni, consulta [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md).

   Se il ruolo IAM che desideri utilizzare come predefinito non è elencato, potrebbe essere perché non lo hai ancora aggiunto alla tua Account AWS connessione. Per aggiungere un ruolo IAM alla connessione di un account, consulta[Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md).

1. (Facoltativo) Nella **connessione VPC**, scegli una connessione VPC che desideri associare a questo ambiente. Per ulteriori informazioni sulla creazione di connessioni VPC, consulta Managing [Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) nella *Amazon CodeCatalyst Administrator Guide*.

   Se la connessione VPC che desideri utilizzare non è elencata, potrebbe essere perché include una Account AWS connessione non consentita nel tuo progetto. Per ulteriori informazioni, consulta [Configurazione delle connessioni di account con restrizioni del progetto](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) nella *Amazon CodeCatalyst * Administrator Guide.

1. **Scegli Crea ambiente.** CodeCatalyst crea un ambiente vuoto.

**Fasi successive**
+ Ora che hai creato un ambiente, sei pronto per associarlo a un'azione del flusso di lavoro. Per ulteriori informazioni, consulta [Associare un ambiente a un'azione](deploy-environments-add-app-to-environment.md).

# Associare un ambiente a un'azione
<a name="deploy-environments-add-app-to-environment"></a>

Quando associ un ambiente a un'[azione di workflow supportata](deploy-environments.md#deploy-environments-supported), all'azione vengono assegnati l'ambiente, il ruolo IAM predefinito e Amazon VPC opzionale. Account AWS L'azione può quindi connettersi e implementare al ruolo Account AWS Using the IAM e connettersi anche all'Amazon VPC opzionale.

Utilizza le seguenti istruzioni per associare un ambiente a un'azione.

## Fase 1: Associare l'ambiente a un'azione del flusso di lavoro
<a name="deploy-environments-add-app-to-environment-assoc"></a>

Utilizzare la procedura seguente per associare un ambiente a un'azione del flusso di lavoro.

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

**Per associare un ambiente a un'azione del flusso di lavoro utilizzando l'editor visivo**

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. Nel diagramma del flusso di lavoro, scegli un'azione supportata dagli ambienti. Per ulteriori informazioni, consulta [Quali azioni supportano la visualizzazione delle informazioni sulla distribuzione in? CodeCatalyst](deploy-environments.md#deploy-environments-supported-targets).

1. Scegliete la scheda **Configurazione** e specificate le informazioni nel campo **Ambiente**, come segue.

   **Ambiente**

   Specificate 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).

1. (Facoltativo) Modifica il ruolo IAM associato all'azione. Potresti voler cambiare il ruolo se contiene il set di autorizzazioni errato per l'azione.

    Per cambiare il ruolo:

   1. Nella sezione **Cosa c'è dentro*my-environment*?** casella e scegliete l'icona con i puntini di sospensione verticali ()![\[Ellipsis.\]](http://docs.aws.amazon.com/it_it/codecatalyst/latest/userguide/images/flows/elipsis.png).

   1. Seleziona una delle seguenti opzioni:
      +  **Cambia ruolo**. Scegli questa opzione per modificare il ruolo IAM utilizzato da questa azione e solo da questa azione. Altre azioni continuano a utilizzare il ruolo IAM predefinito specificato nell'ambiente associato. Per ulteriori informazioni, consulta [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md).
      +  **Modifica ambiente**. Scegli questa opzione per modificare il ruolo IAM predefinito elencato nel tuo ambiente. Quando scegli questa opzione, la tua azione, e qualsiasi altra azione associata allo stesso ambiente, inizia a utilizzare il nuovo ruolo IAM predefinito.
**Importante**  
Fai attenzione quando aggiorni il ruolo IAM predefinito. La modifica del ruolo potrebbe causare errori nelle azioni se le autorizzazioni relative al ruolo non sono sufficienti per tutte le azioni che condividono l'ambiente.

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 associare un ambiente a un'azione del flusso di lavoro utilizzando l'editor YAML**

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 **YAML**.

1. Nell'azione del flusso di lavoro che desideri associare a un ambiente, aggiungi un codice simile al seguente:

   ```
   action-name:
     Environment:
       Name: environment-name
   ```

   Per ulteriori informazioni, consulta l'[Tipi di operazione](workflows-actions.md#workflows-actions-types)argomento. Questo argomento contiene collegamenti alla documentazione per ogni azione, incluso il relativo riferimento YAML.

1. (Facoltativo) Se desideri che l'azione utilizzi un ruolo diverso dal ruolo IAM predefinito elencato nell'ambiente, aggiungi una `Connections:` sezione che includa il ruolo che desideri utilizzare. Per ulteriori informazioni, consulta [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md).

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

------

## Fase 2: Compila la pagina delle attività di distribuzione
<a name="deploy-environments-add-app-to-environment-run"></a>

Dopo aver associato un ambiente a un'azione del flusso di lavoro, è possibile compilare le pagine **Attività di distribuzione** **e Target** di distribuzione nella sezione **Ambienti** della CodeCatalyst console con informazioni sulla distribuzione. Utilizza le seguenti istruzioni per compilare queste pagine.

**Nota**  
Solo alcune azioni supportano la visualizzazione delle informazioni sulla distribuzione nella CodeCatalyst console. Per ulteriori informazioni, consulta [Quali azioni supportano la visualizzazione delle informazioni sulla distribuzione in? CodeCatalyst](deploy-environments.md#deploy-environments-supported-targets).

**Per aggiungere informazioni sulla distribuzione a CodeCatalyst**

1. Se l'esecuzione di un flusso di lavoro non si avvia automaticamente al momento del commit delle modifiche[Fase 1: Associare l'ambiente a un'azione del flusso di lavoro](#deploy-environments-add-app-to-environment-assoc), avvia manualmente un'esecuzione come segue:

   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 **Esegui**.

   L'esecuzione del flusso di lavoro avvia una nuova distribuzione, che comporta CodeCatalyst l'aggiunta di informazioni sulla distribuzione. CodeCatalyst

1. Verifica che l'attività di distribuzione sia stata aggiunta alla CodeCatalyst console:

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

   1. Scegli il tuo ambiente (ad esempio,`Production`).

   1. Scegli la scheda **Attività di distribuzione** e verifica che venga visualizzata una distribuzione con **lo stato** di **RIUSCITA**. Ciò indica che un flusso di lavoro eseguito ha distribuito correttamente le risorse dell'applicazione.

   1. Scegli la scheda **Obiettivi di distribuzione** e verifica che vengano visualizzate le risorse dell'applicazione.

# Associazione di un VPC a un ambiente
<a name="deploy-environments-associate-vpc"></a>

Quando un'azione è configurata con un ambiente che dispone di una connessione VPC, l'azione verrà eseguita connessa al VPC, rispettando le regole di rete e le risorse di accesso specificate dal VPC associato. La stessa connessione VPC può essere utilizzata da uno o più ambienti.

Utilizza le seguenti istruzioni per associare una connessione VPC a un ambiente.

**Per associare una connessione VPC a un ambiente**

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 Ambienti.**

1. Scegliete il vostro ambiente (ad esempio,`Production`).

1. Scegli la scheda delle **proprietà dell'ambiente**.

1. **Scegli **Gestisci connessione VPC, scegli la connessione** VPC desiderata e scegli Conferma.** Ciò associa la connessione VPC selezionata a questo ambiente.
**Nota**  
Se la connessione VPC che desideri utilizzare non è elencata, potrebbe essere perché include una Account AWS connessione non consentita nel tuo progetto. Per ulteriori informazioni, consulta [Configurazione delle connessioni di account con restrizioni del progetto](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) nella *Amazon CodeCatalyst* Administrator Guide.

Per ulteriori informazioni, consulta [Managing Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) nella *CodeCatalyst Administrator Guide*.

# Associare un a Account AWS un ambiente
<a name="deploy-environments-associate-account"></a>

Usa le seguenti istruzioni per Account AWS associare un uomo a un ambiente. Quando si associa un Account AWS ambiente, le azioni del flusso di lavoro assegnate all'ambiente potranno connettersi a Account AWS.

Per ulteriori informazioni sulle connessioni degli account, vedere[Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md).

**Prima di iniziare**

È necessario quanto segue:
+ Una connessione AWS all'account che includa i ruoli IAM a cui dovrà accedere l'azione del flusso di lavoro AWS. Per informazioni sulla creazione di una connessione all'account, consulta[Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md). È possibile utilizzare al massimo una connessione a un account per ambiente.
+ Uno dei seguenti CodeCatalyst ruoli: **amministratore dello spazio o amministratore** **del progetto**. Per ulteriori informazioni, consulta [Concessione delle autorizzazioni di progetto agli utenti](projects-members.md).

**Associare un uomo Account AWS a un ambiente**

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 Ambienti.**

1. Scegliete il vostro ambiente (ad esempio,`Production`).

1. Scegli **Modifica ambiente**.

1. In **Proprietà dell'ambiente**, nell'elenco a discesa **Account AWS Connessione - opzionale**, scegli quello che desideri. Account AWS

   Se la Account AWS connessione che desideri utilizzare non è elencata, è possibile che non sia consentita nel progetto. Per ulteriori informazioni, consulta [Configurazione delle connessioni di account con restrizioni del progetto](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) nella *Amazon CodeCatalyst * Administrator Guide.

1. Nel **ruolo IAM predefinito**, scegli il ruolo IAM che desideri associare a questo ambiente. Le azioni del flusso di lavoro assegnate a questo ambiente erediteranno questo ruolo IAM e potranno utilizzarlo per connettersi ai servizi e alle risorse del tuo Account AWS.

   Se il ruolo IAM che desideri utilizzare come predefinito non è elencato, potrebbe essere perché non lo hai ancora aggiunto alla tua Account AWS connessione. Per aggiungere un ruolo IAM alla connessione di un account, consulta[Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md).

# Modifica del ruolo IAM di un'azione
<a name="deploy-environments-switch-role"></a>

Per impostazione predefinita, quando si associa un [ambiente](deploy-environments.md) a un'[azione](workflows-actions.md) del flusso di lavoro, l'azione eredita il ruolo IAM predefinito specificato nell'ambiente. È possibile modificare questo comportamento in modo che l'azione utilizzi un ruolo diverso. Potresti volere che un'azione utilizzi un ruolo diverso se al ruolo IAM predefinito mancano le autorizzazioni necessarie all'azione per operare nel AWS cloud.

Per assegnare un ruolo IAM diverso a un'azione, puoi utilizzare l'opzione **Switch role** nell'editor visuale o la `Connections:` proprietà nell'editor YAML. Il nuovo ruolo sostituisce il ruolo IAM predefinito specificato nell'ambiente, consentendoti di mantenere il ruolo IAM predefinito così com'è. Potresti voler mantenere il ruolo IAM predefinito così com'è se ci sono altre azioni che lo utilizzano.

Utilizza le seguenti istruzioni per configurare un'azione per utilizzare un ruolo IAM diverso da quello specificato nel relativo ambiente.

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

**Per assegnare un ruolo IAM diverso a un'azione (editor visivo)**

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 la casella che rappresenta l'azione di cui desideri aggiornare il ruolo IAM.

1. Scegli la scheda **Configurazione**.

1. Nella sezione **Cosa c'è dentro*my-environment*?** casella, scegliete l'icona con i puntini di sospensione verticali ()![\[Ellipsis.\]](http://docs.aws.amazon.com/it_it/codecatalyst/latest/userguide/images/flows/elipsis.png).

1. Scegli **Cambia ruolo**.

1. Nella finestra di dialogo **Cambia ruolo**, nell'elenco a discesa del **ruolo IAM**, scegli il ruolo IAM che desideri venga utilizzato dall'azione. Questo ruolo sostituirà il ruolo IAM predefinito nell'ambiente. Se il ruolo che desideri utilizzare non è nell'elenco, assicurati di averlo aggiunto al tuo spazio. Per ulteriori informazioni, consulta [Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md).

   Il ruolo scelto viene ora visualizzato nella sezione **Cosa c'è in*my-environment*?** riquadro con il badge **Definito nel flusso di lavoro**. Il ruolo appare anche nel file di definizione del flusso di lavoro, nella `Connections:` sezione.

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 assegnare un ruolo IAM diverso a un'azione (editor YAML)**

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 **YAML**.

1. Nell'azione del flusso di lavoro in cui desideri utilizzare un ruolo IAM diverso, aggiungi una `Connections:` sezione simile alla seguente:

   ```
   action-name:
     Environment:
       Name: environment-name
       Connections: 
         - Name: account-connection-name
           Role: iam-role-name
   ```

   Nel codice precedente, sostituiscilo *account-connection-name* con il nome della [connessione all'account](ipa-connect-account.md) che contiene il ruolo IAM e *iam-role-name* sostituiscilo con il nome del ruolo IAM che desideri che l'azione utilizzi. Questo ruolo sostituirà il ruolo IAM predefinito nell'ambiente. Assicurati di aver aggiunto il ruolo al tuo spazio. Per ulteriori informazioni, consulta [Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md).

   Per ulteriori informazioni, consulta l'[Tipi di operazione](workflows-actions.md#workflows-actions-types)argomento. Questo argomento contiene collegamenti alla documentazione per ogni azione, incluso il relativo riferimento YAML.

------

# Visualizzazione dell'URL dell'app nel diagramma del flusso di lavoro
<a name="deploy-app-url"></a>

Se il tuo flusso di lavoro implementa un'applicazione, puoi configurare Amazon CodeCatalyst per visualizzare l'URL dell'applicazione come link cliccabile. Questo link appare nella CodeCatalyst console, all'interno dell'azione che lo ha distribuito. Il seguente diagramma del flusso di lavoro mostra l'URL **dell'app View** che appare nella parte inferiore di un'azione.

![\[Visualizza l'URL dell'app\]](http://docs.aws.amazon.com/it_it/codecatalyst/latest/userguide/images/deploy/view-app-url.png)


Rendendo cliccabile questo URL nella CodeCatalyst console, puoi verificare rapidamente la distribuzione dell'applicazione.

**Nota**  
L'URL dell'app non è supportato con l'**azione Deploy to Amazon ECS.**

Per abilitare questa funzionalità, aggiungi una variabile di output all'azione con un nome che contenga `appurl` o. `endpointurl` Puoi usare un nome con o senza un trattino di unione (`-`), un trattino basso (`_`) o uno spazio (` `). La stringa non fa distinzione tra maiuscole e minuscole. Imposta il valore della variabile `https` sull'URL `http` o dell'applicazione distribuita.

**Nota**  
Se stai aggiornando una variabile di output esistente per includere la `endpoint url` stringa o`app url`, aggiorna tutti i riferimenti a questa variabile per utilizzare il nuovo nome della variabile.

Per i passaggi dettagliati, consulta una delle seguenti procedure:
+ [Per visualizzare l'URL dell'app nell'azione "AWS CDK deploy»](#deploy-app-url-cdk)
+ [Per visualizzare l'URL dell'app nell'azione «Deploy CloudFormation stack»](#deploy-app-url-cfn)
+ [Per visualizzare l'URL dell'app in tutte le altre azioni](#deploy-app-url-other)

Al termine della configurazione dell'URL, verifica che appaia come previsto seguendo queste istruzioni:
+ [Per verificare che l'URL dell'applicazione sia stato aggiunto](#deploy-app-url-verify)<a name="deploy-app-url-cdk"></a>

**Per visualizzare l'URL dell'app nell'azione "AWS CDK deploy»**

1. Se utilizzi l'azione **AWS CDK deploy**, aggiungi un `CfnOutput` costrutto (che è una coppia chiave-valore) nel codice dell'applicazione: AWS CDK 
   + Il nome della chiave deve contenere`appurl`, o`endpointurl`, con o senza un trattino (), un trattino di sottolineatura (`-`) o uno spazio (`_`). ` ` La stringa non fa distinzione tra maiuscole e minuscole.
   + Il valore deve essere l'`https`URL `http` o l'URL dell'applicazione distribuita.

   Ad esempio, il AWS CDK codice potrebbe avere il seguente aspetto:

   ```
   import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
   import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
   import * as s3 from 'aws-cdk-lib/aws-s3';
   import { Construct } from 'constructs';
   import * as cdk from 'aws-cdk-lib';
   export class HelloCdkStack extends Stack {
     constructor(scope: Construct, id: string, props?: StackProps) {
       super(scope, id, props);
       const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
         removalPolicy: RemovalPolicy.DESTROY,
       });
       new CfnOutput(this, 'APP-URL', {
         value: https://mycompany.myapp.com,
         description: 'The URL of the deployed application',
         exportName: 'myApp',
       });
       ...
     }
   }
   ```

   Per ulteriori informazioni sul `CfnOutput` costrutto, consulta l'[interfaccia CfnOutputProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutputProps.html) nell'*AWS Cloud Development Kit (AWS CDK) API Reference.*

1. Salva e conferma il codice.

1. Passa a [Per verificare che l'URL dell'applicazione sia stato aggiunto](#deploy-app-url-verify).<a name="deploy-app-url-cfn"></a>

**Per visualizzare l'URL dell'app nell'azione «Deploy CloudFormation stack»**

1. Se utilizzi l'azione **Deploy CloudFormation stack**, aggiungi un output alla `Outputs` sezione del tuo CloudFormation modello o AWS SAM modello con queste caratteristiche:
   + La chiave (chiamata anche ID logico) deve contenere`appurl`, con o senza, un trattino di unione ()`endpointurl`, un trattino di sottolineatura (`-`) o uno `_` spazio (). ` ` La stringa non fa distinzione tra maiuscole e minuscole.
   + Il valore deve essere l'`https`URL `http` o l'URL dell'applicazione distribuita.

   Ad esempio, il CloudFormation modello potrebbe avere il seguente aspetto:

   ```
   "Outputs" : {
     "APP-URL" : {
       "Description" : "The URL of the deployed app",
       "Value" : "https://mycompany.myapp.com",
       "Export" : {
         "Name" : "My App"
       }
     }
   }
   ```

   Per ulteriori informazioni sugli CloudFormation output, consulta [Output nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html) per l'*AWS CloudFormation utente*.

1. Salva e conferma il codice.

1. Passa a [Per verificare che l'URL dell'applicazione sia stato aggiunto](#deploy-app-url-verify).<a name="deploy-app-url-other"></a>

**Per visualizzare l'URL dell'app in tutte le altre azioni**

Se stai utilizzando un'altra azione per distribuire l'applicazione, ad esempio l'azione di compilazione o **GitHub le azioni**, procedi come segue per visualizzare l'URL dell'app.

1. Definite una variabile di ambiente nella `Steps` sezione `Inputs` o nell'azione nel file di definizione del flusso di lavoro. La variabile deve avere le seguenti caratteristiche:
   + `name`Deve contenere`appurl`, o`endpointurl`, con o senza un trattino (`-`), un carattere di sottolineatura (`_`) o uno spazio (` `). La stringa non fa distinzione tra maiuscole e minuscole.
   + Il valore deve essere l'`https`URL `http` o l'URL dell'applicazione distribuita.

   Ad esempio, un'azione di compilazione potrebbe avere il seguente aspetto:

   ```
   Build-action:
     Identifier: aws/build@v1
     Inputs:
       Variables:
         - Name: APP-URL
           Value: https://mycompany.myapp.com
   ```

   ... o questo:

   ```
   Actions:
     Build:
       Identifier: aws/build@v1
       Configuration:    
         Steps:
           - Run: APP-URL=https://mycompany.myapp.com
   ```

   Per ulteriori informazioni sulla definizione delle variabili di ambiente, vedere[Definizione di una variabile](workflows-working-with-variables-define-input.md).

1. Esporta la variabile.

   Ad esempio, l'azione di compilazione potrebbe essere simile alla seguente:

   ```
   Build-action:
     ...
     Outputs:
       Variables:
         - APP-URL
   ```

   Per informazioni sull'esportazione delle variabili, consulta[Esportazione di una variabile in modo che altre azioni possano utilizzarla](workflows-working-with-variables-export-input.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.**

1. Passa a [Per verificare che l'URL dell'applicazione sia stato aggiunto](#deploy-app-url-verify).<a name="deploy-app-url-verify"></a>

**Per verificare che l'URL dell'applicazione sia stato aggiunto**
+ Avvia l'esecuzione di un flusso di lavoro, se non è stato avviato automaticamente. La nuova esecuzione dovrebbe avere l'URL dell'app visualizzato come collegamento cliccabile nel diagramma del flusso di lavoro. Per ulteriori informazioni sull'avvio delle esecuzioni, consulta. [Avvio manuale dell’esecuzione di un flusso di lavoro](workflows-manually-start.md) 

# Rimozione di un obiettivo di distribuzione
<a name="deploy-remove-target"></a>

Puoi rimuovere un obiettivo di distribuzione, ad esempio un cluster o uno CloudFormation stack Amazon ECS, dalla pagina **Destinazioni di distribuzione** nella CodeCatalyst console.

**Importante**  
Quando rimuovi un obiettivo di distribuzione, questo viene rimosso dalla CodeCatalyst console, ma rimane disponibile nel AWS servizio che lo ospita (se esiste ancora).

Prendi in considerazione la possibilità di rimuovere un obiettivo di distribuzione se il target è diventato obsoleto in CodeCatalyst. Gli obiettivi potrebbero diventare obsoleti se:
+ Hai eliminato il flusso di lavoro distribuito sulla destinazione.
+ Hai cambiato lo stack o il cluster in cui esegui la distribuzione. 
+ Hai eliminato lo stack o il cluster dal CloudFormation servizio Amazon ECS nella AWS console.

**Per rimuovere un obiettivo di distribuzione**

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 Ambienti.**

1. Scegli il nome dell'ambiente che contiene l'obiettivo di distribuzione che desideri rimuovere. Per informazioni sugli ambienti, consulta[Implementazione in e Account AWS VPCs](deploy-environments.md).

1. Scegli la scheda **Obiettivi di distribuzione**.

1. Scegli il pulsante di opzione accanto al target di distribuzione che desideri rimuovere.

1. Scegli **Rimuovi**.

   L'obiettivo viene rimosso dalla pagina.

# Monitoraggio dello stato di distribuzione tramite commit
<a name="track-changes"></a>

In qualsiasi momento del ciclo di vita dello sviluppo, è importante conoscere lo stato di implementazione di commit specifici, come correzioni di bug, nuove funzionalità o altre modifiche importanti. Considerate i seguenti scenari in cui la funzionalità di monitoraggio dello stato dell'implementazione è utile per i team di sviluppo:
+ In qualità di sviluppatore, hai apportato una correzione per correggere un bug e desideri segnalare lo stato della sua implementazione negli ambienti di distribuzione del tuo team.
+ In qualità di release manager, desideri visualizzare un elenco di commit distribuiti per monitorare e segnalare lo stato della distribuzione.

CodeCatalyst fornisce una visualizzazione che è possibile utilizzare per determinare a colpo d'occhio dove sono stati implementati i singoli commit o modifiche e in quale ambiente. Questa visualizzazione include: 
+ Un elenco di commit.
+ Lo stato delle distribuzioni che includono i commit.
+ Gli ambienti in cui i commit vengono distribuiti con successo.
+ Lo stato di tutti i test eseguiti rispetto ai commit nel flusso di lavoro. CI/CD 

La procedura seguente descrive in dettaglio come accedere a questa visualizzazione e utilizzarla per tenere traccia delle modifiche nel progetto.

**Nota**  
Il monitoraggio dello stato di distribuzione tramite commit è supportato solo con i [CodeCatalyst repository](source.md). Non è possibile utilizzare questa funzionalità con un [GitHub repository, un repository Bitbucket o un repository](extensions.md) di progetto. GitLab 

**Per tenere traccia dello stato della distribuzione tramite commit**

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 **Change** tracking.

1. Nei due elenchi a discesa nella parte superiore del riquadro principale, scegli il repository di origine e il ramo che contengono i commit di cui desideri visualizzare lo stato di rilascio.

1. **Scegli Visualizza modifiche.**

   Viene visualizzato un elenco di commit.

   Per ogni commit, puoi visualizzare quanto segue:
   + Conferma informazioni come ID, autore, messaggio e quando è stato eseguito il commit. Per ulteriori informazioni, consulta [Archivia e collabora sul codice con i repository di sorgenti in CodeCatalystArchivia e collabora sul codice con i repository di origine](source.md).
   + Lo stato delle implementazioni in ogni ambiente. Per ulteriori informazioni, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md).
   + Risultati dei test e della copertura del codice. Per ulteriori informazioni, consulta [Test con flussi di lavoroTest con flussi di lavoro](test-workflow-actions.md).
**Nota**  
I risultati dell'analisi della composizione del software (SCA) non vengono visualizzati.

1. (Facoltativo) Per visualizzare ulteriori informazioni sulle modifiche relative a un commit specifico, tra cui la distribuzione più recente e la copertura dettagliata del codice e le informazioni sui test unitari, scegli **Visualizza i dettagli** per quel commit.

# Visualizzazione dei log di distribuzione
<a name="deploy-deployment-logs"></a>

Puoi visualizzare i log relativi a specifiche azioni di distribuzione per risolvere i problemi in Amazon. CodeCatalyst

[Puoi visualizzare i log a partire da un [flusso](workflow.md) di lavoro o da un ambiente.](deploy-environments.md)

**Per visualizzare i registri di un'azione di distribuzione a partire da un flusso di lavoro**

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 **Esecuzioni**.

1. Scegli il flusso di lavoro eseguito che ha distribuito la tua applicazione.

1. Nel diagramma del flusso di lavoro, scegli l'azione di cui desideri visualizzare i log.

1. Scegli la scheda **Registri** ed espandi le sezioni per visualizzare i messaggi di registro.

1. Per visualizzare altri registri, scegli la scheda **Riepilogo**, quindi scegli **Visualizza in CloudFormation** (se disponibile) per visualizzarne altri. Potrebbe essere necessario accedere a. AWS

**Per visualizzare i log di un'azione di distribuzione a partire da un ambiente**

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 Ambienti.**

1. Scegli l'ambiente in cui è stata distribuita l'applicazione.

1. In **Attività di distribuzione**, trova la colonna **Workflow Run ID** e scegli l'esecuzione del flusso di lavoro che ha distribuito il tuo stack.

1. Nel diagramma del flusso di lavoro, scegli l'azione di cui desideri visualizzare i log.

1. Scegli la scheda **Registri** ed espandi le sezioni per visualizzare i messaggi di registro.

1. Per visualizzare altri registri, scegli la scheda **Riepilogo**, quindi scegli **Visualizza in CloudFormation** (se disponibile) per visualizzarne altri. Potrebbe essere necessario accedere a. AWS

# Visualizzazione delle informazioni sulla distribuzione
<a name="deploy-view-deployment-info"></a>

Puoi visualizzare le seguenti informazioni su una distribuzione in Amazon CodeCatalyst:
+ Attività di distribuzione, inclusi lo stato della distribuzione, l'ora di inizio, l'ora di fine, la cronologia e la durata degli eventi.
+ Nome dello stack Regione AWS, ora dell'ultimo aggiornamento e flussi di lavoro associati.
+ Commit e richieste pull.
+ Informazioni specifiche sull'azione, ad esempio CloudFormation eventi e risultati.

[È possibile visualizzare le informazioni sulla distribuzione a partire da un [flusso di lavoro](workflow.md), un [ambiente](deploy-environments.md) o un'azione del flusso di lavoro.](workflows-concepts.md#workflows-concepts-actions)

**Per visualizzare le informazioni sulla distribuzione a partire da un flusso di lavoro**
+ Vai all'esecuzione del flusso di lavoro che ha distribuito l'applicazione. Per istruzioni, consulta [Visualizzazione dello stato e dei dettagli dell'esecuzione del flusso di lavoro](workflows-view-run.md). 

**Per visualizzare le informazioni sulla distribuzione a partire da un ambiente**

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 Ambienti.**

1. Scegli l'ambiente in cui è stato distribuito lo stack, ad esempio. `Production`

1. Scegli **Attività di distribuzione** per visualizzare la cronologia di implementazione dei tuoi stack, lo stato delle distribuzioni (ad esempio, **RIUSCITED o **FAILED**) e altre informazioni** relative alla distribuzione.

1. Scegli **Deployment target** per visualizzare le informazioni sugli stack, i cluster o altri obiettivi distribuiti nell'ambiente. È possibile visualizzare informazioni come il nome dello stack, la regione, il provider e l'identificatore.

**Per visualizzare le informazioni sulla distribuzione a partire da un'azione**

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. Nel diagramma del flusso di lavoro, scegli l'azione del flusso di lavoro che ha distribuito l'applicazione. Ad esempio, puoi scegliere. **DeployCloudFormationStack**

1. Esamina il contenuto nel riquadro a destra per informazioni sulla distribuzione specifiche dell'azione.