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

# CodePipeline tutorial
<a name="tutorials"></a>

Dopo aver completato i passaggi indicati[Iniziare con CodePipeline](getting-started-codepipeline.md), puoi provare uno dei AWS CodePipeline tutorial di questa guida per l'utente.

**Topics**
+ [

# Tutorial: Esegui la distribuzione su istanze Amazon EC2 con CodePipeline
](tutorials-ec2-deploy.md)
+ [

# Tutorial: crea e invia un'immagine Docker ad Amazon ECR con CodePipeline (tipo V2)
](tutorials-ecr-build-publish.md)
+ [

# Tutorial: Esegui la distribuzione su Amazon EKS con CodePipeline
](tutorials-eks-deploy.md)
+ [

# Tutorial: crea una pipeline che esegue comandi con compute (tipo V2)
](tutorials-commands.md)
+ [

# Tutorial: usa i tag Git per avviare la tua pipeline
](tutorials-github-tags.md)
+ [

# Tutorial: filtra i nomi delle filiali per le richieste pull per avviare la pipeline (tipo V2)
](tutorials-github-featurebranches.md)
+ [

# Tutorial: utilizzare le variabili a livello di pipeline
](tutorials-pipeline-variables.md)
+ [

# Tutorial: creazione di una semplice pipeline (bucket S3)
](tutorials-simple-s3.md)
+ [

# Tutorial: crea una pipeline semplice (CodeCommit repository)
](tutorials-simple-codecommit.md)
+ [

# Tutorial: creazione di una pipeline a quattro fasi
](tutorials-four-stage-pipeline.md)
+ [

# Tutorial: imposta una regola CloudWatch Events per ricevere notifiche e-mail per le modifiche allo stato della pipeline
](tutorials-cloudwatch-sns-notifications.md)
+ [

# Tutorial: crea una pipeline con cui creare e testare la tua app Android AWS Device Farm
](tutorials-codebuild-devicefarm.md)
+ [

# Tutorial: crea una pipeline con cui testare la tua app iOS AWS Device Farm
](tutorials-codebuild-devicefarm-S3.md)
+ [

# Tutorial: crea una pipeline da distribuire su Service Catalog
](tutorials-S3-servicecatalog.md)
+ [

# Tutorial: Creare una pipeline con AWS CloudFormation
](tutorials-cloudformation.md)
+ [

# Tutorial: crea una pipeline che utilizza le variabili delle azioni di AWS CloudFormation distribuzione
](tutorials-cloudformation-action.md)
+ [

# Tutorial: distribuzione standard di Amazon ECS con CodePipeline
](ecs-cd-pipeline.md)
+ [

# Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy
](tutorials-ecs-ecr-codedeploy.md)
+ [

# Tutorial: creazione di una pipeline che distribuisce una competenza Amazon Alexa
](tutorials-alexa-skills-kit.md)
+ [

# Tutorial: crea una pipeline che utilizzi Amazon S3 come provider di distribuzione
](tutorials-s3deploy.md)
+ [

# Tutorial: crea una pipeline che pubblichi la tua applicazione serverless su AWS Serverless Application Repository
](tutorials-serverlessrepo-auto-publish.md)
+ [

# Tutorial: implementazioni di funzioni Lambda con CodePipeline
](tutorials-lambda-deploy.md)
+ [

# Tutorial: Utilizzo delle variabili con le azioni di richiamo Lambda
](tutorials-lambda-variables.md)
+ [

# Tutorial: utilizzare un'azione di AWS Step Functions richiamo in una pipeline
](tutorials-step-functions.md)
+ [

# Tutorial: crea una pipeline da utilizzare AWS AppConfig come provider di distribuzione
](tutorials-AppConfig.md)
+ [

# Tutorial: usa il clone completo con una sorgente di GitHub pipeline
](tutorials-github-gitclone.md)
+ [

# Tutorial: usa il clone completo con una sorgente di CodeCommit pipeline
](tutorials-codecommit-gitclone.md)
+ [

# Tutorial: creare una pipeline con azioni AWS CloudFormation StackSets di distribuzione
](tutorials-stackset-deployment.md)
+ [

# Tutorial: crea una regola di controllo variabile per una pipeline come condizione di ingresso
](tutorials-varcheckrule.md)

# Tutorial: Esegui la distribuzione su istanze Amazon EC2 con CodePipeline
<a name="tutorials-ec2-deploy"></a>

Questo tutorial ti aiuta a creare un'azione di distribuzione CodePipeline che distribuisce il codice nelle istanze che hai configurato in Amazon EC2.

**Nota**  
Come parte della creazione di una pipeline nella console, per gli artefatti verrà utilizzato un bucket di artefatti S3. CodePipeline (Questo è diverso dal bucket utilizzato per un'azione sorgente S3.) Se il bucket di artefatti S3 si trova in un account diverso da quello della pipeline, assicurati che il bucket di artefatti S3 sia di proprietà di utenti sicuri e affidabili. Account AWS 

**Nota**  
L'`EC2`azione di distribuzione è disponibile solo per le pipeline di tipo V2.

## Prerequisiti
<a name="tutorials-ec2-deploy-prereqs"></a>

Per utilizzare questo tutorial per creare la pipeline di distribuzione continua, è necessario disporre di alcune risorse. Ecco di cosa hai bisogno prima di iniziare:

**Nota**  
Tutte queste risorse devono essere create all'interno della stessa regione. AWS 
+ Un repository per il controllo del codice sorgente (utilizzato in questo tutorial GitHub) in cui aggiungere un `script.sh` file di esempio.
+ È necessario utilizzare un ruolo di CodePipeline servizio esistente che è stato aggiornato con le autorizzazioni per questa azione. Per aggiornare il tuo ruolo di servizio, consulta[Autorizzazioni relative alla policy del ruolo di servizio per l'azione di implementazione di EC2](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action).

Dopo aver soddisfatto questi prerequisiti, puoi procedere con il tutorial e creare la pipeline di distribuzione continua.

## Fase 1: creazione di istanze Amazon EC2 Linux
<a name="tutorials-ec2-deploy-instances"></a>

In questa fase, creerai le istanze Amazon EC2 in cui distribuirai un'applicazione di esempio. Come parte di questo processo, crea un ruolo di istanza in IAM, se non lo hai già creato nella regione in cui desideri creare risorse.

**Per creare un ruolo dell'istanza**

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

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

1. Scegli **Crea ruolo**.

1. In **Seleziona il tipo di entità affidabile**, seleziona **Servizio AWS**. In **Scegli un caso d'uso**, seleziona **EC2**. In **Select your use case (Seleziona il tuo caso d'uso)** selezionare **EC2**. Scegli **Next (Successivo)**.

1. Cerca e seleziona la politica denominata **`AmazonSSMManagedEC2InstanceDefaultPolicy`**. 

1. Cerca e seleziona la politica denominata **`AmazonSSMManagedInstanceCore`**. Scegliere **Next: Tags (Successivo: Tag)**.

1. Scegliere **Next:Review (Successivo: Rivedi)**. Immettere un nome per il ruolo (ad esempio **EC2InstanceRole**).
**Nota**  
Prendere nota del nome del ruolo per la fase successiva. È possibile scegliere questo ruolo quando si crea l'istanza.
**Nota**  
Aggiungerai le autorizzazioni a questo ruolo per consentire l'accesso al bucket di artefatti S3 per la tua pipeline dopo la creazione della pipeline.

   Scegli **Crea ruolo**.

**Per avviare istanze**

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

1. Dalla navigazione laterale, scegli **Istanze e seleziona **Launch** instances nella** parte superiore della pagina.

1. In **Nome**, inserisci **MyInstances**. **Questo assegna all'istanza un tag **Key** di **Name** e un tag Value di.** **MyInstances** 

1. In **Immagini dell'applicazione e del sistema operativo (Amazon Machine Image)**, individua l'opzione AMI **Amazon Linux** con il AWS logo e assicurati che sia selezionata. (Questa AMI è descritta come AMI Amazon Linux 2 (HVM) ed è etichettata come «Idoneo al piano gratuito».)

1. In **Tipo di istanza**, scegli il `t2.micro` tipo idoneo al piano gratuito come configurazione hardware per la tua istanza.

1. In **Coppia di chiavi (login)**, scegli una coppia di chiavi o creane una. 

1. In **Impostazioni di rete**, assicurati che lo stato sia **Attiva**.

1. Espandi **Advanced details** (Dettagli avanzati). Nel **profilo dell'istanza** IAM, scegli il ruolo IAM che hai creato nella procedura precedente (ad esempio,**EC2InstanceRole**).
**Nota**  
Non lasciare vuoto il ruolo dell'istanza poiché ciò crea un ruolo predefinito e non seleziona il ruolo che hai creato.

1. In **Riepilogo**, in **Numero di istanze**, inserisci`2`.

1. Scegliere **Launch Instance (Avvia istanza)**. 

1. È possibile visualizzare lo stato dell'avvio nella pagina **Instances (Istanze)**. Quando avvii un'istanza, il suo stato iniziale è `pending`. Una volta avviata l'istanza, il suo stato passa a `running` e riceve un nome DNS pubblico. Se la colonna **Public DNS (DNS pubblico)** non è visualizzata, scegliere l'icona **Show/Hide (Mostra/Nascondi)** quindi selezionare **Public DNS (DNS pubblico)**.

## Fase 2: aggiungi le autorizzazioni per artifact bucket al ruolo dell'istanza EC2
<a name="tutorials-ec2-deploy-role-s3"></a>

Devi aggiornare il ruolo dell'istanza EC2 che hai creato per l'istanza per consentirle di accedere al bucket di artefatti della pipeline. 

**Nota**  
Quando crei l'istanza, crei o utilizzi un ruolo di istanza EC2 esistente. Per evitare `Access Denied` errori, devi aggiungere le autorizzazioni del bucket S3 al ruolo dell'istanza per assegnare le autorizzazioni dell'istanza al bucket di artefatti. CodePipeline Crea un ruolo predefinito o aggiorna il tuo ruolo esistente con l'`s3:GetObject`autorizzazione limitata al bucket di artefatti per la regione della tua pipeline.

1. Accedi alla tua pipeline nella console. CodePipeline Seleziona **Impostazioni**. Visualizza il nome e la posizione dell'archivio di artefatti per una pipeline esistente. Prendi nota del bucket di artefatti Amazon Resource Name (ARN) e copialo.

1. Passare alla console IAM e quindi scegliere **Ruoli**. Scegli il ruolo di istanza che hai creato nella fase 1 di questo tutorial.

1. Nella scheda **Permissions (Autorizzazioni)** scegliere **Add inline policy (Aggiungi policy inline)**.

1. Aggiungi il seguente codice JSON al documento di policy, sostituendo il valore nel `Resource` campo con il bucket ARN.

   ```
   {
       "Effect": "Allow",
       "Principal": "*",
       "Action": "s3:GetObject",
       "Resource": "arn:aws:s3:::BucketName"
   }
   ```

1. Scegliere **Aggiorna**.

## Passaggio 3: aggiungi un file di script al tuo repository
<a name="tutorials-ec2-deploy-file"></a>

Incolla questo testo di esempio per creare il `script.sh` file per la fase post-script della distribuzione.

```
echo "Hello World!" 
```

**Aggiunta di un file `script.sh` nell'archivio di codice sorgente**

1. Apri un editor di testo, quindi copia e incolla il file precedente in un nuovo file.

1. Conferma e inserisci il file `script.sh` nell'archivio del codice sorgente.

   1. Aggiungi il file.

      ```
      git add .
      ```

   1. Conferma la modifica.

      ```
      git commit -m "Adding script.sh."
      ```

   1. Invia la conferma.

      ```
      git push
      ```

   Prendi nota del percorso nel tuo repository.

   ```
   /MyDemoRepo/test/script.sh
   ```

## Fase 4: Creazione della pipeline
<a name="tutorials-ec2-deploy-pipeline"></a>

Usa la CodePipeline procedura guidata per creare le fasi della pipeline e connettere il tuo repository di origine.

**Creazione della pipeline**

1. Apri la console all' CodePipeline indirizzo. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyPipeline**

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

1. In **Ruolo di servizio**, scegli **Usa il ruolo di servizio esistente**, quindi scegli il ruolo di CodePipeline servizio che è stato aggiornato con le autorizzazioni richieste per questa azione. Per configurare il ruolo CodePipeline di servizio per questa azione, consulta[Autorizzazioni relative alla policy del ruolo di servizio per l'azione di implementazione di EC2](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action).

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

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Repository name (Nome repository)**, scegli il nome del repository GitHub .

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 4: Aggiungi fase di creazione**, scegli **Ignora**.

1. **Nella pagina **Fase 5: Aggiungi fase di implementazione**, scegli EC2.**  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. Per la **directory Target**, inserisci la directory sull'istanza in cui desideri eseguire la distribuzione, ad esempio. `/home/ec2-user/testhelloworld`
**Nota**  
Specificate la directory di distribuzione che desiderate che l'azione utilizzi sull'istanza. L'azione automatizzerà la creazione della directory specificata sull'istanza come parte della distribuzione.

   1. Per **PostScript**, inserisci il percorso e il nome del file dello script, ad esempio`test/script.sh`.

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

1. Nella pagina **Step 6: Review** (Fase 6: esamina), esamina la configurazione della pipeline, quindi seleziona **Create pipeline** (Crea pipeline) per creare la pipeline.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. Dopo che la pipeline è stata eseguita correttamente, scegli **Visualizza dettagli per visualizzare i** registri dell'azione e visualizzare l'output dell'azione di elaborazione gestita.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## Fase 5: testa la tua pipeline
<a name="tutorials-ec2-deploy-test"></a>

La tua pipeline dovrebbe avere tutto il necessario per eseguire una distribuzione AWS continua end-to-end nativa. Ora, testane la funzionalità inserendo una modifica del codice all'archivio del codice sorgente.

**Test della pipeline**

1. Effettua una modifica del codice nell'archivio del codice sorgente configurato, conferma e inserisci la modifica.

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleziona la pipeline nell'elenco.

1. Osserva l'avanzamento della pipeline attraverso le varie fasi. La pipeline dovrebbe essere completata e la tua azione distribuirà lo script sulle tue istanze.

1. Per ulteriori informazioni sulla risoluzione dei problemi, consulta. [L'azione EC2 Deploy fallisce e viene visualizzato un messaggio di errore `No such file`](troubleshooting.md#troubleshooting-ec2-deploy)

# Tutorial: crea e invia un'immagine Docker ad Amazon ECR con CodePipeline (tipo V2)
<a name="tutorials-ecr-build-publish"></a>

Questo tutorial ti aiuta a creare un'azione di compilazione CodePipeline che esegue e invia la tua immagine Docker ad Amazon ECR dopo una modifica al codice sorgente. Questo tutorial mostra anche come aggiungere un'azione di distribuzione di Amazon ECS che distribuisca l'immagine inviata.

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

**Nota**  
Questo tutorial riguarda l'azione di ECRBuild AndPublish compilazione di una CodePipeline pipeline con un repository di GitHub origine e un'azione standard Amazon ECS per la distribuzione in un cluster Amazon ECS. Per un tutorial che utilizza una pipeline con un repository di immagini ECR come origine per un'azione di distribuzione da Amazon ECS a CodeDeploy blu/green, consulta. CodePipeline [Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)

**Importante**  
Questa azione utilizza l' CodeBuild elaborazione CodePipeline gestita per eseguire comandi in un ambiente di compilazione. L'esecuzione dell'azione dei comandi comporterà costi separati in. AWS CodeBuild

## Prerequisiti
<a name="tutorials-ecr-build-publish-prereqs"></a>

Per utilizzare questo tutorial per creare la pipeline di distribuzione continua, è necessario disporre di alcune risorse. Ecco di cosa hai bisogno prima di iniziare:

**Nota**  
Tutte queste risorse devono essere create all'interno della stessa AWS regione.
+ Un archivio per il controllo del codice sorgente (utilizzato in questo tutorial GitHub) in cui aggiungerai quanto segue per questo tutorial:
  + Nel passaggio 1, aggiungerai un Dockerfile di esempio al tuo repository di origine come artefatto di input per l'azione di compilazione in. ECRBuild AndPublish CodePipeline
  + Nella fase 2, aggiungerai un file imagedefinitions.json di esempio al tuo repository di origine come requisito per l'azione di distribuzione standard di Amazon ECS in. CodePipeline
+ Un repository di immagini Amazon ECR che contiene un'immagine creata dal tuo Dockerfile. Per ulteriori informazioni, consulta [Creating a Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) and [Pushing an Image](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) nella *Amazon Elastic Container Registry User Guide*.
+ Un cluster e un servizio Amazon ECS creati nella stessa regione del repository di immagini. Per ulteriori informazioni, consulta [Creazione di un cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) e [creazione di un servizio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service.html) nella *Amazon Elastic Container Service Developer Guide*.

Dopo aver soddisfatto questi prerequisiti, puoi procedere con il tutorial e creare la pipeline di distribuzione continua.

## Passaggio 1: aggiungi un Dockerfile al tuo repository di origine
<a name="tutorials-ecr-build-publish-file"></a>

Questo tutorial utilizza l' ECRBuildAndPublish azione per creare l'immagine Docker e inviarla ad Amazon ECR. L'azione di elaborazione gestita CodePipeline viene utilizzata CodeBuild per eseguire i comandi per l'accesso ECR e il push dell'immagine. Non è necessario aggiungere un `buildspec.yml` file all'archivio del codice sorgente per sapere CodeBuild come eseguire questa operazione. Per questo esempio, fornisci solo il Dockerfile nel tuo repository come segue.

Incolla questo testo di esempio per creare il tuo file. `Dockerfile` Questo Dockerfile di esempio è lo stesso utilizzato nelle istruzioni relative all'immagine ECR nei prerequisiti.

```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest

# Install dependencies
RUN yum update -y && \
 yum install -y httpd

# Install apache and write hello world message
RUN echo 'Hello World!' > /var/www/html/index.html

# Configure apache
RUN echo 'mkdir -p /var/run/httpd' >> /root/run_apache.sh && \
 echo 'mkdir -p /var/lock/httpd' >> /root/run_apache.sh && \
 echo '/usr/sbin/httpd -D FOREGROUND' >> /root/run_apache.sh && \
 chmod 755 /root/run_apache.sh

EXPOSE 80

CMD /root/run_apache.sh
```

**Aggiunta di un file `Dockerfile` nell'archivio di codice sorgente**

1. Apri un editor di testo, quindi copia e incolla il Dockerfile riportato sopra in un nuovo file.

1. Conferma e inserisci il file `Dockerfile` nell'archivio del codice sorgente.

   1. Aggiungi il file.

      ```
      git add .
      ```

   1. Conferma la modifica.

      ```
      git commit -m "Adding Dockerfile."
      ```

   1. Invia la conferma.

      ```
      git push
      ```

   Assicurati di posizionare il file al livello principale del tuo repository.

   ```
   / Dockerfile
   ```

## Passaggio 2: aggiungi un file imagedefinitions.json al tuo repository di origine
<a name="w2aac13b9c15"></a>

Questo tutorial utilizza l'azione di distribuzione standard di Amazon ECS CodePipeline per distribuire il contenitore nel cluster Amazon ECS. L'azione di distribuzione standard di Amazon ECS richiede un file imagedefinitions.json contenente il nome dell'immagine e l'URI. Per ulteriori informazioni sul file imagedefinitions.json, consulta. [file imagedefinitions.json per le azioni di distribuzione standard di Amazon ECS](file-reference.md#pipelines-create-image-definitions)

Incolla questo testo di esempio per creare il file. `imagedefinitions.json` Usa il nome nel tuo Dockerfile, ad esempio`hello-world`, e usa l'URI dal tuo repository Amazon ECR in cui è archiviata l'immagine.

```
[
  {
    "name": "hello-world",
    "imageUri": "ACCOUNT-ID.dkr.ecr.us-east-1.amazonaws.com/actions/image-repo"
  }
]
```

**Per aggiungere un `imagedefinitions.json` file al tuo repository di origine**

1. Apri un editor di testo e copia e incolla l'esempio precedente in un nuovo file.

1. Conferma e inserisci il file `imagedefinitions.json` nell'archivio del codice sorgente.

   1. Aggiungi il file.

      ```
      git add .
      ```

   1. Conferma la modifica.

      ```
      git commit -m "Adding imagedefinitions.json."
      ```

   1. Invia la conferma.

      ```
      git push
      ```

   Assicurati di posizionare il file al livello principale del tuo repository.

   ```
   / imagedefinitions.json
   ```

## Fase 3: Creazione della pipeline
<a name="tutorials-ecr-build-publish-pipeline"></a>

Usa la CodePipeline procedura guidata per creare le fasi della pipeline e connettere il tuo repository di origine.

**Creazione della pipeline**

1. Apri la console all' CodePipeline indirizzo. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyPipeline**

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

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

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

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Repository name (Nome repository)**, scegli il nome del repository GitHub .

   1. Nel **ramo predefinito**, scegli il ramo che desideri specificare quando la pipeline viene avviata manualmente o con un evento di origine che non sia un tag Git. Se l'origine della modifica non è il trigger o se l'esecuzione di una pipeline è stata avviata manualmente, la modifica utilizzata sarà il commit HEAD del ramo predefinito.

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 4: Aggiungi fase di compilazione**, scegli **Altri fornitori di build**. **ECRBuildAndPublish**  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ecrbuild-wizard.png)

   1. Per il **nome del repository ECR, scegli il tuo repository** di immagini.

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

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

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 6: Aggiungi fase di distribuzione, scegli **Salta** fase** di distribuzione. Aggiungerai l'azione ECS nel passaggio successivo.

1. Nella pagina **Passaggio 7: revisione**, rivedi la configurazione della pipeline e scegli **Crea pipeline per creare la pipeline**.

1. Modifica la tua pipeline per aggiungere l'azione di distribuzione di Amazon ECS alla tua pipeline:

   1. In alto a destra, scegli **Edit (Modifica)**.

   1. In fondo al diagramma, scegliere **\$1 Add stage (\$1 Aggiungi fase)** In **Nome fase** immetti un nome, ad esempio **Deploy**.

   1. Scegliere **\$1 Add action group (\$1 Aggiungi gruppo di operazioni)**.

   1. Alla voce **Action name (Nome operazione)**, inserire un nome. 

   1. In **Action provider**, scegli Amazon ECS. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. In **Input artifacts**, scegli l'artefatto di input dalla fase di origine, ad esempio. `SourceArtifact` 

   1. Per **il nome del cluster**, scegli il cluster Amazon ECS in cui è in esecuzione il tuo servizio.

   1. Per **Nome del servizio**, scegli il servizio da aggiornare.

   1. Scegli **Save** (Salva).

   1. Nella fase che stai modificando, scegli **Done (Fatto)**. Nel riquadro AWS CodePipeline , scegli **Save (Salva)** e quindi scegli **Save (Salva)** sul messaggio di avviso.

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

1. Dopo l'esecuzione della pipeline, visualizza la struttura e lo stato della pipeline.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ecrbuild-ecsaction.png)

1. Dopo che la pipeline è stata eseguita correttamente, scegli **Visualizza dettagli per visualizzare i** log dell'azione e visualizzare l'output dell'azione di elaborazione gestita.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ecrbuild-logs.png)

1. Risolvi eventuali azioni non riuscite. Ad esempio, l'azione di distribuzione ECS può avere esito negativo se il file imagedefinitions.json non si trova nel repository di origine. Di seguito è riportato un esempio del messaggio di errore che viene visualizzato quando manca il file imagedefinitions.json.   
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ecrbuild-ecsdebug.png)

## Fase 4: test della pipeline
<a name="tutorials-ecr-build-publish-test"></a>

La tua pipeline dovrebbe avere tutto il necessario per eseguire una end-to-end distribuzione continua nativa. AWS Ora, testane la funzionalità inserendo una modifica del codice all'archivio del codice sorgente.

**Test della pipeline**

1. Effettua una modifica del codice nell'archivio del codice sorgente configurato, conferma e inserisci la modifica.

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleziona la pipeline nell'elenco.

1. Osserva l'avanzamento della pipeline attraverso le varie fasi. La pipeline dovrebbe essere completata e l'azione inserisce l'immagine Docker in ECR creata dalla modifica del codice.

# Tutorial: Esegui la distribuzione su Amazon EKS con CodePipeline
<a name="tutorials-eks-deploy"></a>

Questo tutorial ti aiuta a creare un'azione di distribuzione CodePipeline che distribuisce il codice in un cluster che hai configurato in Amazon EKS.

L'azione EKS supporta cluster EKS pubblici e privati. I cluster privati sono il tipo consigliato da EKS; tuttavia, entrambi i tipi sono supportati.

**Nota**  
Come parte della creazione di una pipeline nella console, per gli artefatti verrà utilizzato un bucket di artefatti S3. CodePipeline (Questo è diverso dal bucket utilizzato per un'azione sorgente S3.) Se il bucket di artefatti S3 si trova in un account diverso da quello della pipeline, assicurati che il bucket di artefatti S3 sia di proprietà di utenti sicuri e affidabili. Account AWS 

**Nota**  
Questa azione utilizza l'elaborazione gestita per eseguire comandi in un ambiente di CodePipeline compilazione. CodeBuild L'esecuzione dell'azione dei comandi comporterà costi separati in. AWS CodeBuild

**Nota**  
L'azione di `EKS` distribuzione è disponibile solo per le pipeline di tipo V2.

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

Per utilizzare questo tutorial per creare la pipeline di distribuzione continua, è necessario disporre di alcune risorse. Ecco di cosa hai bisogno prima di iniziare:

**Nota**  
Tutte queste risorse devono essere create all'interno della stessa regione. AWS 
+ Un repository per il controllo del codice sorgente (utilizzato in questo tutorial GitHub) in cui aggiungere un `deployment.yaml` file di esempio.
+ È necessario utilizzare un ruolo di CodePipeline servizio esistente che aggiornerai con le autorizzazioni per questa azione utilizzando [Fase 3: Aggiornare la politica del ruolo di servizio in IAM CodePipeline](#tutorials-eks-deploy-role) di seguito le autorizzazioni per questa azione. Le autorizzazioni necessarie dipendono dal tipo di cluster creato. Per ulteriori informazioni, consulta [Autorizzazioni relative alla politica del ruolo di servizio](action-reference-EKS.md#action-reference-EKS-service-role).
+ Un'immagine funzionante e un tag del repository che hai inviato a ECR o al tuo archivio di immagini.

Dopo aver soddisfatto questi prerequisiti, puoi procedere con il tutorial e creare la pipeline di distribuzione continua.

## Fase 1: (Facoltativo) Creare un cluster in Amazon EKS
<a name="tutorials-eks-deploy-cluster"></a>

Puoi scegliere di creare un cluster EKS con un endpoint pubblico o privato. 

Nei passaggi seguenti, crei un cluster pubblico o privato in EKS. Questo passaggio è facoltativo se il cluster è già stato creato.

### Crea un cluster pubblico in Amazon EKS
<a name="tutorials-eks-deploy-cluster-public"></a>

In questo passaggio, crei un cluster in EKS.

**Crea un cluster pubblico**

1. Apri la console EKS, quindi scegli **Crea cluster**.

1. In **Nome, assegna** un nome al cluster. Scegli **Next (Successivo)**.

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

### Crea un cluster privato in Amazon EKS
<a name="tutorials-eks-deploy-cluster-private"></a>

Se scegli di creare un cluster con un endpoint privato, assicurati di collegare solo le sottoreti private e assicurati che abbiano una connessione Internet.

Segui i prossimi cinque passaggi secondari per creare un cluster con un endpoint privato.

**Crea un VPC nella console**

1. Apri la console VPC, quindi scegli Crea **VPC**.

1. In **Impostazioni VPC**, scegli **VPC e altro**.

1. Scegli di creare una sottorete pubblica e 4 sottoreti private. Seleziona **Crea VPC**.

1. **Nella pagina delle sottoreti, scegli Privato.** 

**Determina le sottoreti private nel tuo VPC**

1. Accedi al tuo VPC e scegli l'ID VPC per aprire la pagina dei dettagli del VPC.

1. Nella pagina dei dettagli del VPC, scegli la scheda **Mappa delle risorse**.

1. Visualizza il diagramma e prendi nota delle tue sottoreti private. Le sottoreti vengono visualizzate con etichette per indicare lo stato pubblico o privato e ogni sottorete è mappata su una tabella di routing.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/eks-deploy-subnets.png)

   Tieni presente che un cluster privato avrà tutte le sottoreti private.

1. Crea una sottorete pubblica per ospitare il gateway NAT. È possibile allegare un solo gateway Internet a un VPC alla volta.

**Crea un gateway NAT nella sottorete pubblica**

1. Nella sottorete pubblica, create un gateway NAT. Vai alla console VPC, quindi scegli Gateway **Internet**. Scegliere **Crea gateway Internet**.

1. In Nome, inserisci un nome per il tuo gateway Internet. Scegliere **Crea gateway Internet**.

Aggiorna la tabella di routing per la sottorete privata per indirizzare il traffico verso il gateway NAT.

**Aggiungi il gateway NAT alle tabelle di routing per le sottoreti private**

1. **Vai alla console VPC, quindi scegli Subnet.**

1. **Per ogni sottorete privata, selezionala, quindi scegli la tabella di routing per quella sottorete nella pagina dei dettagli, scegli Modifica tabella di routing.** 

1. Aggiorna la tabella di routing per la sottorete privata per indirizzare il traffico Internet verso il gateway NAT. Seleziona **Aggiungi route**. Scegli il **gateway NAT** tra le opzioni da aggiungere. Scegli il gateway Internet che hai creato.

1. Per la sottorete pubblica, crea una tabella di routing personalizzata. Verifica che la lista di controllo degli accessi alla rete (ACL) per la sottorete pubblica consenta il traffico in entrata dalla sottorete privata.

1. Scegli **Save changes** (Salva modifiche).

In questo passaggio, crei un cluster in EKS.

**Crea un cluster privato**

1. Apri la console EKS, quindi scegli **Crea cluster**.

1. In **Nome, assegna** un nome al cluster. Scegli **Next (Successivo)**.

1. Specificate il VPC e altre informazioni di configurazione. Scegli **Create** (Crea).

Il tuo cluster EKS può essere un cluster pubblico o privato. Questo passaggio è per i cluster che hanno SOLO un endpoint privato. Assicurati che il tuo cluster sia privato.

## Fase 2: configura il tuo cluster privato in Amazon EKS
<a name="tutorials-eks-deploy-cluster-private-configure"></a>

Questo passaggio è applicabile solo se hai creato un cluster privato. Questo passaggio è per i cluster che hanno SOLO un endpoint privato. 

**Configura il tuo cluster**

1. Collega le sottoreti private solo nel cluster EKS nella scheda **Rete**. Collega le sottoreti private acquisite nella sezione **Determina le sottoreti private nel tuo VPC** sotto. [Fase 1: (Facoltativo) Creare un cluster in Amazon EKS](#tutorials-eks-deploy-cluster)

1. Assicurati che le sottoreti private abbiano accesso a Internet poiché CodePipeline archivia e recupera gli artefatti dal bucket di artefatti S3 per la tua pipeline.

## Fase 3: Aggiornare la politica del ruolo di servizio in IAM CodePipeline
<a name="tutorials-eks-deploy-role"></a>

In questo passaggio, aggiornerai un ruolo di CodePipeline servizio esistente`cp-service-role`, ad esempio con le autorizzazioni richieste per connetterti CodePipeline al tuo cluster. Se non disponi di un ruolo esistente, creane uno nuovo.

Aggiorna il tuo ruolo di CodePipeline servizio con i seguenti passaggi.

**Per aggiornare la politica CodePipeline del ruolo di servizio**

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

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

1. Cerca il tuo ruolo CodePipeline di servizio, ad esempio`cp-service-role`.

1. Aggiungi una nuova politica in linea.

1. Nell'**editor delle politiche**, inserisci quanto segue.
   + Per un cluster pubblico, aggiungi le seguenti autorizzazioni.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             }
         ]
     }
     ```

------
   + Per un cluster privato, aggiungi le seguenti autorizzazioni. I cluster privati richiederanno autorizzazioni aggiuntive per il tuo VPC, se applicabile.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterfacePermission",
                 "Resource": "*",
                 "Condition": {
                     "ArnEquals": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:DeleteNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             }
         ]
     }
     ```

------

1. Scegli **Aggiorna policy**.

## Fase 4: Creare una voce di accesso per il ruolo di servizio CodePipeline
<a name="tutorials-eks-deploy-access-entry"></a>

In questo passaggio, si crea una voce di accesso nel cluster che aggiungerà il ruolo di CodePipeline servizio aggiornato nel passaggio 3, insieme a una politica di accesso gestito.

1. Apri la console EKS e accedi al tuo cluster.

1. Scegliere la scheda **Accesso**.

1. In **Voci di accesso IAM**, scegli **Crea voce di accesso**.

1. Nell'**ARN principale IAM**, inserisci il ruolo che hai appena aggiornato per l'azione, ad esempio. `cp-service-role` Scegli **Next (Successivo)**.

1. Nella pagina **Step 2: Aggiungi policy di accesso**, in **Nome policy**, scegli la policy gestita per l'accesso, ad `AmazonEKSClusterAdminPolicy` esempio. Scegli **Aggiungi policy**. Scegli **Next (Successivo)**.
**Nota**  
Questa è la politica utilizzata dall' CodePipeline azione per comunicare con Kubernetes. Come procedura consigliata, per definire le autorizzazioni della policy con il minimo privilegio rispetto alla politica amministrativa, allega invece di una policy personalizzata.

1. **Nella pagina di revisione, scegli Crea.**

## Passo 5: Crea un archivio di sorgenti e aggiungi i file di `helm chart` configurazione
<a name="tutorials-eks-deploy-source"></a>

In questo passaggio, crei un file di configurazione appropriato per la tua azione (file manifest di Kubernetes o grafico Helm) e lo memorizzi nel tuo repository di origine. Usa il file appropriato per la tua configurazione. Per ulteriori informazioni, consulta [https://kubernetes. ](https://kubernetes.io/docs/reference/kubectl/quick-reference/)io/docs/reference/kubectl/quick[-reference/ o https://helm. sh/docs/topics/charts](https://helm.sh/docs/topics/charts/)/.
+ Per Kubernetes, usa un file manifest.
+ Per Helm, usa un grafico Helm.

1. Crea o usa un repository esistente GitHub .

1. Crea una nuova struttura nel tuo repository per i file del grafico Helm, come mostrato nell'esempio seguente.

   ```
   mychart
   |-- Chart.yaml
   |-- charts
   |-- templates
   |   |-- NOTES.txt
   |   |-- _helpers.tpl
   |   |-- deployment.yaml
   |   |-- ingress.yaml
   |   `-- service.yaml
   `-- values.yaml
   ```

1. Aggiungi il file al livello principale del tuo repository.

## Fase 6: Creazione della pipeline
<a name="tutorials-eks-deploy-pipeline"></a>

Usa la CodePipeline procedura guidata per creare le fasi della pipeline e connettere il tuo repository di origine.

**Creazione della pipeline**

1. Apri la console all' CodePipeline indirizzo. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyEKSPipeline**

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

1. In **Ruolo di servizio**, scegli il ruolo di servizio che hai aggiornato nella Fase 3.

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

1. **Nella pagina Passaggio 3: Aggiungi fase di origine**, per **Provider di origine**, scegli **di creare una connessione al tuo GitHub repository**.

1. Nel **Passaggio 4: Aggiungi la pagina della fase di compilazione**, scegli **Salta**.

1. Nella pagina **Fase 5: Aggiungere la fase di distribuzione**, scegli **Amazon EKS**.  
![\[Deploy configuration form with Helm selected, showing fields for release name and chart location.\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/eks-action-example.png)

   1. **In **Tipo di configurazione Deploy**, scegli Helm.**

   1. In **Helm chart location**, inserisci il nome della release, ad esempio. `my-release` Per **Helm chart location**, inserisci il percorso per i file della mappa di Helm, ad esempio. `mychart`

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

1. Nella pagina **Step 6: Review** (Fase 6: esamina), esamina la configurazione della pipeline, quindi seleziona **Create pipeline** (Crea pipeline) per creare la pipeline.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/eks-deploy-pipeline.png)

1. Dopo che la pipeline è stata eseguita correttamente, scegli **Visualizza dettagli per visualizzare i** registri dell'azione e visualizzare l'output dell'azione.

# Tutorial: crea una pipeline che esegue comandi con compute (tipo V2)
<a name="tutorials-commands"></a>

In questo tutorial, configurerai una pipeline che esegue continuamente i comandi di compilazione forniti utilizzando l'azione Commands in una fase di compilazione. Per ulteriori informazioni sull'azione Comandi, vedere[Riferimento all'azione dei comandi](action-reference-Commands.md).

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

## Prerequisiti
<a name="tutorials-commands-prereq"></a>

Devi avere già quanto segue:
+ Un repository. GitHub È possibile utilizzare il GitHub repository in cui è stato creato. [Tutorial: usa il clone completo con una sorgente di GitHub pipeline](tutorials-github-gitclone.md)

## Passaggio 1: Crea i file sorgente e inviali al tuo repository GitHub
<a name="tutorials-commands-push"></a>

In questa sezione, create e inviate i file sorgente di esempio al repository utilizzato dalla pipeline per la fase di origine. In questo esempio, produci e invii quanto segue: 
+ Un file `README.txt`.

**Per creare file sorgente**

1. Crea un file con il testo seguente:

   ```
   Sample readme file
   ```

1. Salva il file con nome `README.txt`.

**Per inviare file al tuo GitHub repository**

1. Invia o carica i file nel repository . Questi file sono l'artefatto di origine creato dalla procedura guidata **Create Pipeline (Crea pipeline)** per l'operazione di distribuzione in AWS CodePipeline. I file dovrebbero avere questo aspetto nella directory locale:

   ```
   README.txt
   ```

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

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

      ```
      git add -A
      ```

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

      ```
      git commit -m "Added source files"
      ```

   1. Esegui il comando seguente per eseguire il push dei file dal repository locale al repository :

      ```
      git push
      ```

## Fase 2: creazione della pipeline
<a name="tutorials-commands-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un'azione GitHub (tramite GitHub App) per il repository in cui sono archiviati i file di origine.
+ Una fase di compilazione con l'azione Commands.

**Per creare una pipeline con la procedura guidata**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyCommandsPipeline**

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

1. In **Ruolo di servizio**, scegli **Nuovo ruolo di servizio** CodePipeline per consentire la creazione di un ruolo di servizio in IAM.
**Nota**  
Se utilizzi un ruolo di servizio esistente, per utilizzare l'azione Comandi, dovrai aggiungere le seguenti autorizzazioni per il ruolo di servizio. Riduci le autorizzazioni a livello di risorsa della pipeline utilizzando le autorizzazioni basate sulle risorse nella dichiarazione sulla politica del ruolo di servizio. Per ulteriori informazioni, consulta l'esempio di policy in. [Autorizzazioni relative ai ruoli di servizio](action-reference-Commands.md#action-reference-Commands-policy)  
registri: CreateLogGroup
registri: CreateLogStream
registri: PutLogEvents

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

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungere una fase di origine:

   1. In **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Nome archivio**, scegli il nome del tuo repository GitHub .com. 

   1. Nel **ramo predefinito**, scegli il ramo che desideri specificare quando la pipeline viene avviata manualmente o con un evento di origine che non sia un tag Git. Se l'origine della modifica non è il trigger o se l'esecuzione di una pipeline è stata avviata manualmente, la modifica utilizzata sarà il commit HEAD del ramo predefinito. Facoltativamente, puoi anche specificare webhook con filtri (trigger). Per ulteriori informazioni, consulta [Automatizza l'avvio delle pipeline utilizzando trigger e filtri](pipelines-triggers.md).

   Scegli **Next (Successivo)**.

1. **Nel **passaggio 4: Aggiungi la fase di compilazione**, scegli Comandi.**
**Nota**  
L'esecuzione dell'azione Comandi comporterà addebiti separati in. AWS CodeBuild

   Eseguire i comandi seguenti: 

   ```
   ls
   echo hello world
   cat README.txt
   echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}
   ```

   Scegli **Next (Successivo)**.  
![\[Passaggio 4: aggiungere la pagina della fase di compilazione per una nuova pipeline con l'azione Comandi\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/commands-wizard-screen.png)

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

   Scegli **Next (Successivo)**.

1. **Nel **passaggio 6: aggiungi la fase di distribuzione, scegli Salta fase** **di distribuzione**, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** 

   Scegli **Next (Successivo)**.

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

1. Come passaggio finale per la creazione dell'azione, aggiungi una variabile di ambiente all'azione che risulterà in una variabile di output per l'azione. Nell'azione Comandi, scegli **Modifica**. Nella schermata **Modifica**, specifica uno spazio dei nomi variabile per la tua azione inserendolo `compute` nel campo Spazio dei **nomi variabile**.

   **Aggiungi la variabile CodeBuild di output`AWS_Default_Region`, quindi scegli Aggiungi variabile.**  
![\[La pagina Modifica per l'azione Comandi\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/commands-output-edit-var.png)

## Passaggio 3: Esegui la pipeline e verifica i comandi di compilazione
<a name="tutorials-commands-update"></a>

Rilascia una modifica per eseguire la pipeline. Verifica che i comandi di compilazione siano stati eseguiti visualizzando la cronologia di esecuzione, i log di compilazione e le variabili di output.

**Per visualizzare i registri delle azioni e le variabili di output**

1. Dopo che la pipeline è stata eseguita correttamente, è possibile visualizzare i log e l'output dell'azione.

1. **Per visualizzare le variabili di output per l'azione, scegliete **Cronologia, quindi scegliete Cronologia**.** 

   Visualizza la variabile di output che è stata aggiunta all'azione. L'output dell'azione Comandi mostra la variabile di output risolta nella regione di azione.  
![\[L'output dell'azione Comandi che mostra la variabile di output risolta nella regione di azione\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/commands-output-variable.png)

1. Per visualizzare i registri dell'azione, scegli **Visualizza dettagli** sull'azione Comandi riuscita. Visualizza i registri dell'azione Comandi.  
![\[Registri di esempio per l'azione Comandi\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/commands-output-logs.png)

# Tutorial: usa i tag Git per avviare la tua pipeline
<a name="tutorials-github-tags"></a>

In questo tutorial, creerai una pipeline che si connette al tuo GitHub repository in cui l'azione source è configurata per il tipo di trigger dei tag Git. Quando viene creato un tag Git su un commit, viene avviata la pipeline. Questo esempio mostra come creare una pipeline che consenta il filtraggio dei tag in base alla sintassi del nome del tag. Per ulteriori informazioni sul filtraggio con pattern a glob, consulta. [Lavorare con i modelli a globo nella sintassi](syntax-glob.md)

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

Questo GitHub tutorial si collega `CodeStarSourceConnection` a tramite il tipo di azione.

**Nota**  
Questa funzionalità non è disponibile nelle regioni Asia Pacifico (Hong Kong), Africa (Città del Capo), Medio Oriente (Bahrein) o Europa (Zurigo). Per fare riferimento ad altre azioni disponibili, consulta[Integrazioni di prodotti e servizi con CodePipeline](integrations.md). Per considerazioni su questa azione nella regione Europa (Milano), si veda la nota in[CodeStarSourceConnection per Bitbucket Cloud, GitHub Enterprise Server GitHub, GitLab .com e GitLab azioni autogestite](action-reference-CodestarConnectionSource.md).

**Topics**
+ [

## Prerequisiti
](#tutorials-github-tags-prereq)
+ [

## Passaggio 1: apri CloudShell e clona il tuo repository
](#w2aac13c16c15)
+ [

## Passaggio 2: creare una pipeline da attivare sui tag Git
](#tutorials-github-tags-pipeline)
+ [

## Passaggio 3: contrassegna i tuoi commit per il rilascio
](#w2aac13c16c19)
+ [

## Passaggio 4: Rilascia le modifiche e visualizza i log
](#tutorials-github-tags-view)

## Prerequisiti
<a name="tutorials-github-tags-prereq"></a>

Prima di iniziare è necessario:
+ Crea un GitHub repository con il tuo GitHub account.
+ Tieni a portata di mano GitHub le tue credenziali. Quando utilizzi il Console di gestione AWS per configurare una connessione, ti viene chiesto di accedere con GitHub le tue credenziali. 

## Passaggio 1: apri CloudShell e clona il tuo repository
<a name="w2aac13c16c15"></a>

Puoi usare un'interfaccia a riga di comando per clonare il tuo repository, fare commit e aggiungere tag. Questo tutorial avvia un' CloudShell istanza per l'interfaccia a riga di comando.

1. Accedi alla Console di gestione AWS.

1. Nella barra di navigazione in alto, scegli l' AWS icona. La pagina principale dei Console di gestione AWS display.

1. Nella barra di navigazione in alto, scegli l' AWS CloudShell icona. 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).

1. In GitHub, accedi al tuo repository. Scegli **Codice**, quindi scegli **HTTPS**. Copia il percorso. L'indirizzo per clonare il repository Git viene copiato negli Appunti.

1. Esegui il seguente comando per clonare il repository.

   ```
   git clone https://github.com/<account>/MyGitHubRepo.git
   ```

1. Inserisci il tuo GitHub account `Username` e `Password` quando richiesto. Per l'`Password`immissione, è necessario utilizzare un token creato dall'utente anziché la password dell'account.

## Passaggio 2: creare una pipeline da attivare sui tag Git
<a name="tutorials-github-tags-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase sorgente con una connessione al tuo GitHub repository e all'azione.
+ Una fase di compilazione con un'azione di AWS CodeBuild compilazione.

**Per creare una pipeline con la procedura guidata**

1. Accedi alla CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyGitHubTagsPipeline**

1. **Nel **tipo di tubazione**, mantenete la selezione di default su V2.** I tipi di tubazioni differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md).

1. In **Service Role (Ruolo del servizio)**, scegliere **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Se invece scegli di utilizzare il tuo ruolo di CodePipeline servizio esistente, assicurati di aver aggiunto l'autorizzazione `codestar-connections:UseConnection` IAM alla tua politica del ruolo di servizio. Per istruzioni sul ruolo CodePipeline di servizio, consulta [Aggiungere autorizzazioni al ruolo CodePipeline di servizio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. In **Impostazioni avanzate** non modificare le impostazioni predefinite. In **Artifact store (Archivio artefatti)**, seleziona **Default location (Posizione predefinita)** per utilizzare l'archivio artefatti predefinito, ad esempio il bucket Amazon S3 dedicato agli artefatti designato come predefinito, per la pipeline nella regione selezionata.
**Nota**  
Non si tratta del bucket di origine per il codice sorgente, ma dell'archivio artefatti per la pipeline. È richiesto un archivio artefatti separato, ad esempio un bucket S3, per ogni pipeline.

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Repository name (Nome repository)**, scegli il nome del repository GitHub.

   1. Nel **ramo predefinito**, scegli il ramo che desideri specificare quando la pipeline viene avviata manualmente o con un evento di origine che non sia un tag Git. Se l'origine della modifica non è il trigger o se l'esecuzione di una pipeline è stata avviata manualmente, la modifica utilizzata sarà il commit HEAD del ramo predefinito.

   1. **In **Eventi Webhook**, in **Tipo di filtro**, scegli Tag.**

      Nel campo **Tag o modelli**, inserisci`release*`.
**Importante**  
Le pipeline che iniziano con un tipo di trigger di tag Git verranno configurate per gli eventi WebHookV2 e non utilizzeranno l'evento Webhook (rilevamento delle modifiche su tutti gli eventi push) per avviare la pipeline.

   Scegli **Next (Successivo)**.

1. In **Add build stage (Aggiungi fase di compilazione)**, aggiungi una fase di compilazione:

   1. In **Build provider (Provider compilazione)**, scegli **AWS CodeBuild**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. ****Per Image, scegliere:5.0. aws/codebuild/standard****

   1. Per **Service Role (Ruolo del servizio)**, scegli **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Annota il nome del tuo ruolo di servizio. CodeBuild Avrai bisogno del nome del ruolo per l'ultimo passaggio di questo tutorial.

   1. In **Buildspec**, per **Build specifications** (Specifiche di compilazione), scegli **Insert build commands (Inserisci comandi di compilazione)**. Scegli **Passa all'editor** e incolla quanto segue nei **comandi di compilazione**.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Scegli **Continua a CodePipeline**. Questo ritorna alla CodePipeline console e crea un CodeBuild progetto che utilizza i comandi di compilazione per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.**

## Passaggio 3: contrassegna i tuoi commit per il rilascio
<a name="w2aac13c16c19"></a>

Dopo aver creato la pipeline e specificato i tag Git, puoi taggare i commit nel tuo GitHub repository. In questi passaggi, taggherai un commit con il tag. `release-1` Ogni commit in un repository Git deve avere un tag Git univoco. Quando scegli il commit e lo tagghi, ciò ti consente di incorporare le modifiche provenienti da diversi rami nella distribuzione della pipeline. Nota che il nome del tag release non si applica al concetto di release in GitHub.

1. Fai riferimento al commit copiato IDs che desideri taggare. Per visualizzare i commit in ogni ramo, nel CloudShell terminale, inserisci il seguente comando per acquisire il commit che IDs desideri taggare: 

   ```
   git log
   ```

1. Nel CloudShell terminale, inserisci il comando per etichettare il tuo commit e invialo a origin. Dopo aver taggato il tuo commit, usi il comando git push per spingere il tag all'origine. Nell'esempio seguente, inserisci il comando seguente per utilizzare il `release-1` tag per il secondo commit con ID`49366bd`. Questo tag verrà filtrato dal filtro dei `release*` tag pipeline e avvierà la pipeline.

   ```
   git tag release-1 49366bd
   ```

   ```
   git push origin release-1
   ```  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/git-tags-pipeline.png)

## Passaggio 4: Rilascia le modifiche e visualizza i log
<a name="tutorials-github-tags-view"></a>

1. Dopo che la pipeline è stata eseguita correttamente, nella fase di compilazione corretta, scegli **Visualizza** registro.

   In **Log**, visualizza l'output della CodeBuild build. I comandi restituiscono il valore della variabile immessa.

1. Nella pagina **Cronologia**, visualizza la colonna **Trigger**. Visualizza il tipo di trigger **GitTag : release-1**.

# Tutorial: filtra i nomi delle filiali per le richieste pull per avviare la pipeline (tipo V2)
<a name="tutorials-github-featurebranches"></a>

In questo tutorial, creerai una pipeline che si collega al tuo repository GitHub .com in cui l'azione source è configurata per avviare la pipeline con una configurazione di trigger che filtra le richieste pull. Quando si verifica uno specifico evento di pull request per un ramo specifico, viene avviata la pipeline. Questo esempio mostra come creare una pipeline che consenta il filtraggio dei nomi delle filiali. Per ulteriori informazioni sull'utilizzo dei trigger, vedere. [Aggiungi filtri per i tipi di eventi di richiesta push e pull (CLI)](pipelines-filter.md#pipelines-filter-cli) Per ulteriori informazioni sul filtraggio con pattern regex in formato glob, consulta. [Lavorare con i modelli a globo nella sintassi](syntax-glob.md)

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

Questo tutorial si connette a .com tramite il tipo di azione. GitHub `CodeStarSourceConnection`

**Topics**
+ [

## Prerequisiti
](#tutorials-github-featurebranches-prereq)
+ [

## Passaggio 1: crea una pipeline da avviare su richiesta pull per rami specifici
](#tutorials-github-featurebranches-pipeline)
+ [

## Passaggio 2: crea e unisci una richiesta pull in GitHub .com per avviare le esecuzioni della pipeline
](#tutorials-github-featurebranches-pullrequest)

## Prerequisiti
<a name="tutorials-github-featurebranches-prereq"></a>

Prima di iniziare è necessario:
+ Crea un GitHub repository.com con il tuo account GitHub .com.
+ Tieni a portata di mano GitHub le tue credenziali. Quando utilizzi il Console di gestione AWS per configurare una connessione, ti viene chiesto di accedere con GitHub le tue credenziali. 

## Passaggio 1: crea una pipeline da avviare su richiesta pull per rami specifici
<a name="tutorials-github-featurebranches-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con una connessione al repository e all'azione GitHub .com.
+ Una fase di compilazione con un'azione di AWS CodeBuild compilazione.

**Per creare una pipeline con la procedura guidata**

1. Accedi alla CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyFilterBranchesPipeline**

1. **Nel **tipo di tubazione**, mantenete la selezione di default su V2.** I tipi di tubazioni differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md).

1. In **Service Role (Ruolo del servizio)**, scegliere **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Se invece scegli di utilizzare il tuo ruolo di CodePipeline servizio esistente, assicurati di aver aggiunto l'autorizzazione `codeconnections:UseConnection` IAM alla tua politica del ruolo di servizio. Per istruzioni sul ruolo CodePipeline di servizio, consulta [Aggiungere autorizzazioni al ruolo CodePipeline di servizio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. In **Impostazioni avanzate** non modificare le impostazioni predefinite. In **Artifact store (Archivio artefatti)**, seleziona **Default location (Posizione predefinita)** per utilizzare l'archivio artefatti predefinito, ad esempio il bucket Amazon S3 dedicato agli artefatti designato come predefinito, per la pipeline nella regione selezionata.
**Nota**  
Non si tratta del bucket di origine per il codice sorgente, ma dell'archivio artefatti per la pipeline. È richiesto un archivio artefatti separato, ad esempio un bucket S3, per ogni pipeline.

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Nome repository**, scegli il nome del tuo repository GitHub .com.

   1. In **Tipo di trigger**, scegli **Specificare** filtro.

      In **Tipo di evento**, scegli **Pull request**. Seleziona tutti gli eventi sotto richiesta pull in modo che l'evento si verifichi per le richieste pull create, aggiornate o chiuse.

      In **Branches**, nel campo **Includi**, inserisci`main*`.  
![\[Immagine che mostra l'opzione Includi rami selezionata con un valore di main* per un trigger con un tipo di evento di richiesta Pull\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/pullreq-example-triggers-edit.png)
**Importante**  
Le pipeline che iniziano con questo tipo di trigger verranno configurate per gli eventi WebHookV2 e non utilizzeranno l'evento Webhook (rilevamento delle modifiche su tutti gli eventi push) per avviare la pipeline.

   Scegli **Next (Successivo)**.

1. **Nel **passaggio 4: Aggiungi la fase di compilazione, in Build provider, scegli**. **AWS CodeBuild**** Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline. Scegli o crea il progetto di compilazione come indicato in[Tutorial: usa i tag Git per avviare la tua pipeline](tutorials-github-tags.md). Questa azione verrà utilizzata in questo tutorial solo come seconda fase necessaria per creare la pipeline.

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.**

## Passaggio 2: crea e unisci una richiesta pull in GitHub .com per avviare le esecuzioni della pipeline
<a name="tutorials-github-featurebranches-pullrequest"></a>

In questa sezione, crei e unisci una pull request. Questo avvia la pipeline, con un'esecuzione per la pull request aperta e un'esecuzione per la pull request chiusa.

**Per creare una pull request e avviare la pipeline**

1. In GitHub .com, crea una richiesta pull apportando una modifica a README.md su un ramo di funzionalità e inviando una richiesta pull al ramo. `main` Conferma la modifica con un messaggio del tipo. `Update README.md for PR`

1. La pipeline inizia con la revisione del codice sorgente che mostra il messaggio **Source** per la pull request come **Update README.md** for PR.  
![\[Immagine che mostra il messaggio sorgente per la richiesta Pull con il seguente testo: Update README.md for PR\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/pullreq-example.png)

1. Scegliere **History (Cronologia)**. Nella cronologia di esecuzione della pipeline, visualizza gli eventi di stato delle richieste pull CREATED e MERGED che hanno avviato le esecuzioni della pipeline.  
![\[Immagine che mostra la cronologia di esecuzione della pipeline che mostra gli eventi di stato delle richieste pull CREATED e MERGED che hanno avviato le esecuzioni della pipeline\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/pullreq-example-history.png)

# Tutorial: utilizzare le variabili a livello di pipeline
<a name="tutorials-pipeline-variables"></a>

In questo tutorial, creerai una pipeline in cui aggiungi una variabile a livello di pipeline ed eseguirai un'azione di CodeBuild compilazione che restituisce il valore della variabile.

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

**Topics**
+ [

## Prerequisiti
](#tutorials-pipeline-variables-prereq)
+ [

## Passaggio 1: crea la tua pipeline e crea il progetto
](#tutorials-pipeline-variables-pipeline)
+ [

## Passaggio 2: Rilascia le modifiche e visualizza i log
](#tutorials-pipeline-variables-view)

## Prerequisiti
<a name="tutorials-pipeline-variables-prereq"></a>

Prima di iniziare è necessario:
+ Crea un repository. CodeCommit 
+ Aggiungi un file.txt al repository.

## Passaggio 1: crea la tua pipeline e crea il progetto
<a name="tutorials-pipeline-variables-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con una connessione al tuo CodeCommit repository.
+ Una fase di compilazione con un'azione di AWS CodeBuild compilazione.

**Per creare una pipeline con la procedura guidata**

1. Accedi alla CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyVariablesPipeline**

1. **Nel **tipo di tubazione**, mantenete la selezione di default su V2.** I tipi di tubazioni differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md).

1. In **Service Role (Ruolo del servizio)**, scegliere **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Se invece scegli di utilizzare il tuo ruolo di CodePipeline servizio esistente, assicurati di aver aggiunto l'autorizzazione `codeconnections:UseConnection` IAM alla tua politica del ruolo di servizio. Per istruzioni sul ruolo CodePipeline di servizio, consulta [Aggiungere autorizzazioni al ruolo CodePipeline di servizio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. In **Variabili**, scegli **Aggiungi variabile**. In **Nome**, inserisci `timeout`. In **Predefinito**, inserisci 1000. Nella descrizione, immettere la seguente descrizione:**Timeout**.

   Questo creerà una variabile in cui è possibile dichiarare il valore all'avvio dell'esecuzione della pipeline. I nomi delle variabili devono corrispondere `[A-Za-z0-9@\-_]+` e possono essere qualsiasi cosa tranne una stringa vuota.

1. In **Impostazioni avanzate** non modificare le impostazioni predefinite. In **Artifact store (Archivio artefatti)**, seleziona **Default location (Posizione predefinita)** per utilizzare l'archivio artefatti predefinito, ad esempio il bucket Amazon S3 dedicato agli artefatti designato come predefinito, per la pipeline nella regione selezionata.
**Nota**  
Non si tratta del bucket di origine per il codice sorgente, ma dell'archivio artefatti per la pipeline. È richiesto un archivio artefatti separato, ad esempio un bucket S3, per ogni pipeline.

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider (Provider origine)**, scegliere **AWS CodeCommit**.

   1. In **Nome del deposito e Nome del** **ramo, scegli il** tuo repository e il tuo ramo.

   Scegli **Next (Successivo)**.

1. Nel **passaggio 4: Aggiungi fase di compilazione, aggiungi una fase** di compilazione:

   1. In **Build provider (Provider compilazione)**, scegli **AWS CodeBuild**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. **Per **Image**, scegliete: 5.0aws/codebuild/standard.**

   1. Per **Service Role (Ruolo del servizio)**, scegli **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Annota il nome del tuo ruolo di servizio. CodeBuild Avrai bisogno del nome del ruolo per l'ultimo passaggio di questo tutorial.

   1. In **Buildspec**, per **Build specifications** (Specifiche di compilazione), scegli **Insert build commands (Inserisci comandi di compilazione)**. Scegli **Passa all'editor** e incolla quanto segue nei **comandi di compilazione**. In buildspec, la variabile customer `$CUSTOM_VAR1` verrà utilizzata per generare la variabile pipeline nel registro di compilazione. Creerai la variabile `$CUSTOM_VAR1` di output come variabile di ambiente nel passaggio successivo.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - echo $CUSTOM_VAR1
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Scegli **Continua a CodePipeline**. Questo ritorna alla CodePipeline console e crea un CodeBuild progetto che utilizza i comandi di compilazione per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

   1. **In **Variabili di ambiente *- facoltativo***, per creare una variabile di ambiente come variabile di input per l'azione di compilazione che verrà risolta dalla variabile a livello di pipeline, scegli Aggiungi variabile di ambiente.** Questo creerà la variabile specificata in buildspec as. `$CUSTOM_VAR1` In **Nome**, inserisci `CUSTOM_VAR1`. In **Valore**, immetti `#{variables.timeout}`. In **Tipo, scegliete**. `Plaintext`

      Il `#{variables.timeout}` valore della variabile di ambiente si basa sullo spazio dei nomi della variabile a livello di pipeline `variables` e sulla variabile a livello di pipeline creata per la pipeline nel passaggio 7. `timeout`

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.**

## Passaggio 2: Rilascia le modifiche e visualizza i log
<a name="tutorials-pipeline-variables-view"></a>

1. Dopo che la pipeline è stata eseguita correttamente, nella fase di compilazione corretta, scegli **Visualizza** dettagli.

   Nella pagina dei dettagli, scegli la scheda **Registri.** Visualizza l'output della CodeBuild build. I comandi restituiscono il valore della variabile inserita.

1. **Nel navigatore a sinistra, scegli Cronologia.**

   **Scegli l'esecuzione recente, quindi scegli la scheda Variabili.** Visualizzate il valore risolto per la variabile pipeline.

# Tutorial: creazione di una semplice pipeline (bucket S3)
<a name="tutorials-simple-s3"></a>

Il modo più semplice per creare una pipeline consiste nell'utilizzare la procedura guidata **Crea** pipeline nella console. AWS CodePipeline 

In questo tutorial, creerai una pipeline a due fasi che utilizza un bucket di sorgenti S3 con versioni diverse e rilascerai un'applicazione di esempio. CodeDeploy 

**Nota**  
Se Amazon S3 è il fornitore di origine per la tua pipeline, puoi comprimere il file o i file sorgente in un unico .zip e caricare il file.zip nel tuo bucket di origine. È inoltre possibile caricare un singolo file decompresso; tuttavia, le operazioni a valle che si aspettano un file con estensione .zip avranno esito negativo.

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

Una volta creata questa pipeline semplice, puoi aggiungere un'altra fase e quindi disabilitare e abilitare la transizione tra fasi.

**Importante**  
Molte delle azioni che aggiungi alla pipeline in questa procedura coinvolgono AWS risorse che devi creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

Prima di iniziare, occorre completare i prerequisiti in [Iniziare con CodePipeline](getting-started-codepipeline.md).

**Topics**
+ [

## Passaggio 1: crea un bucket di origine S3 per la tua applicazione
](#s3-create-s3-bucket)
+ [

## Fase 2: creare istanze Amazon EC2 Windows e installare l'agente CodeDeploy
](#S3-create-instances)
+ [

## Passaggio 3: Creare un'applicazione in CodeDeploy
](#S3-create-deployment)
+ [

## Passaggio 4: Crea la tua prima pipeline in CodePipeline
](#s3-create-pipeline)
+ [

## (Opzionale) Fase 5: aggiunta di un'altra fase alla pipeline
](#s3-add-stage)
+ [

## (Facoltativo) Fase 6: Disabilitare e abilitare le transizioni tra le fasi in CodePipeline
](#s3-configure-transitions)
+ [

## Fase 7: eliminazione delle risorse
](#s3-clean-up)

## Passaggio 1: crea un bucket di origine S3 per la tua applicazione
<a name="s3-create-s3-bucket"></a>

Puoi archiviare i file di origine o le applicazioni in qualsiasi percorso con versioni multiple. In questo tutorial, crei un bucket S3 per i file dell'applicazione di esempio e abiliti il controllo delle versioni su quel bucket. Dopo aver abilitato la funzione Versioni multiple, puoi copiare le applicazioni di esempio nel bucket. 

**Per creare un bucket S3**

1. Accedi alla console all'indirizzo. Console di gestione AWS Apri la console S3.

1. Seleziona **Crea bucket**.

1. Per **Bucket Name (Nome bucket)**, immettere un nome per il bucket, ad esempio **awscodepipeline-demobucket-example-date**.
**Nota**  
Poiché tutti i nomi dei bucket in Amazon S3 devono essere univoci, usane uno personalizzato, non il nome mostrato nell'esempio. È possibile modificare il nome dell'esempio semplicemente aggiungendo la data. Prendere nota di questo nome perché sarà necessario nel resto di questo tutorial.

   **In **Regione**, scegli la regione in cui intendi creare la pipeline, ad esempio **Stati Uniti occidentali (Oregon)**, quindi scegli Crea bucket.**

1. Dopo aver creato il bucket, viene visualizzato un banner di successo. Scegliere **Go to bucket details (Vai ai dettagli del bucket)**.

1. Nella scheda **Properties (Proprietà)** scegliere **Versioning (Funzione Versioni multiple)**. Scegliere **Enable versioning (Abilita funzione Versioni multiple)**, quindi scegliere **Save (Salva)**.

   Quando il controllo delle versioni è abilitato, Amazon S3 salva ogni versione di ogni oggetto nel bucket.

1. Nella scheda **Permissions (Autorizzazioni)**, lasciare le impostazioni predefinite. Per ulteriori informazioni sul bucket S3 e le autorizzazioni oggetto, consulta [Specificare le autorizzazioni in una policy](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html).

1. Quindi, scaricare un esempio e salvarlo in una cartella o directory sul computer locale.

   1. Scegliere una delle seguenti opzioni. Scegliere `SampleApp_Windows.zip` se si desidera seguire la procedura descritta in questo tutorial per le istanze di Windows Server.
      + [Se desideri eseguire la distribuzione su istanze Amazon Linux utilizzando CodeDeploy, scarica l'applicazione di esempio qui: SampleApp \$1Linux.zip.](samples/SampleApp_Linux.zip)
      + [Se desideri eseguire la distribuzione su istanze di Windows Server utilizzando CodeDeploy, scarica l'applicazione di esempio qui: \$1Windows.zip. SampleApp](samples/SampleApp_Windows.zip)

      L'applicazione di esempio contiene i seguenti file con cui eseguire la distribuzione: CodeDeploy 
      + `appspec.yml`— Il file delle specifiche dell'applicazione (AppSpecfile) è un file in formato [YAML](http://www.yaml.org) utilizzato da CodeDeploy per gestire una distribuzione. *Per ulteriori informazioni sul AppSpec file, vedere [CodeDeploy AppSpec File reference](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) nella Guida per l'utente.AWS CodeDeploy *
      + `index.html`— Il file indice contiene la home page dell'applicazione di esempio distribuita.
      + `LICENSE.txt`— Il file di licenza contiene informazioni sulla licenza per l'applicazione di esempio.
      + File per script: l'applicazione di esempio utilizza script per scrivere file di testo in una posizione sull'istanza. Un file viene scritto per ciascuno dei diversi eventi del ciclo di vita della CodeDeploy distribuzione nel modo seguente:
        + `scripts`Cartella (solo esempio Linux): la cartella contiene i seguenti script di shell per installare le dipendenze e avviare e arrestare l'applicazione di esempio per la distribuzione automatizzata:`install_dependencies`, e. `start_server` `stop_server`
        + (Solo esempio per Windows)`before-install.bat`: si tratta di uno script batch per l'evento del ciclo di vita della `BeforeInstall` distribuzione, che verrà eseguito per rimuovere i vecchi file scritti durante le distribuzioni precedenti di questo esempio e creare una posizione sull'istanza in cui scrivere i nuovi file.

   1. Scarica il file compresso. Non decomprimere il file.

1. Nella console Amazon S3, per il tuo bucket, carica il file:  

   1. Scegli **Carica**. 

   1. Trascina il file oppure scegli **Add files (Aggiungi file)** e individua il file.

   1. Scegli **Carica**.

## Fase 2: creare istanze Amazon EC2 Windows e installare l'agente CodeDeploy
<a name="S3-create-instances"></a>

**Nota**  
Questo tutorial fornisce passaggi di esempio per creare istanze Windows di Amazon EC2. Per esempi di passaggi per creare istanze Amazon EC2 Linux, consulta. [Fase 3: creare un'istanza Amazon EC2 Linux e installare l'agente CodeDeploy](tutorials-simple-codecommit.md#codecommit-create-deployment) Quando viene richiesto il numero di istanze da creare, specificare **2** istanze.

In questo passaggio, creerai le istanze Windows Server Amazon EC2 su cui distribuirai un'applicazione di esempio. Come parte di questo processo, crei un ruolo dell'istanza con politiche che consentono l'installazione e la gestione dell' CodeDeploy agente sulle istanze. L' CodeDeploy agente è un pacchetto software che consente di utilizzare un'istanza nelle CodeDeploy distribuzioni. È inoltre possibile allegare politiche che consentono all'istanza di recuperare i file utilizzati dall' CodeDeploy agente per distribuire l'applicazione e di consentire la gestione dell'istanza da parte di SSM.

**Per creare un ruolo dell'istanza**

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

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

1. Scegli **Crea ruolo**.

1. In **Seleziona il tipo di entità affidabile**, seleziona **Servizio AWS**. In **Choose a use case (Scegliere un caso d'uso)**, selezionare **EC2**, quindi scegliere **Next: Permissions (Successivo: autorizzazioni)**.

1. Cerca e seleziona la politica denominata **`AmazonEC2RoleforAWSCodeDeploy`**.

1. Cerca e seleziona la politica denominata **`AmazonSSMManagedInstanceCore`**. Scegliere **Next: Tags (Successivo: Tag)**.

1. Scegliere **Next:Review (Successivo: Rivedi)**. Immettere un nome per il ruolo (ad esempio **EC2InstanceRole**).
**Nota**  
Prendere nota del nome del ruolo per la fase successiva. È possibile scegliere questo ruolo quando si crea l'istanza.

   Scegli **Crea ruolo**.

**Per avviare istanze**

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

1. Dalla barra di navigazione laterale, scegli **Istanze** e seleziona **Avvia istanze** nella parte superiore della pagina.

1. In **Nome e tag**, in **Nome, inserisci**. **MyCodePipelineDemo** Questo assegna alle istanze un tag **Key** di **Name** e un tag **Value** di. **MyCodePipelineDemo** Successivamente, si crea un' CodeDeploy applicazione che distribuisce l'applicazione di esempio alle istanze. CodeDeployseleziona le istanze da distribuire in base ai tag.

1. In **Immagini dell'applicazione e del sistema operativo (Amazon Machine Image)**, scegli l'opzione **Windows**. (Questa AMI è descritta come **Microsoft Windows Server 2019 Base** ed è etichettata come «Idonea per il livello gratuito» e può essere trovata in **Quick Start**.)

1. In **Tipo di istanza**, scegli il `t2.micro` tipo idoneo al piano gratuito come configurazione hardware per la tua istanza.

1. In **Coppia di chiavi (login)**, scegli una coppia di chiavi o creane una. 

   Puoi anche scegliere **Proceed without a key pair**.
**Nota**  
Ai fini di questo tutorial, è possibile procedere senza una coppia di chiavi. Per utilizzare SSH per connettersi alle istanze, creare o utilizzare una coppia di chiavi.

1. In **Impostazioni di rete**, procedi come segue.

   **In **Assegna automaticamente un IP pubblico**, assicurati che lo stato sia Abilita.**
   + Accanto a **Assign a security group (Assegna un gruppo di sicurezza)**, scegliere **Create a new security group (Crea un nuovo gruppo di sicurezza)**.
   + **Nella riga relativa a **SSH**, in **Tipo di sorgente**, scegli Il mio IP.**
   + Scegli **Aggiungi gruppo di sicurezza**, scegli **HTTP**, quindi in **Tipo di origine**, scegli **Il mio IP**.

1. Espandi **Advanced details** (Dettagli avanzati). Nel **profilo dell'istanza** IAM, scegli il ruolo IAM che hai creato nella procedura precedente (ad esempio,**EC2InstanceRole**).

1. In **Riepilogo**, in **Numero di istanze**, inserisci.. `2`

1. Scegliere **Launch Instance (Avvia istanza)**.

1. Scegli **View Instances** (Visualizza istanze) per chiudere la pagina di conferma e tornare alla console.

1. È possibile visualizzare lo stato dell'avvio nella pagina **Instances (Istanze)**. Quando avvii un'istanza, il suo stato iniziale è `pending`. Una volta avviata l'istanza, il suo stato passa a `running` e riceve un nome DNS pubblico. Se la colonna **Public DNS (DNS pubblico)** non è visualizzata, scegliere l'icona **Show/Hide (Mostra/Nascondi)** quindi selezionare **Public DNS (DNS pubblico)**.

1. Possono essere necessari alcuni minuti prima che sia possibile connettersi all'istanza. Verifica che l’istanza abbia superato i controlli dello stato. Queste informazioni sono disponibili nella colonna **Status Checks (Verifiche di stato)**.

## Passaggio 3: Creare un'applicazione in CodeDeploy
<a name="S3-create-deployment"></a>

In CodeDeploy, un'*applicazione* è un identificatore, sotto forma di nome, per il codice che si desidera distribuire. CodeDeploy utilizza questo nome per garantire che durante una distribuzione venga fatto riferimento alla combinazione corretta di revisione, configurazione di distribuzione e gruppo di distribuzione. Il nome dell' CodeDeploy applicazione creata in questo passaggio viene selezionato quando si crea la pipeline più avanti in questo tutorial.

Per prima cosa crei un ruolo di servizio CodeDeploy da utilizzare. Se è già stato creato un ruolo di servizio, non è necessario crearne un altro.

**Per creare un ruolo CodeDeploy di servizio**

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

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

1. Scegli **Crea ruolo**.

1. In **Seleziona entità affidabile**, scegli **Servizio AWS**. In **Use case** (Caso d'uso), scegli **CodeDeploy**. Scegli **CodeDeploy**tra le opzioni elencate. Scegli **Next (Successivo)**. La policy gestita `AWSCodeDeployRole` è già collegata al ruolo.

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

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

**Per creare un'applicazione in CodeDeploy**

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

1. **Se la pagina **Applicazioni** non viene visualizzata, nel AWS CodeDeploy menu, scegli Applicazioni.**

1. Scegli **Crea applicazione**.

1. In **Application name (Nome applicazione)**, immettere `MyDemoApplication`. 

1. In **Compute Platform (Piattaforma di calcolo)**, scegliere **EC2/On-premises (EC2/Locale)**.

1. Scegli **Crea applicazione**.

**Per creare un gruppo di distribuzione in CodeDeploy**

1. Nella pagina in cui è visualizzata l'applicazione, scegliere **Create deployment group (Crea gruppo di distribuzione)**.

1. In **Deployment group name (Nome del gruppo di distribuzione)**, immettere **MyDemoDeploymentGroup**.

1. In **Ruolo di servizio**, scegli il ruolo di servizio che hai creato in precedenza. È necessario utilizzare un ruolo di servizio che AWS CodeDeploy garantisca almeno la fiducia e le autorizzazioni descritte in [Creare un ruolo di servizio](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-create-service-role.html) per. CodeDeploy Per ottenere l'ARN del ruolo di servizio, consulta [Ottenere l'ARN del ruolo di servizio (console)](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#getting-started-get-service-role-console).

1. In **Deployment type (Tipo di distribuzione)**, scegliere **In-place (In loco)**.

1. In **Environment configuration (Configurazione dell'ambiente)**, scegliere **Amazon EC2 Instances (Istanze Amazon EC2)**. Scegliere **Name (Nome)** nel campo **Key (Chiave)** e nel campo **Value (Valore)**, immettere **MyCodePipelineDemo**. 
**Importante**  
Scegliere qui lo stesso valore per la chiave **Name (Nome)** che è stato assegnato all'istanza EC2 al momento della creazione. Se l'istanza è stata taggata in maniera diversa da **MyCodePipelineDemo**, assicurarsi di utilizzare tale valore qui.

1. In **Configurazione dell'agente con AWS Systems Manager**, scegli **Ora e pianifica gli aggiornamenti**. Questo installa l'agente sull'istanza. L'istanza Windows è già configurata con l'agente SSM e verrà ora aggiornata con l' CodeDeploy agente.

1. In **Impostazioni di distribuzione**, scegli`CodeDeployDefault.OneAtaTime`.

1. In **Load Balancer**, assicurati che la casella **Enable load balancing** non sia selezionata. Non è necessario configurare un sistema di bilanciamento del carico o scegliere un gruppo di destinazione per questo esempio. Dopo aver deselezionato la casella di controllo, le opzioni di bilanciamento del carico non vengono visualizzate.

1. Nella sezione **Advanced (Impostazioni avanzate)** mantenere le impostazioni predefinite.

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

## Passaggio 4: Crea la tua prima pipeline in CodePipeline
<a name="s3-create-pipeline"></a>

In questa parte del tutorial, verrà creata la pipeline. L'esempio viene eseguito automaticamente tramite la pipeline.

**Per creare un CodePipeline processo di rilascio automatico**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyFirstPipeline** 
**Nota**  
Se si sceglie un altro nome per la pipeline, accertarsi di utilizzarlo al posto di **MyFirstPipeline** nella parte restante di questo tutorial. Non è possibile modificare il nome di una pipeline dopo che è stata creata. I nomi di pipeline sono soggetti ad alcune limitazioni. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md). 

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

1. In **Service role (Ruolo del servizio)**, procedere in uno dei seguenti modi:
   + Scegli **Nuovo ruolo di servizio** CodePipeline per consentire la creazione di un nuovo ruolo di servizio in IAM.
   + Scegli **Existing service role (Ruolo di servizio esistente)** per usare un ruolo del servizio già creato in IAM. In **Role name (Nome ruolo)**, scegli il ruolo del servizio dall'elenco.

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **Amazon S3**. In **Bucket**, immettere il nome del bucket S3 creato in [Passaggio 1: crea un bucket di origine S3 per la tua applicazione](#s3-create-s3-bucket). Nella **chiave oggetto S3**, immettere la chiave oggetto con o senza un percorso file e ricordarsi di includere l'estensione del file. Ad esempio, per `SampleApp_Windows.zip`, immettere il nome del file di esempio come illustrato in questo esempio:

   ```
   SampleApp_Windows.zip
   ```

   Seleziona **Fase successiva**.

   In **Change detection options (Opzioni di rilevamento delle modifiche)**, lasciare le impostazioni predefinite. Ciò consente di CodePipeline utilizzare Amazon CloudWatch Events per rilevare le modifiche nel bucket di origine.

    Scegli **Next (Successivo)**.

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

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di distribuzione, in **Deploy**** provider, scegli. **CodeDeploy ** Per impostazione predefinita, il campo **Regione** è lo stesso Regione AWS della pipeline. In **Application name (Nome applicazione)**, immettere `MyDemoApplication` oppure scegliere il pulsante **Refresh (Aggiorna)** e quindi selezionare il nome dell'applicazione dall'elenco. In **Deployment group (Gruppo di distribuzione)**, immettere **MyDemoDeploymentGroup** o selezionarlo dall'elenco, quindi scegliere **Next (Successivo)**. 
**Nota**  
Il nome "Deploy (Distribuzione)" è il nome assegnato per impostazione predefinita alla fase creata in **Step 4: Add deploy stage (Fase 4: aggiunta della fase di distribuzione)**, così come "Source (Origine)" è il nome assegnato alla prima fase della pipeline. 

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

1. La pipeline inizia l'esecuzione. Puoi visualizzare lo stato di avanzamento e i messaggi di successo e di fallimento mentre l' CodePipeline esempio distribuisce una pagina Web su ciascuna delle istanze Amazon EC2 della distribuzione. CodeDeploy

Complimenti\$1 Hai appena creato una semplice pipeline in. CodePipeline La pipeline è composta da due fasi:
+ Una fase di origine denominata **Source (Origine)**, che rileva le modifiche nell'applicazione di esempio con versioni multiple archiviate nel bucket S3 ed esegue il push di tali modifiche nella pipeline.
+ Una fase **Deploy (Distribuzione)** che distribuisce tali modifiche alle istanze EC2 con CodeDeploy. 

Verifica ora i risultati.

**Per verificare che la pipeline è stata eseguita correttamente**

1. Visualizzare l'avanzamento iniziale della pipeline. Lo stato di ciascuna fase cambia da **No executions yet (Ancora nessun esecuzione)** a **In Progress (In corso)** e quindi in **Succeeded (Riuscito)** o **Failed (Non riuscito)**. L'esecuzione della pipeline richiede qualche minuto.

1. Quando lo stato dell'operazione indica **Succeeded (Riuscito)**, nell'area di stato per la fase **Deploy (Distribuzione)**, scegliere **Details (Dettagli)**. Questo apre la CodeDeploy console.

1. Nella scheda **Deployment group (Gruppo di distribuzione)**, in **Deployment lifecycle events (Eventi del ciclo di vita di distribuzione)**, scegliere un ID dell'istanza. Si apre la console EC2.

1. Nella scheda **Description (Descrizione)**, in **Public DNS (DNS pubblico)**, copiare l'indirizzo e incollarlo nella barra degli indirizzi del browser Web. Visualizzare la pagina di indice per l'applicazione di esempio caricata nel bucket S3.

   Viene visualizzata la pagina Web dell'applicazione di esempio che hai caricato nel tuo bucket S3.

Per ulteriori informazioni sulle fasi, sulle operazioni e sul funzionamento delle pipeline, consulta [CodePipeline concetti ](concepts.md).

## (Opzionale) Fase 5: aggiunta di un'altra fase alla pipeline
<a name="s3-add-stage"></a>

Aggiungi ora un'altra fase nella pipeline per la distribuzione da server di gestione temporanea a server di produzione utilizzando CodeDeploy. Innanzitutto, crei un altro gruppo di distribuzione all' CodePipelineDemoApplication interno. CodeDeploy Quindi, aggiungi una fase che include un'operazione che utilizza questo gruppo di distribuzione. Per aggiungere un'altra fase, è necessario utilizzare la CodePipeline console o AWS CLI recuperare e modificare manualmente la struttura della pipeline in un file JSON, quindi eseguire il **update-pipeline** comando per aggiornare la pipeline con le modifiche.

**Topics**
+ [

### Crea un secondo gruppo di distribuzione in CodeDeploy
](#s3-add-stage-part-1)
+ [

### Aggiunta del gruppo di distribuzione come un'altra fase nella pipeline
](#s3-add-stage-part-2)

### Crea un secondo gruppo di distribuzione in CodeDeploy
<a name="s3-add-stage-part-1"></a>

**Nota**  
In questa parte del tutorial, crei un secondo gruppo di distribuzione, ma esegui la distribuzione sulle stesse istanze Amazon EC2 di prima. Questo esempio è solo a scopo dimostrativo. È stato progettato appositamente per non mostrarti come vengono visualizzati gli errori. CodePipeline

**Per creare un secondo gruppo di distribuzione in CodeDeploy**

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

1. Scegliere **Applications (Applicazioni)** e selezionare `MyDemoApplication` nell'elenco di applicazioni.

1. Scegliere la scheda **Deployment groups (Gruppi di distribuzione)**, quindi scegliere **Create deployment group (Crea gruppo di distribuzione)**.

1. Nella pagina **Create deployment group (Crea gruppo di distribuzione)**, in **Deployment group name (Nome del gruppo di distribuzione)**, immettere un nome per il secondo gruppo di distribuzione, ad esempio **CodePipelineProductionFleet**.

1. In **Service Role**, scegli lo stesso ruolo di CodeDeploy servizio che hai usato per la distribuzione iniziale (non il ruolo di CodePipeline servizio).

1. In **Deployment type (Tipo di distribuzione)**, scegliere **In-place (In loco)**.

1. In **Environment configuration (Configurazione dell'ambiente)**, scegliere **Amazon EC2 Instances (Istanze Amazon EC2)**. Scegliere **Nome** nella casella **Key (Chiave)** e nella casella **Value (Valore)** scegliere `MyCodePipelineDemo` dall'elenco. Lasciare la configurazione predefinita per **Deployment settings (Impostazioni di distribuzione)**. 

1. In **Deployment configuration (Configurazione della distribuzione)**, scegliere `CodeDeployDefault.OneAtaTime`.

1. In **Load Balancer (Sistema di bilanciamento del carico)**, deselezionare **Enable load balancing (Abilita il bilanciamento del carico)**.

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

### Aggiunta del gruppo di distribuzione come un'altra fase nella pipeline
<a name="s3-add-stage-part-2"></a>

Ora che disponi di un altro gruppo di distribuzione, puoi aggiungere una fase che utilizza questo gruppo di distribuzione per la distribuzione alle stesse istanze EC2 utilizzate in precedenza. Puoi usare la CodePipeline console o AWS CLI aggiungere questa fase. 

**Topics**
+ [

#### Creazione di una terza fase (console)
](#s3-add-stage-part-2-console)
+ [

#### Creazione di una terza fase (CLI)
](#s3-add-stage-part-2-cli)

#### Creazione di una terza fase (console)
<a name="s3-add-stage-part-2-console"></a>

È possibile utilizzare la CodePipeline console per aggiungere una nuova fase che utilizza il nuovo gruppo di distribuzione. Poiché questo gruppo di distribuzione sta eseguendo la distribuzione alle istanze EC2 che hai già utilizzato, l'operazione di distribuzione in questa fase non va a buon fine. 

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

1. In **Name (Nome)**, scegliere il nome della pipeline creata, MyFirstPipeline. 

1. Nella pagina dei dettagli della pipeline, scegliere **Edit (Modifica)**. 

1. Nella pagina **Edit (Modifica)**, scegli **\$1 Add stage (Aggiungi fase)** per aggiungere una fase subito dopo la fase Deploy (Distribuzione).   
![\[Immagine che mostra il pulsante + Aggiungi stage nella schermata di modifica\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)

1. In **Aggiungi fase**, in **Nome fase**, inserisci**Production**. Selezionare **Add stage (Aggiungi fase)**.

1. Nella nuova fase, scegliere **\$1 Add action group (Aggiungi gruppo di operazioni)**.

1. In **Modifica azione**, in **Nome azione**, inserisci**Deploy-Second-Deployment**. In **Action provider**, in **Deploy**, scegli **CodeDeploy**.

1. Nella CodeDeploy sezione, in **Nome applicazione**, scegli `MyDemoApplication` dall'elenco a discesa, come hai fatto quando hai creato la pipeline. In **Deployment group (Gruppo di distribuzione)**, scegli il gruppo di distribuzione appena creato **CodePipelineProductionFleet**. In **Artefatti di input**, scegliere l'artefatto di input dall'azione sorgente. Scegli **Save** (Salva).

1. Nella pagina **Edit (Modifica)**, scegliere **Save (Salva)**. In **Save pipeline changes (Salva modifiche alla pipeline)**, scegliere **Save (Salva)**.

1. Anche se la nuova fase è stata aggiunta alla pipeline, viene visualizzato lo stato **No executions yet (Ancora nessun esecuzione)** perché le modifiche non hanno attivato un'altra esecuzione della pipeline. Per vedere come viene eseguita la pipeline modificata, è necessario rieseguire manualmente la revisione più recente. **Nella pagina dei dettagli della pipeline, scegli **Release change**, quindi scegli Release quando richiesto.** In questo modo viene eseguita la revisione più recente disponibile in ogni percorso di origine specificato in un'operazione origine tramite la pipeline. 

   In alternativa, per utilizzare il AWS CLI per rieseguire la pipeline, da un terminale sul computer Linux, macOS o Unix locale o da un prompt dei comandi sul computer Windows locale, esegui il comando, **start-pipeline-execution** specificando il nome della pipeline. In questo modo l'applicazione viene eseguita nel bucket di origine tramite la pipeline per una seconda volta.

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   Questo comando restituisce un oggetto `pipelineExecutionId`.

1. Torna alla CodePipeline console e nell'elenco delle pipeline, scegli di aprire la pagina di visualizzazione. **MyFirstPipeline**

   La pipeline mostra tre fasi e lo stato dell'artefatto in esecuzione attraverso queste tre fasi. L'esecuzione in tutte le fasi della pipeline potrebbe richiedere fino a cinque minuti. La distribuzione va a buon fine nelle prime due fasi, come in precedenza, ma nella fase **Production (Produzione)** l'operazione **Deploy-Second-Deployment (Distribuisci-seconda-distribuzione)** viene mostrata come non riuscita.

1. Nell'operazione **Deploy-Second-Deployment (Distribuisci-seconda-distribuzione)**, scegliere **Details (Dettagli)**. Si verrà reindirizzati alla pagina per la distribuzione CodeDeploy. In questo caso, l'errore è il risultato della distribuzione del primo gruppo di istanze a tutte le istanze EC2, senza lasciare alcuna istanza per il secondo gruppo di distribuzione.
**Nota**  
Questo errore è un comportamento predefinito per dimostrare cosa accade quando si verifica un errore in una fase della pipeline.

#### Creazione di una terza fase (CLI)
<a name="s3-add-stage-part-2-cli"></a>

Sebbene l'utilizzo AWS CLI di per aggiungere una fase alla pipeline sia più complesso rispetto all'utilizzo della console, offre una maggiore visibilità sulla struttura della pipeline.

**Per creare una terza fase per la pipeline**

1. Apri una sessione terminale sul tuo computer Linux, macOS o Unix locale o un prompt dei comandi sul tuo computer Windows locale ed esegui il **get-pipeline** comando per visualizzare la struttura della pipeline appena creata. Per **MyFirstPipeline**, digitare il comando seguente: 

   ```
   aws codepipeline get-pipeline --name "MyFirstPipeline"
   ```

   Questo comando restituisce la struttura di. MyFirstPipeline L'aspetto della prima parte dell'output è simile al seguente:

   ```
   {
       "pipeline": {
           "roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service",
           "stages": [
       ...
   ```

   La parte finale dell'output include i metadati della pipeline e l'aspetto è simile al seguente:

   ```
       ...
           ],
           "artifactStore": {
               "type": "S3"
               "location": "amzn-s3-demo-bucket",
           },
           "name": "MyFirstPipeline",
           "version": 4
       },
       "metadata": {
           "pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline",
           "updated": 1501626591.112,
           "created": 1501626591.112
       }
   }
   ```

1. Copiare e incollare questa struttura in un editor di testo semplice e salvare il file come **pipeline.json**. Per comodità, salvare il file nella stessa directory in cui si eseguono i comandi **aws codepipeline**.
**Nota**  
È possibile eseguire il piping di JSON direttamente in un file con il comando **get-pipeline** come segue:  

   ```
   aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
   ```

1. Copiare la sezione della fase **Deploy (Distribuzione)** e incollarla dopo le prime due fasi. Poiché si tratta di una fase di distribuzione, analogamente alla fase **Deploy (Distribuzione)**, utilizzarla come un modello per la terza fase. 

1. Cambia il nome della fase e i dettagli del gruppo di distribuzione. 

   **L'esempio seguente mostra il codice JSON aggiunto al file pipeline.json dopo la fase di distribuzione.** Modificare gli elementi sottolineati con nuovi valori. Ricordare di includere una virgola per separare le definizioni delle fasi **Deploy (Distribuzione)** e **Production (Produzione)**.

   ```
   ,
   {
       "name": "Production",
        "actions": [
           {
            "inputArtifacts": [
                {
                 "name": "MyApp"
                }
              ],
             "name": "Deploy-Second-Deployment",
             "actionTypeId": {
                 "category": "Deploy",
                 "owner": "AWS",
                 "version": "1",
                 "provider": "CodeDeploy"
                 },
            "outputArtifacts": [],
            "configuration": {
                 "ApplicationName": "CodePipelineDemoApplication",
                 "DeploymentGroupName": "CodePipelineProductionFleet"
                  },
            "runOrder": 1
           }
       ]
   }
   ```

1. Se stai utilizzando la struttura della pipeline recuperata tramite il comando **get-pipeline**, devi rimuovere le righe `metadata` dal file JSON. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi le righe `"metadata": { }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.

   Ad esempio, rimuovere dalla struttura le seguenti righe:

   ```
   "metadata": {  
     "pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
     "created": "date",
     "updated": "date"
     }
   ```

   Salvare il file.

1. Eseguire il comando **update-pipeline**, specificando il file JSON della pipeline, in modo analogo al seguente:

   ```
   aws codepipeline update-pipeline --cli-input-json file://pipeline.json
   ```

   Questo comando restituisce l'intera struttura della pipeline aggiornata.
**Importante**  
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.

1.  Eseguire il comando **start-pipeline-execution**, specificando il nome della pipeline. In questo modo l'applicazione viene eseguita nel bucket di origine tramite la pipeline per una seconda volta.

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   Questo comando restituisce un oggetto `pipelineExecutionId`.

1. Apri la CodePipeline console e scegli **MyFirstPipeline**dall'elenco delle pipeline.

   La pipeline mostra tre fasi e lo stato dell'artefatto in esecuzione attraverso queste tre fasi. L'esecuzione in tutte le fasi della pipeline potrebbe richiedere fino a cinque minuti. Anche se la distribuzione va buon fine sulle prime due fasi, come in precedenza, la fase **Production (Produzione)** mostra che l'operazione **Deploy-Second-Deployment (Distribuisci-seconda-distribuzione)** non è riuscita. 

1. Nell'operazione **Deploy-Second-Deployment (Distribuisci-seconda-distribuzione)**, scegliere **Details (Dettagli)** per visualizzare i dettagli dell'errore. Verrai reindirizzato alla pagina dei dettagli della CodeDeploy distribuzione. In questo caso, l'errore è il risultato della distribuzione del primo gruppo di istanze a tutte le istanze EC2, senza lasciare alcuna istanza per il secondo gruppo di distribuzione. 
**Nota**  
Questo errore è un comportamento predefinito per dimostrare cosa accade quando si verifica un errore in una fase della pipeline.

## (Facoltativo) Fase 6: Disabilitare e abilitare le transizioni tra le fasi in CodePipeline
<a name="s3-configure-transitions"></a>

Puoi abilitare o disabilitare la transizione tra fasi in una pipeline. La disabilitazione della transizione tra fasi consente di controllare manualmente le transizioni tra una fase e un'altra. Ad esempio, potrebbe essere necessario eseguire le prime due fasi di una pipeline, ma disabilitare le transizioni alla terza fase finché non si è pronti per distribuire in produzione, oppure durante la risoluzione di un problema o errore relativo a tale fase.

**Per disabilitare e abilitare le transizioni tra le fasi di una pipeline CodePipeline**

1. Apri la CodePipeline console e scegli **MyFirstPipeline**dall'elenco delle pipeline.

1. Nella pagina dei dettagli per la pipeline, scegliere il pulsante **Disable transition (Disabilita transizione)** tra la seconda fase, (**Deploy (Distribuzione)**) e la terza fase aggiunta nella sezione precedente, (**Production (Produzione)**).

1. In **Disable transition (Disabilita transizione)**, specificare il motivo della disabilitazione della transizione tra le fasi, quindi scegliere **Disable (Disabilita)**.

   La freccia tra le fasi visualizza un'icona e una modifica del colore e viene visualizzato il pulsante **Enable transition (Abilita transizione)**.  
![\[Immagine che mostra il motivo inserito per la disabilitazione della transizione come «Disabilitazione della transizione durante la risoluzione dei problemi»\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)

1. Caricare nuovamente l'esempio nel bucket S3. Poiché il bucket è con versioni multiple, questa modifica avvia la pipeline. 

1. Tornare alla pagina dei dettagli per la pipeline e osservare lo stato delle fasi. La visualizzazione della pipeline cambia per mostrare l'avanzamento e i messaggi di esito positivo sulle prime due fasi, ma nessuna modifica viene apportata sulla terza fase. Questo processo potrebbe richiedere alcuni minuti.

1. Abilitare la transizione selezionando il pulsante **Enable transition (Abilita transazione)** tra le due fasi. Nella finestra di dialogo **Enable transition (Abilita transazione)**, scegliere **Enable (Abilita)**. La fase inizia l'esecuzione entro pochi minuti e tenta di elaborare l'artefatto che è già stato eseguito nelle prime due fasi della pipeline.
**Nota**  
Se vuoi che questa terza fase abbia successo, modifica il gruppo di CodePipelineProductionFleet distribuzione prima di abilitare la transizione e specifica un set diverso di istanze EC2 in cui viene distribuita l'applicazione. Per ulteriori informazioni su come eseguire questa operazione, consulta [Modifica delle impostazioni del gruppo di distribuzione](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html). Se si creano più istanze EC2, è possibile che vengano addebitati costi aggiuntivi. 

## Fase 7: eliminazione delle risorse
<a name="s3-clean-up"></a>

Puoi utilizzare alcune delle risorse create in questo tutorial per il [Tutorial: creazione di una pipeline a quattro fasi](tutorials-four-stage-pipeline.md). Ad esempio, puoi riutilizzare l'applicazione e la CodeDeploy distribuzione. Puoi configurare un'azione di compilazione con un provider come CodeBuild, che è un servizio di compilazione completamente gestito nel cloud. È inoltre possibile configurare un'operazione di compilazione che utilizza un provider con un server o sistema di compilazione, ad esempio Jenkins.

Tuttavia, dopo aver completato questo ed eventuali altri tutorial, devi eliminare la pipeline e le risorse utilizzate, per evitare che ti venga addebitato un costo per l'utilizzo continuo di tali risorse. Innanzitutto, elimina la pipeline, quindi l' CodeDeploy applicazione e le istanze Amazon EC2 associate e infine il bucket S3.

**Per eliminare le risorse utilizzate in questo tutorial**

1. [Per ripulire CodePipeline le risorse, segui le istruzioni riportate in Eliminare una pipeline in. AWS CodePipeline](pipelines-delete.md)

1. Per ripulire le CodeDeploy risorse, segui le istruzioni in [Per pulire le risorse (console)](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console).

1. Per eliminare il bucket S3, segui le istruzioni in [Eliminazione o svuotamento di un bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html). Se non si prevede di creare altre pipeline, eliminare il bucket S3 creato per l'archiviazione degli artefatti pipeline. Per ulteriori informazioni su questo bucket, consulta [CodePipeline concetti ](concepts.md).

# Tutorial: crea una pipeline semplice (CodeCommit repository)
<a name="tutorials-simple-codecommit"></a>

In questo tutorial, lo utilizzerai CodePipeline per distribuire il codice gestito in un CodeCommit repository su una singola istanza Amazon EC2. La tua pipeline viene attivata quando invii una modifica al repository. CodeCommit La pipeline distribuisce le modifiche a un'istanza Amazon EC2 CodeDeploy utilizzandola come servizio di distribuzione.

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

La pipeline è composta da due fasi:
+ **Una fase di origine (Source) per la tua azione sorgente.** CodeCommit 
+ Una fase di distribuzione (**Deploy**) per l'azione CodeDeploy di distribuzione.

Il modo più semplice per iniziare AWS CodePipeline è utilizzare la procedura guidata **Create Pipeline** nella console. CodePipeline 

**Nota**  
Prima di iniziare, assicurati di aver configurato il tuo client Git per utilizzarlo CodeCommit. Per istruzioni, consulta [Configurazione di CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html).

## Passaggio 1: crea un CodeCommit repository
<a name="codecommit-create-repository"></a>

Innanzitutto, crei un repository in. CodeCommit La pipeline riceve il codice sorgente da questo repository quando viene eseguita. Inoltre, crei un repository locale in cui conservare e aggiornare il codice prima di inviarlo al CodeCommit repository.

**Per creare un repository CodeCommit**



1. Apri la CodeCommit console all'indirizzo [https://console.aws.amazon.com/codecommit/](https://console.aws.amazon.com/codecommit/).

1. Nel selettore della regione, scegli Regione AWS dove vuoi creare il repository e la pipeline. Per ulteriori informazioni, consulta [Regioni AWS ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html).

1. Nella pagina **Repositories (Repository)**, scegli **Create repository (Crea repository)**.

1. Nella pagina **Create repository (Crea repository)**, in **Repository name (Nome repository)**, immetti un nome per il repository (ad esempio **MyDemoRepo**).

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

**Nota**  
I passaggi rimanenti di questo tutorial vengono utilizzati **MyDemoRepo** per il nome del repository. CodeCommit Se scegli un nome differente, assicurati di utilizzarlo in tutto il tutorial.

**Per configurare un repository locale**

In questa fase, configurerai un repository locale per connetterti al repository CodeCommit remoto.
**Nota**  
Non è necessario configurare un repository locale. È inoltre possibile utilizzare la console per caricare file come descritto in[Passaggio 2: aggiungi codice di esempio al tuo CodeCommit repository](#codecommit-add-code).

1. Con il nuovo repository aperto nella console, scegli **Clone URL (Clona URL** ) nella parte superiore destra della pagina, quindi seleziona **Clone SSH (Clona SSH**). L'indirizzo per clonare il repository Git viene copiato negli Appunti.

1. Nel terminale o nella riga di comando, passare a una directory locale in cui si desidera archiviare il repository locale. In questo tutorial, utilizziamo `/tmp`.

1. Esegui il comando seguente per clonare il repository, sostituendo l'indirizzo SSH con quello copiato nella fase precedente. Questo comando crea una directory denominata `MyDemoRepo`. Copia un'applicazione di esempio in questa directory.

   ```
   git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
   ```

## Passaggio 2: aggiungi codice di esempio al tuo CodeCommit repository
<a name="codecommit-add-code"></a>

In questo passaggio, scarichi il codice per un'applicazione di esempio creata per una procedura dettagliata di CodeDeploy esempio e lo aggiungi al tuo repository. CodeCommit 



1. Quindi, scaricare un esempio e salvarlo in una cartella o directory sul computer locale.

   1. Scegliere una delle seguenti opzioni. Scegli `SampleApp_Linux.zip` se vuoi seguire i passaggi di questo tutorial per le istanze Linux.
      + [Se desideri eseguire la distribuzione su istanze Amazon Linux utilizzando CodeDeploy, scarica l'applicazione di esempio qui: SampleApp \$1Linux.zip.](samples/SampleApp_Linux.zip)
      + [Se desideri eseguire la distribuzione su istanze di Windows Server utilizzando CodeDeploy, scarica l'applicazione di esempio qui: \$1Windows.zip. SampleApp](samples/SampleApp_Windows.zip)

      L'applicazione di esempio contiene i seguenti file con cui eseguire la distribuzione: CodeDeploy 
      + `appspec.yml`— Il file delle specifiche dell'applicazione (AppSpecfile) è un file in formato [YAML](http://www.yaml.org) utilizzato da CodeDeploy per gestire una distribuzione. *Per ulteriori informazioni sul AppSpec file, vedere [CodeDeploy AppSpec File reference](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) nella Guida per l'utente.AWS CodeDeploy *
      + `index.html`— Il file indice contiene la home page dell'applicazione di esempio distribuita.
      + `LICENSE.txt`— Il file di licenza contiene informazioni sulla licenza per l'applicazione di esempio.
      + File per script: l'applicazione di esempio utilizza script per scrivere file di testo in una posizione sull'istanza. Un file viene scritto per ciascuno dei diversi eventi del ciclo di vita della CodeDeploy distribuzione nel modo seguente:
        + `scripts`Cartella (solo esempio Linux): la cartella contiene i seguenti script di shell per installare le dipendenze e avviare e arrestare l'applicazione di esempio per la distribuzione automatizzata:`install_dependencies`, e. `start_server` `stop_server`
        + (Solo esempio per Windows)`before-install.bat`: si tratta di uno script batch per l'evento del ciclo di vita della `BeforeInstall` distribuzione, che verrà eseguito per rimuovere i vecchi file scritti durante le distribuzioni precedenti di questo esempio e creare una posizione sull'istanza in cui scrivere i nuovi file.

   1. Scarica il file compresso.

1. Decomprimi i file da [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) nella directory locale creata in precedenza (ad esempio o). `/tmp/MyDemoRepo` `c:\temp\MyDemoRepo`

   Assicurati di inserire i file direttamente nel repository locale. Non includere una cartella `SampleApp_Linux`. Sul computer locale Linux, macOS o Unix, ad esempio, la gerarchia delle cartelle e dei file dovrebbe avere il seguente aspetto:

   ```
   /tmp
      └-- MyDemoRepo
          │-- appspec.yml
          │-- index.html
          │-- LICENSE.txt
          └-- scripts
              │-- install_dependencies
              │-- start_server
              └-- stop_server
   ```

1. Per caricare file nel tuo repository, usa uno dei seguenti metodi.

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

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

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

      1. Seleziona **Choose file (Scegli file)** e vai al file. Per aggiungere un file in una cartella, scegli **Crea file**, quindi inserisci il nome della cartella con il nome del file, ad esempio. `scripts/install_dependencies` Incolla il contenuto del file nel nuovo file.

         Conferma la modifica inserendo il tuo nome utente e indirizzo e-mail. 

         Scegliere **Commit changes (Applica modifiche)**.

      1. Ripetere questo passaggio per ogni file.

         Il contenuto del repository dovrebbe avere il seguente aspetto:

         ```
                │-- appspec.yml
                │-- index.html
                │-- LICENSE.txt
                └-- scripts
                    │-- install_dependencies
                    │-- start_server
                    └-- stop_server
         ```

   1. Per usare i comandi git per caricare i tuoi file: 

      1. Cambiare le directory nel repository locale:

         ```
         (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
         (For Windows) cd c:\temp\MyDemoRepo
         ```

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

         ```
         git add -A
         ```

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

         ```
         git commit -m "Add sample application files"
         ```

      1. Esegui il comando seguente per eseguire il push dei file dal repository locale al repository CodeCommit:

         ```
         git push
         ```

1. I file che hai scaricato e aggiunto al tuo repository locale sono stati ora aggiunti al `main` ramo del tuo CodeCommit `MyDemoRepo` repository e sono pronti per essere inclusi in una pipeline.

## Fase 3: creare un'istanza Amazon EC2 Linux e installare l'agente CodeDeploy
<a name="codecommit-create-deployment"></a>

In questo passaggio, crei l'istanza Amazon EC2 in cui distribuisci un'applicazione di esempio. Come parte di questo processo, crea un ruolo dell'istanza che consenta l'installazione e la gestione dell' CodeDeploy agente sull'istanza. L' CodeDeploy agente è un pacchetto software che consente di utilizzare un'istanza nelle CodeDeploy distribuzioni. È inoltre possibile allegare politiche che consentono all'istanza di recuperare i file utilizzati dall' CodeDeploy agente per distribuire l'applicazione e di consentire la gestione dell'istanza da parte di SSM.

**Per creare un ruolo dell'istanza**

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

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

1. Scegli **Crea ruolo**.

1. In **Seleziona il tipo di entità affidabile**, seleziona **Servizio AWS**. In **Scegli un caso d'uso**, seleziona **EC2**. In **Select your use case (Seleziona il tuo caso d'uso)** selezionare **EC2**. Scegli **Successivo: autorizzazioni**.

1. Cerca e seleziona la politica denominata **`AmazonEC2RoleforAWSCodeDeploy`**. 

1. Cerca e seleziona la politica denominata **`AmazonSSMManagedInstanceCore`**. Scegliere **Next: Tags (Successivo: Tag)**.

1. Scegliere **Next:Review (Successivo: Rivedi)**. Immettere un nome per il ruolo (ad esempio **EC2InstanceRole**).
**Nota**  
Prendere nota del nome del ruolo per la fase successiva. È possibile scegliere questo ruolo quando si crea l'istanza.

   Scegli **Crea ruolo**.

**Per avviare un'istanza**

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

1. Dalla barra di navigazione laterale, scegli **Istanze** e seleziona **Avvia istanze** nella parte superiore della pagina.

1. In **Nome**, inserisci **MyCodePipelineDemo**. **Questo assegna all'istanza un tag **Key** di **Name** e un tag Value di.** **MyCodePipelineDemo** Successivamente, si crea un' CodeDeploy applicazione che distribuisce l'applicazione di esempio su questa istanza. CodeDeployseleziona le istanze da distribuire in base ai tag.

1. In **Immagini dell'applicazione e del sistema operativo (Amazon Machine Image)**, individua l'opzione AMI **Amazon Linux** con il AWS logo e assicurati che sia selezionata. (Questa AMI è descritta come AMI Amazon Linux 2 (HVM) ed è etichettata come «Idoneo al piano gratuito».)

1. In **Tipo di istanza**, scegli il `t2.micro` tipo idoneo al piano gratuito come configurazione hardware per la tua istanza.

1. In **Coppia di chiavi (login)**, scegli una coppia di chiavi o creane una. 

   Puoi anche scegliere **Proceed without a key pair**.
**Nota**  
Ai fini di questo tutorial, è possibile procedere senza una coppia di chiavi. Per utilizzare SSH per connettersi alle istanze, creare o utilizzare una coppia di chiavi.

1. In **Impostazioni di rete**, procedi come segue.

   **In **Assegna automaticamente un IP pubblico**, assicurati che lo stato sia Abilita.**

   Per il gruppo di sicurezza creato, scegli **HTTP**, quindi in **Tipo di origine**, scegli **Il mio** IP.

1. Espandi **Advanced details** (Dettagli avanzati). Nel **profilo dell'istanza** IAM, scegli il ruolo IAM che hai creato nella procedura precedente (ad esempio,**EC2InstanceRole**).

1. In **Riepilogo**, in **Numero di istanze**, inserisci.. `1`

1. Scegliere **Launch Instance (Avvia istanza)**. 

1. È possibile visualizzare lo stato dell'avvio nella pagina **Instances (Istanze)**. Quando avvii un'istanza, il suo stato iniziale è `pending`. Una volta avviata l'istanza, il suo stato passa a `running` e riceve un nome DNS pubblico. Se la colonna **Public DNS (DNS pubblico)** non è visualizzata, scegliere l'icona **Show/Hide (Mostra/Nascondi)** quindi selezionare **Public DNS (DNS pubblico)**.

## Passaggio 4: Creare un'applicazione in CodeDeploy
<a name="codecommit-create-codedeploy-app"></a>

In CodeDeploy, un'[https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) è una risorsa che contiene l'applicazione software che si desidera distribuire. Successivamente, utilizzerai questa applicazione CodePipeline per automatizzare le distribuzioni dell'applicazione di esempio sulla tua istanza Amazon EC2.

Innanzitutto, crei un ruolo che CodeDeploy consenta di eseguire le distribuzioni. Quindi, crea un'applicazione CodeDeploy .

**Per creare un ruolo di servizio CodeDeploy**

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

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

1. Scegli **Crea ruolo**.

1. In **Seleziona un'entità affidabile**, scegli **Servizio AWS**. In **Use case** (Caso d'uso), scegli **CodeDeploy**. Scegli **CodeDeploy**tra le opzioni elencate. Scegli **Next (Successivo)**. La policy gestita `AWSCodeDeployRole` è già collegata al ruolo.

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

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

**Per creare un'applicazione in CodeDeploy**

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

1. **Se la pagina **Applicazioni** non viene visualizzata, nel menu, scegli Applicazioni.**

1. Scegli **Crea applicazione**.

1. In **Application name (Nome applicazione)**, immettere **MyDemoApplication**. 

1. In **Compute Platform (Piattaforma di calcolo)**, scegliere **EC2/On-premises (EC2/Locale)**.

1. Scegli **Crea applicazione**.

**Per creare un gruppo di distribuzione in CodeDeploy**

Un [https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) è una risorsa che definisce le impostazioni correlate alla distribuzione, come le istanze a cui distribuire e la velocità di distribuzione.

1. Nella pagina in cui è visualizzata l'applicazione, scegliere **Create deployment group (Crea gruppo di distribuzione)**.

1. In **Deployment group name (Nome del gruppo di distribuzione)**, immettere **MyDemoDeploymentGroup**.

1. In **Ruolo di servizio**, scegli l'ARN del ruolo di servizio creato in precedenza (ad esempio,**`arn:aws:iam::account_ID:role/CodeDeployRole`**).

1. In **Deployment type (Tipo di distribuzione)**, scegliere **In-place (In loco)**.

1. In **Environment configuration (Configurazione dell'ambiente)**, scegliere **Amazon EC2 Instances (Istanze Amazon EC2)**. Nel campo **Chiave**, immettere**Name**. Nel campo **Valore**, inserisci il nome che hai usato per etichettare l'istanza (ad esempio,**MyCodePipelineDemo**).

1. In **Configurazione dell'agente con AWS Systems Manager**, scegli **Ora e pianifica gli aggiornamenti**. Questo installa l'agente sull'istanza. L'istanza Linux è già configurata con l'agente SSM e verrà ora aggiornata con l' CodeDeploy agente.

1. In **Deployment configuration (Configurazione della distribuzione)**, scegliere `CodeDeployDefault.OneAtaTime`.

1. In **Load Balancer**, assicurati che l'**opzione Abilita bilanciamento del carico non sia selezionata**. Non è necessario configurare un sistema di bilanciamento del carico o scegliere un gruppo di destinazione per questo esempio.

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

## Fase 5: Crea la tua prima pipeline in CodePipeline
<a name="codecommit-create-pipeline"></a>

È ora possibile creare ed eseguire la prima pipeline. In questo passaggio, crei una pipeline che viene eseguita automaticamente quando il codice viene inviato al tuo repository. CodeCommit 

**Per creare una pipeline CodePipeline**

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

   Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyFirstPipeline**

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

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

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **CodeCommit**. In **Nome archivio**, scegli il nome del CodeCommit repository in cui hai creato. [Passaggio 1: crea un CodeCommit repository](#codecommit-create-repository) In **Branch name (Nome ramo)**, scegliere `main`, quindi selezionare **Next step (Fase successiva)**.

   Dopo aver selezionato il nome del repository e il ramo, un messaggio mostra la regola Amazon CloudWatch Events da creare per questa pipeline. 

   In **Change detection options (Opzioni di rilevamento delle modifiche)**, lasciare le impostazioni predefinite. Ciò consente di CodePipeline utilizzare Amazon CloudWatch Events per rilevare le modifiche nel tuo repository di origine.

   Scegli **Next (Successivo)**.

1. Nel **passaggio 4: aggiungi la fase di compilazione**, scegli **Ignora fase di compilazione**, quindi accetta il messaggio di avviso scegliendo nuovamente **Ignora**. Scegli **Next (Successivo)**.
**Nota**  
In questo tutorial, viene distribuito codice che non richiede alcun servizio di compilazione, in modo da poter ignorare questa fase. Tuttavia, se il codice sorgente deve essere compilato prima di essere distribuito alle istanze, puoi configurare [CodeBuild](https://aws.amazon.com/codebuild/) in questa fase.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di distribuzione, in **Deploy**** provider, scegli. **CodeDeploy** In **Application name (Nome applicazione)**, scegliere **MyDemoApplication**. In **Deployment group (Gruppo di distribuzione**), scegliere **MyDemoDeploymentGroup**, quindi **Next step (Fase successiva)**.

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

1. La pipeline viene avviata dopo la creazione. Scarica il codice dal tuo CodeCommit repository e crea una CodeDeploy distribuzione sulla tua istanza EC2. Puoi visualizzare lo stato di avanzamento e i messaggi di successo e di errore mentre l' CodePipeline esempio distribuisce la pagina Web sull'istanza Amazon EC2 nella distribuzione. CodeDeploy   
![\[Una visualizzazione di una pipeline che inizia a funzionare nella console. CodePipeline\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

Complimenti\$1 Hai appena creato una pipeline semplice in. CodePipeline 

Viene quindi eseguita la verifica dei risultati.

**Per verificare che la pipeline è stata eseguita correttamente**

1. Visualizzare l'avanzamento iniziale della pipeline. Lo stato di ciascuna fase cambia da **No executions yet (Ancora nessun esecuzione)** a **In Progress (In corso)** e quindi in **Succeeded (Riuscito)** o **Failed (Non riuscito)**. L'esecuzione della pipeline richiede qualche minuto.

1. Dopo aver visualizzato **Succeeded** per lo stato della pipeline, nell'area di stato della fase di **distribuzione, scegliete. **CodeDeploy**** Verrà aperta la console. CodeDeploy Se **Succeeded (Riuscito)** non viene visualizzato, consulta [Risoluzione dei problemi CodePipeline](troubleshooting.md).

1.  Nella scheda **Deployments (Distribuzioni)**, scegliere, l'ID della distribuzione. Nella pagina relativa alla distribuzione, in **Deployment lifecycle events (Eventi del ciclo di vita di distribuzione)**, scegliere l'ID dell'istanza. Si apre la console EC2.

1. Nella scheda **Description (Descrizione)**, in **Public DNS (DNS pubblico)**, copiare l'indirizzo (ad esempio, `ec2-192-0-2-1.us-west-2.compute.amazonaws.com`) e incollarlo nella barra degli indirizzi del browser Web.

   Viene visualizzata la pagina Web dell'applicazione di esempio che hai scaricato e inviato al tuo CodeCommit repository.

Per ulteriori informazioni sulle fasi, sulle operazioni e sul funzionamento delle pipeline, consulta [CodePipeline concetti ](concepts.md).

## Passaggio 6: Modifica il codice nel tuo repository CodeCommit
<a name="codecommit-push-code"></a>

La pipeline è configurata per essere eseguita ogni volta che modifiche di codice vengono apportate al repository CodeCommit. In questo passaggio, si apportano modifiche al file HTML che fa parte dell' CodeDeployapplicazione di esempio presente nel CodeCommit repository. Quando esegui il push di queste modifiche, la pipeline viene eseguita nuovamente e le modifiche apportate sono visibili all'indirizzo Web a cui hai effettuato l'accesso in precedenza.

1. Cambiare le directory nel repository locale:

   ```
   (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
   (For Windows) cd c:\temp\MyDemoRepo
   ```

1. Utilizzare un editor di testo per modificare il file `index.html`:

   ```
   (For Linux or Unix)gedit index.html
   (For OS X)open –e index.html
   (For Windows)notepad index.html
   ```

1. Rivedere il contenuto del file `index.html` per modificare il colore di sfondo e parte del testo sulla pagina Web, quindi salvare il file. 

   ```
   <!DOCTYPE html>
   <html>
   <head>
     <title>Updated Sample Deployment</title>
     <style>
       body {
         color: #000000;
         background-color: #CCFFCC;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
           
       h1 {
         font-size: 250%;
         font-weight: normal;
         margin-bottom: 0;
       }
       
       h2 {
         font-size: 175%;
         font-weight: normal;
         margin-bottom: 0;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Updated Sample Deployment</h1></div>
     <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div>
     <div align="center">
       <p>Learn more:</p> 
       <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p>
     </div>
   </body>
   </html>
   ```

1. Conferma e invia le modifiche al tuo CodeCommit repository eseguendo i seguenti comandi, uno alla volta:

   ```
   git commit -am "Updated sample application files"
   ```

   ```
   git push
   ```

**Per verificare che la pipeline è stata eseguita correttamente**

1. Visualizzare l'avanzamento iniziale della pipeline. Lo stato di ciascuna fase cambia da **No executions yet (Ancora nessun esecuzione)** a **In Progress (In corso)** e quindi in **Succeeded (Riuscito)** o **Failed (Non riuscito)**. L'esecuzione della pipeline dovrebbe essere completata entro pochi minuti.

1. Dopo aver visualizzato **Succeeded (Riuscito)** per lo stato dell'operazione, aggiorna la pagina dimostrativa che hai consultato in precedenza nel browser.

   Viene visualizzata la pagina Web aggiornata.

## Fase 7: eliminazione delle risorse
<a name="codecommit-clean-up"></a>

Puoi utilizzare alcune delle risorse create in questo tutorial per altri tutorial in questa guida. Ad esempio, è possibile riutilizzare l' CodeDeploy applicazione e la distribuzione. Tuttavia, dopo aver completato questo ed eventuali altri tutorial, devi eliminare la pipeline e le risorse utilizzate, per evitare che ti venga addebitato un costo per l'utilizzo continuo di tali risorse. Innanzitutto, elimina la pipeline, quindi l' CodeDeploy applicazione e l'istanza Amazon EC2 associata e infine il repository. CodeCommit

**Per eliminare le risorse utilizzate in questo tutorial**

1. Per ripulire CodePipeline le tue risorse, segui le istruzioni riportate in [Eliminare una pipeline](pipelines-delete.md) in. AWS CodePipeline

1. Per ripulire CodeDeploy le risorse, segui le istruzioni riportate in [Clean Up Deployment Walkthrough](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up) Resources.

1. Per eliminare il CodeCommit repository, segui le istruzioni in [Eliminare](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html) un repository. CodeCommit

## Fase 8: approfondimenti
<a name="codecommit-optional-tasks"></a>

Scopri di più su come funziona CodePipeline :
+ Per ulteriori informazioni sulle fasi, sulle operazioni e sul funzionamento delle pipeline, consulta [CodePipeline concetti ](concepts.md).
+ Per informazioni sulle azioni che è possibile eseguire utilizzando CodePipeline, vedere[Integrazioni con tipi di CodePipeline azioni](integrations-action-type.md).
+ Prova questo tutorial più avanzato, [Tutorial: creazione di una pipeline a quattro fasi](tutorials-four-stage-pipeline.md). Crea una pipeline a più fasi che include una fase che compila il codice prima che venga distribuito.

# Tutorial: creazione di una pipeline a quattro fasi
<a name="tutorials-four-stage-pipeline"></a>

Ora che hai creato la tua prima pipeline in [Tutorial: creazione di una semplice pipeline (bucket S3)](tutorials-simple-s3.md) o in [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md), puoi iniziare a creare pipeline più complesse. Questo tutorial ti guiderà attraverso la creazione di una pipeline in quattro fasi che utilizza un GitHub repository per il codice sorgente, un server di build Jenkins per creare il progetto e un' CodeDeploy applicazione per distribuire il codice creato su un server di staging. Il diagramma seguente mostra la pipeline iniziale in tre fasi.

![\[Un diagramma che mostra la fase di origine con l'azione di origine, una fase di creazione con l'azione Jenkins e una fase di distribuzione con l'azione di distribuzione.\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/flow-codepipeline-codecommit-jenkins.png)


Dopo aver creato la pipeline, dovrai modificarla aggiungendo una fase con un'operazione di test per provare il codice, sempre tramite Jenkins. 

Prima di poter creare la pipeline, devi configurare le risorse necessarie. Ad esempio, se si desidera utilizzare un GitHub repository per il codice sorgente, è necessario creare il repository prima di poterlo aggiungere a una pipeline. Nell'ambito della configurazione, il tutorial illustra i passaggi per configurare Jenkins su un'istanza EC2 a scopo dimostrativo. 

**Importante**  
Molte delle azioni che aggiungi alla pipeline in questa procedura coinvolgono AWS risorse che devi creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

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

Prima di iniziare il tutorial, devi aver già completato i prerequisiti generali indicati in [Iniziare con CodePipeline](getting-started-codepipeline.md).

**Topics**
+ [

## Fase 1: completamento dei prerequisiti
](#tutorials-four-stage-pipeline-prerequisites)
+ [

## Passaggio 2: crea una pipeline in CodePipeline
](#tutorials-four-stage-pipeline-pipeline-create)
+ [

## Fase 3: aggiunta di un'altra fase alla pipeline
](#tutorials-four-stage-pipeline-add-stage)
+ [

## Fase 4: Eliminazione delle risorse
](#tutorials-four-stage-pipeline-clean-up)

## Fase 1: completamento dei prerequisiti
<a name="tutorials-four-stage-pipeline-prerequisites"></a>

Per l'integrazione con Jenkins, è AWS CodePipeline necessario installare il CodePipeline Plugin for Jenkins su qualsiasi istanza di Jenkins che si desidera utilizzare. CodePipeline Dovresti anche configurare un utente o un ruolo IAM dedicato da utilizzare per le autorizzazioni tra il tuo progetto Jenkins e. CodePipeline Il modo più semplice per integrare Jenkins CodePipeline consiste nell'installare Jenkins su un'istanza EC2 che utilizza un ruolo di istanza IAM creato per l'integrazione con Jenkins. Per un'efficace connessione dei collegamenti della pipeline per le operazioni Jenkins, occorre configurare le impostazioni del proxy e del firewall sul server; oppure dovrai configurare l'istanza EC2 in modo che autorizzi le connessioni in entrata alla porta utilizzata dal progetto Jenkins. Verifica che la configurazione di Jenkins consenta di autenticare gli utenti e di applicare il controllo degli accessi prima di autorizzare le connessioni su queste porte (ad esempio, 443 e 8443 se hai protetto Jenkins in modo che utilizzi solo connessioni HTTPS o 80 e 8080 se autorizzi le connessioni HTTP). Per ulteriori informazioni, consulta l'articolo [Garantire la sicurezza di Jenkins](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins).

**Nota**  
Questo tutorial utilizza un codice di esempio e configura le fasi di compilazione che convertono il codice dal formato Haml al formato HTML. Puoi scaricare il codice di esempio open source dal GitHub repository seguendo la procedura riportata di seguito. [Copiate o clonate il campione in un repository GitHub](#tutorials-four-stage-pipeline-prerequisites-github) Avrai bisogno dell'intero campione nel tuo GitHub repository, non solo del file.zip.   
Il tutorial presuppone anche che:  
Tu abbia familiarità con l'installazione e l'amministrazione di Jenkins e con la creazione di progetti Jenkins.
Tu abbia installato Rake e il gem Haml per Ruby sullo stesso computer o sulla stessa istanza che ospita il progetto Jenkins.
Tu abbia impostato le variabili di ambiente di sistema necessarie affinché i comandi Rake possano essere eseguiti dal terminale o dalla riga di comando (ad esempio, sui sistemi Windows, modificando la variabile PATH in modo da includere la directory dove è installato Rake).

**Topics**
+ [

### Copiate o clonate il campione in un repository GitHub
](#tutorials-four-stage-pipeline-prerequisites-github)
+ [

### Crea un ruolo IAM da utilizzare per l'integrazione con Jenkins
](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [

### Installa e configura Jenkins e il plugin per Jenkins CodePipeline
](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)

### Copiate o clonate il campione in un repository GitHub
<a name="tutorials-four-stage-pipeline-prerequisites-github"></a>

**Per clonare il campione e inviarlo a un repository GitHub**

1. Scarica il codice di esempio dal GitHub repository o clona i repository sul tuo computer locale. Il codice di esempio è disponibile in due pacchetti: 
   + [Se intendi distribuire il tuo campione su istanze di Amazon Linux, RHEL o Ubuntu Server, scegli \$1linux.zip. codepipeline-jenkins-aws-codedeploy](https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux) 
   + [Se intendi distribuire il campione su istanze di Windows Server, scegli -Jenkins- .zip. CodePipeline AWSCodeDeploy\$1Windows](https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows)

1. Dal repository, scegliere **Fork** per copiare il repository di esempio in un repository dell'account Github. Per ulteriori informazioni, consulta la [documentazione relativa ad GitHub](https://help.github.com/articles/create-a-repo/).

### Crea un ruolo IAM da utilizzare per l'integrazione con Jenkins
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role"></a>

Come best practice, prendi in considerazione l'avvio di un'istanza EC2 per ospitare il tuo server Jenkins e l'utilizzo di un ruolo IAM per concedere all'istanza le autorizzazioni necessarie per interagire con. CodePipeline

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

1. Nel riquadro di navigazione della console IAM, scegli **Ruoli**, quindi **Crea ruolo**.

1. In **Select type of trusted entity (Seleziona tipo di entità attendibile)**, scegli **Servizio AWS**. In **Choose the service that will use this role (Scegli il servizio che utilizzerà questo ruolo)** scegliere **EC2**. In **Select your use case (Seleziona il tuo caso d'uso)** selezionare **EC2**. 

1. Scegli **Successivo: autorizzazioni**. Nella pagina **Collega policy di autorizzazione**, seleziona la policy gestita `AWSCodePipelineCustomActionAccess`, quindi scegli **Next: Tags**. Scegli **Prossimo: Rivedi**.

1. Nella pagina **Review (Revisione)** in **Role name (Nome ruolo)**, digitare il nome del ruolo da creare in modo specifico per l'integrazione di Jenkins (ad esempio *JenkinsAccess*), quindi scegliere **Create role (Crea ruolo)**.

Quando crei l'istanza EC2 dove verrà installato Jenkins, in **Step 3: Configure Instance Details (Fase 3: configurazione dei dettagli dell'istanza)**, assicurati di scegliere il ruolo dell'istanza (ad esempio *JenkinsAccess*).

Per ulteriori informazioni sui ruoli delle istanze e Amazon EC2, consulta [Ruoli IAM per Amazon EC2, Utilizzo dei ruoli](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) [IAM per concedere autorizzazioni alle applicazioni in esecuzione su istanze Amazon EC2 [e Creazione](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html) di un ruolo per delegare](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html) le autorizzazioni a un. Servizio AWS

### Installa e configura Jenkins e il plugin per Jenkins CodePipeline
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-configure"></a>

**Per installare Jenkins e il plugin per Jenkins CodePipeline**

1. Creare un'istanza EC2 dove verrà installato Jenkins e in **Step 3: Configure Instance Details (Fase 3: configurazione dei dettagli dell'istanza)**, assicurarsi di scegliere il ruolo creato per l'istanza (ad esempio *JenkinsAccess*). Per ulteriori informazioni sulla creazione di istanze EC2, consulta [Launch an Amazon EC2 istanza nella Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html) User *Guide*. 
**Nota**  
Se disponi già di risorse Jenkins che desideri utilizzare, puoi farlo, ma devi creare un utente IAM speciale, applicare la policy `AWSCodePipelineCustomActionAccess` gestita a quell'utente e quindi configurare e utilizzare le credenziali di accesso per quell'utente sulla tua risorsa Jenkins. Se vuoi utilizzare l'interfaccia utente Jenkins per fornire le credenziali, configura Jenkins in modo che autorizzi solo il protocollo HTTPS. Per ulteriori informazioni, consulta [Risoluzione dei problemi CodePipeline](troubleshooting.md).

1. Installare Jenkins sull'istanza EC2. Per ulteriori informazioni, consulta la documentazione di Jenkins relativa all'[installazione di Jenkins](https://www.jenkins.io/doc/book/installing/linux/) e all'[avvio e all'accesso a Jenkins](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html), oltre a [details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2) in [Integrazioni di prodotti e servizi con CodePipeline](integrations.md).

1. Avviare Jenkins e sulla home page scegliere **Manage Jenkins (Gestisci Jenkins)**.

1. Nella pagina **Manage Jenkins (Gestisci Jenkins)**, scegliere **Manage Plugins (Gestisci plugin)**.

1. Scegliere la scheda **Available (Disponibile)** e nella casella di ricerca **Filter (Filtra)**, immettere **AWS CodePipeline**. Scegli **CodePipeline Plugin for Jenkins** dall'elenco e scegli **Scarica ora e** installa dopo il riavvio.

1. Nella pagina **Installing Plugins/Upgrades (Installazione plugin/Aggiornamenti)**, selezionare **Restart Jenkins when installation is complete and no jobs are running (Riavvia Jenkins al termine dell'installazione e quando non ci sono processi in esecuzione)**.

1. Scegliere **Back to Dashboard (Torna al pannello di controllo)**.

1. Nella pagina principale, scegliere **New Item (Nuova voce)**.

1. In **Item Name**, inserisci un nome per il progetto Jenkins (ad esempio,*MyDemoProject*). Scegliere **Freestyle project (Progetto freestyle)**, quindi **OK**.
**Nota**  
Assicurati che il nome del progetto soddisfi i requisiti di CodePipeline. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md).

1. Nella pagina di configurazione del progetto, selezionare la casella di controllo **Execute concurrent builds if necessary (Esegui compilazioni simultanee in caso di necessità)**. In **Source Code Management (Gestione codice sorgente)**, scegli **AWS CodePipeline**. Se hai installato Jenkins su un'istanza EC2 e l'hai configurata AWS CLI con il profilo per l'utente IAM che hai creato per l'integrazione tra CodePipeline e Jenkins, lascia tutti gli altri campi vuoti.

1. Scegli **Avanzato** e, in **Provider**, inserisci un nome per il fornitore dell'azione così come verrà visualizzata CodePipeline (ad esempio,). *MyJenkinsProviderName* Verifica che il nome sia univoco e facile da ricordare. Verrà utilizzato più avanti nel tutorial quando si aggiunge un'operazione di compilazione e ancora quando si aggiunge un'operazione di test.
**Nota**  
Il nome dell'operazione deve soddisfare i requisiti di denominazione delle operazioni in CodePipeline. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md).

1. In **Build Triggers (Crea trigger)**, deselezionare tutte le caselle di controllo, quindi selezionare **Poll SCM (Polling SCM)**. In **Schedule (Pianificazione)**, immettere cinque asterischi separati da spazi, nel seguente modo:

   ```
   * * * * *
   ```

   Questo sondaggio viene effettuato CodePipeline ogni minuto. 

1. In **Build (Compila)**, scegliere **Add build step (Aggiungi fase di compilazione)**. Scegli **Esegui shell** (Amazon Linux, RHEL o Ubuntu Server) **Esegui comando batch** (Windows Server), quindi inserisci quanto segue:

   ```
   rake
   ```
**Nota**  
Verifica che il tuo ambiente sia configurato con le variabili e le impostazioni richieste per eseguire rake; in caso contrario, la compilazione non andrà a buon fine.

1. **Scegli **Aggiungi azione post-compilazione**, quindi scegli AWS CodePipeline Publisher.** Scegliere **Add (Aggiungi)** e in **Build Output Locations (Posizioni di output della compilazione)**, lasciare vuota la posizione. Questa è la configurazione predefinita. Al termine del processo di compilazione verrà creato un file compresso.

1. Scegliere **Save (Salva)** per salvare il progetto Jenkins.

## Passaggio 2: crea una pipeline in CodePipeline
<a name="tutorials-four-stage-pipeline-pipeline-create"></a>

In questa parte del tutorial viene creata una pipeline utilizzando la proceduta guidata **Create Pipeline (Crea pipeline)**. 

**Per creare un CodePipeline processo di rilascio automatico**

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

1. Se necessario, utilizzare il selettore delle regioni per modificare la regione in quella in cui si trovano le risorse della pipeline. Ad esempio, se hai creato risorse per il tutorial precedente in`us-east-2`, assicurati che il selettore della regione sia impostato su Stati Uniti orientali (Ohio).

   Per ulteriori informazioni sulle regioni e gli endpoint disponibili CodePipeline, consulta [AWS CodePipeline endpoint](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html) e quote.

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

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

1. Nella pagina **Passaggio 2: Scegli le impostazioni della pipeline**, in Nome **pipeline, inserisci il nome** della pipeline.

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

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

1. Lascia i valori predefiniti delle impostazioni nella pagina **Advanced settings (Impostazioni avanzate)** e scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, in **Provider di origine**, scegli **GitHub**.

1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

1. Nel **passaggio 4: Aggiungi la fase di compilazione**, scegli **Aggiungi Jenkins**. Nel **nome del provider**, inserisci il nome dell'azione che hai fornito nel CodePipeline Plugin per Jenkins (ad esempio*MyJenkinsProviderName*). Questo nome deve corrispondere esattamente al nome nel CodePipeline Plugin for Jenkins. In **Server URL (URL del server)**, immettere l'URL dell'istanza EC2 in cui è installato Jenkins. **In **Nome progetto**, inserisci il nome del progetto che hai creato in Jenkins, ad esempio*MyDemoProject*, e quindi scegli Avanti.**

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di distribuzione**, riutilizza l' CodeDeploy applicazione e il gruppo di distribuzione in cui hai creato. [Tutorial: creazione di una semplice pipeline (bucket S3)](tutorials-simple-s3.md) In **Deploy provider (Provider di distribuzione)**, scegliere **CodeDeploy**. In **Application name (Nome applicazione)**, immettere **CodePipelineDemoApplication** oppure scegliere il pulsante di aggiornamento e quindi selezionare il nome dell'applicazione dall'elenco. In **Deployment group (Gruppo di distribuzione)**, immettere **CodePipelineDemoFleet** o selezionarlo dall'elenco, quindi scegliere **Next (Successivo)**.
**Nota**  
Puoi utilizzare CodeDeploy le tue risorse o crearne di nuove, ma potresti incorrere in costi aggiuntivi.

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

1. La pipeline viene avviata automaticamente ed esegue il codice di esempio. Puoi visualizzare i messaggi di avanzamento e di successo e di fallimento mentre la pipeline crea l'esempio Haml in HTML e lo distribuisce su una pagina Web su ciascuna istanza Amazon EC2 nella distribuzione. CodeDeploy

## Fase 3: aggiunta di un'altra fase alla pipeline
<a name="tutorials-four-stage-pipeline-add-stage"></a>

Ora aggiungerai una fase di test e un'operazione di test alla fase che utilizza il test Jenkins incluso nel codice di esempio per stabilire se la pagina Web è dotata di contenuti. Il test è solo a scopo dimostrativo.

**Nota**  
Se non volevi aggiungere un'altra fase alla pipeline, avresti potuto aggiungere un'operazione di test alla fase temporanea della pipeline, prima o dopo l'operazione di distribuzione.

### Aggiunta di una fase di test alla pipeline
<a name="tutorials-four-stage-pipeline-add-stage-console"></a>

**Topics**
+ [

#### Ricerca dell'indirizzo IP di un'istanza
](#tutorials-four-stage-pipeline-instance-ip-lookup)
+ [

#### Creazione di un progetto Jenkins per testare la distribuzione
](#tutorials-four-stage-pipeline-create-jenkins-project)
+ [

#### Creazione di una quarta fase
](#tutorials-four-stage-pipeline-create-fourth-stage)

#### Ricerca dell'indirizzo IP di un'istanza
<a name="tutorials-four-stage-pipeline-instance-ip-lookup"></a>

**Per verificare l'indirizzo IP di un'istanza in cui hai distribuito il codice**

1. Quando lo stato della pipeline indica **Succeeded (Riuscito)**, nell'area dello stato della fase Staging (Gestione temporanea) scegliere **Details (Dettagli)**. 

1. Nella sezione **Deployment Details (Dettagli distribuzione)**, in **Instance ID (ID istanza)**, scegliere l'ID di una delle istanze correttamente distribuite. 

1. Copia l'indirizzo IP dell'istanza (ad esempio,). *192.168.0.4* Questo indirizzo IP verrà utilizzato nel test Jenkins.

#### Creazione di un progetto Jenkins per testare la distribuzione
<a name="tutorials-four-stage-pipeline-create-jenkins-project"></a>

**Per creare il progetto Jenkins**

1. Nell'istanza in cui è installato Jenkins, aprire Jenkins e dalla pagina principale scegliere **New Item (Nuova voce)**.

1.  In **Item Name**, inserisci un nome per il progetto Jenkins (ad esempio,*MyTestProject*). Scegliere **Freestyle project (Progetto freestyle)**, quindi **OK**.
**Nota**  
Assicurati che il nome del progetto soddisfi i CodePipeline requisiti. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md).

1. Nella pagina di configurazione del progetto, selezionare la casella di controllo **Execute concurrent builds if necessary (Esegui compilazioni simultanee in caso di necessità)**. In **Source Code Management (Gestione codice sorgente)**, scegli **AWS CodePipeline**. Se hai installato Jenkins su un'istanza EC2 e l'hai configurata AWS CLI con il profilo per l'utente IAM che hai creato per l'integrazione tra CodePipeline e Jenkins, lascia tutti gli altri campi vuoti. 
**Importante**  
Se stai configurando un progetto Jenkins che non è installato su un'istanza Amazon EC2 o è installato su un'istanza EC2 che esegue un sistema operativo Windows, completa i campi come richiesto dalle impostazioni dell'host e della porta del proxy e fornisci le credenziali dell'utente o del ruolo IAM che hai configurato per l'integrazione tra Jenkins e. CodePipeline

1. Scegliere **Advanced (Avanzate)** e in **Category (Categoria)**, scegliere **Test**. 

1. In **Provider**, inserisci lo stesso nome che hai usato per il progetto di compilazione (ad esempio,). *MyJenkinsProviderName* Questo nome verrà utilizzato più avanti nel tutorial per aggiungere l'operazione di test alla pipeline.
**Nota**  
Questo nome deve soddisfare i requisiti di CodePipeline denominazione per le azioni. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md).

1. In **Build Triggers (Crea trigger)**, deselezionare tutte le caselle di controllo, quindi selezionare **Poll SCM (Polling SCM)**. In **Schedule (Pianificazione)**, immettere cinque asterischi separati da spazi, nel seguente modo:

   ```
   * * * * *
   ```

   Questo sondaggio viene fatto CodePipeline ogni minuto. 

1. In **Build (Compila)**, scegliere **Add build step (Aggiungi fase di compilazione)**. **Se esegui la distribuzione su istanze Amazon Linux, RHEL o Ubuntu Server, scegli Execute shell.** Immetti quindi quanto segue, dove l'indirizzo IP è l'indirizzo dell'istanza EC2 copiata in precedenza:

   ```
   TEST_IP_ADDRESS=192.168.0.4 rake test
   ```

   Se esegui la distribuzione su istanze di Windows Server, scegli il **comando Esegui batch**, quindi inserisci quanto segue, dove l'indirizzo IP è l'indirizzo dell'istanza EC2 che hai copiato in precedenza:

   ```
   set TEST_IP_ADDRESS=192.168.0.4 rake test
   ```
**Nota**  
Il test presuppone la porta predefinita 80. Se vuoi specificare una porta diversa, aggiungi un'istruzione di test della porta, come segue:   

   ```
   TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test
   ```

1. **Scegli **Aggiungi azione post-compilazione**, quindi scegli Publisher.AWS CodePipeline ** Non scegliere **Add (Aggiungi)**.

1. Scegliere **Save (Salva)** per salvare il progetto Jenkins.

#### Creazione di una quarta fase
<a name="tutorials-four-stage-pipeline-create-fourth-stage"></a>

**Per aggiungere una fase alla pipeline che include l'operazione di test Jenkins**

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

1. In **Name (Nome)**, scegliere il nome della pipeline creata, MySecondPipeline. 

1. Nella pagina dei dettagli della pipeline, scegliere **Edit (Modifica)**. 

1. Nella pagina **Edit (Modifica)** scegliere **\$1 Stage (\$1 Fase)** per aggiungere una fase immediatamente dopo quella di compilazione. 

1. Nel campo del nome della nuova fase, immetti un nome (ad esempio **Testing**), quindi scegli **\$1 Add Action (\$1 Aggiungi operazione)**. 

1. In **Nome azione**, immettere*MyJenkinsTest-Action*. In **Test provider**, scegliete il nome del provider specificato in Jenkins (ad esempio,*MyJenkinsProviderName*). In **Nome progetto**, inserisci il nome del progetto che hai creato in Jenkins (ad esempio,*MyTestProject*). **In **Input artifacts**, scegli l'artefatto dalla build Jenkins il cui nome predefinito è*BuildArtifact*, quindi scegli Fine.**
**Nota**  
Poiché l'operazione di test Jenkins funziona sull'applicazione creata nella fase di compilazione di Jenkins, utilizza l'artefatto di compilazione per l'artefatto di input all'operazione di test.

   Per ulteriori informazioni sugli artefatti di input e di output e sulla struttura delle pipeline, consulta [CodePipeline riferimento alla struttura della tubazione](reference-pipeline-structure.md).

1. Nella pagina **Edit (Modifica)**, scegliere **Save pipeline changes (Salva le modifiche alla pipeline)** Nella casella di dialogo **Save pipeline changes (Salva modifiche della pipeline)**, scegliere **Save and continue (Salva e continua)**.

1. Anche se la nuova fase è stata aggiunta alla pipeline, viene visualizzato lo stato **No executions yet (Ancora nessun esecuzione)** per la nuova fase, perché le modifiche non hanno attivato un'altra esecuzione della pipeline. **Per eseguire l'esempio nella pipeline rivista, nella pagina dei dettagli della pipeline, scegliete Release change.** 

   La visualizzazione della pipeline mostra le fasi e le operazioni nella pipeline e lo stato della revisione attraverso le quattro fasi. Il tempo necessario per l'esecuzione di tutte le fasi della pipeline dipende dalle dimensioni degli artefatti, dalla complessità delle operazioni di compilazione e test e da altri fattori. 

## Fase 4: Eliminazione delle risorse
<a name="tutorials-four-stage-pipeline-clean-up"></a>

Dopo aver completato questo tutorial, devi eliminare la pipeline e le risorse utilizzate per evitare che ti venga addebitato un costo per l'utilizzo continuo di tali risorse. Se non intendi continuare a utilizzare CodePipeline, elimina la pipeline, quindi l' CodeDeploy applicazione e le istanze Amazon EC2 associate e infine il bucket Amazon S3 utilizzato per archiviare gli artefatti. Dovresti anche valutare se eliminare altre risorse, come il GitHub repository, se non intendi continuare a utilizzarle.

**Per eliminare le risorse utilizzate in questo tutorial**

1. Apri una sessione terminale sul tuo computer Linux, macOS o Unix locale o un prompt dei comandi sul tuo computer Windows locale ed esegui il **delete-pipeline** comando per eliminare la pipeline che hai creato. Per **MySecondPipeline**, immettere il comando seguente: 

   ```
   aws codepipeline delete-pipeline --name "MySecondPipeline"
   ```

   Questo comando non restituisce alcun risultato.

1. [Per ripulire CodeDeploy le risorse, segui le istruzioni riportate in Pulizia.](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up)

1. Per eliminare le risorse dell'istanza, eliminare l'istanza EC2 in cui è installato Jenkins. Per ulteriori informazioni, consulta [Pulizia di un'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html).

1. Se non intendi creare altre pipeline o CodePipeline riutilizzarle, elimina il bucket Amazon S3 usato per archiviare gli elementi per la tua pipeline. Per eliminare il bucket, segui le istruzioni relative all'[eliminazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html).

1. Se non si desidera riutilizzare le altre risorse per questa pipeline, è consigliabile eliminarle seguendo le istruzioni per quella particolare risorsa. [Ad esempio, se desideri eliminare il repository, segui le istruzioni in Eliminazione di un GitHub repository sul sito Web.](https://help.github.com/articles/deleting-a-repository/) GitHub 

# Tutorial: imposta una regola CloudWatch Events per ricevere notifiche e-mail per le modifiche allo stato della pipeline
<a name="tutorials-cloudwatch-sns-notifications"></a>

Dopo aver configurato una pipeline in AWS CodePipeline, puoi impostare una regola CloudWatch Events per inviare notifiche ogni volta che ci sono modifiche allo stato di esecuzione delle tue pipeline o nelle fasi o nelle azioni nelle tue pipeline. Per ulteriori informazioni sull'utilizzo CloudWatch degli eventi per impostare le notifiche per le modifiche dello stato della pipeline, consulta. [Monitoraggio CodePipeline degli eventi](detect-state-changes-cloudwatch-events.md)

In questo tutorial, puoi impostare una notifica per l'invio di un'e-mail quando lo stato di una pipeline diventa FAILED (NON RIUSCITO). Questo tutorial utilizza un metodo di trasformazione di input durante la creazione della regola CloudWatch Events. Trasforma i dettagli dello schema del messaggio per consegnare il messaggio in testo leggibile.

**Nota**  
Mentre crei le risorse per questo tutorial, come la notifica Amazon SNS e la regola CloudWatch Events, assicurati che le risorse vengano create nella stessa AWS regione della pipeline.

**Topics**
+ [

## Fase 1: configurare una notifica e-mail utilizzando Amazon SNS
](#create-filter-for-target)
+ [

## Fase 2: creazione di una regola e aggiunta dell'argomento SNS come destinazione
](#create-notification-rule)
+ [

## Fase 3: Eliminazione delle risorse
](#notifications-clean-up-resources)

## Fase 1: configurare una notifica e-mail utilizzando Amazon SNS
<a name="create-filter-for-target"></a>

Amazon SNS coordina l'uso degli argomenti per recapitare messaggi agli endpoint o ai clienti abbonati. Usa Amazon SNS per creare un argomento di notifica e poi iscriviti all'argomento utilizzando il tuo indirizzo e-mail. L'argomento Amazon SNS verrà aggiunto come obiettivo alla tua regola CloudWatch Events. Per ulteriori informazioni, consulta la [Guida per gli sviluppatori di Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).

Crea o identifica un argomento in Amazon SNS. CodePipeline utilizzerà CloudWatch Events per inviare notifiche su questo argomento tramite Amazon SNS. Per creare un argomento:

1. [Apri la console Amazon SNS in /sns. https://console.aws.amazon.com](https://console.aws.amazon.com/sns)

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

1. Nella finestra di dialogo **Create new topic (Crea nuovo argomento)** per **Topic name (Nome argomento)**, digitare un nome per l'argomento, ad esempio **PipelineNotificationTopic**.   
![\[Crea l'argomento di notifica utilizzando Amazon SNS.\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/tutorial-SNS-topic.png)

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

   Per ulteriori informazioni, consulta [Create a Topic](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) nella *Amazon SNS Developer Guide*.

Abbonare uno o più destinatari all'argomento per ricevere notifiche e-mail. Per sottoscrivere un destinatario a un argomento:

1. Nella console Amazon SNS, dall'elenco **Argomenti**, seleziona la casella di controllo accanto al nuovo argomento. Scegliere **Actions, Subscribe to topic (Operazioni, Effettua sottoscrizione all'argomento)**.

1. Nella finestra di dialogo **Create subscription (Crea sottoscrizione)**, verificare che un ARN sia presente in **Topic ARN (ARN dell'argomento)**.

1. Per **Protocollo**, scegli **E-mail**.

1. Per **Endpoint (Endpoint)**, digitare l'indirizzo e-mail completo del destinatario.

1. Selezionare **Crea sottoscrizione**.

1. Amazon SNS invia un'e-mail di conferma dell'abbonamento al destinatario. Il destinatario deve scegliere il collegamento **Confirm subscription (Conferma sottoscrizione)** nell'email di conferma per iniziare a ricevere le notifiche. Dopo che il destinatario ha fatto clic sul link, se l'iscrizione è avvenuta correttamente, Amazon SNS visualizza un messaggio di conferma nel browser Web del destinatario.

   Per ulteriori informazioni, consulta [Abbonarsi a un argomento](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html) nella *Amazon SNS Developer Guide*.

## Fase 2: creazione di una regola e aggiunta dell'argomento SNS come destinazione
<a name="create-notification-rule"></a>

Crea una regola di notifica CloudWatch degli eventi con CodePipeline come origine dell'evento.

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel pannello di navigazione seleziona **Events** (Eventi).

1. Scegli **Crea regola**. In **Event source (Origine eventi)**, scegli **AWS CodePipeline**. Per **Event Type (Tipo di evento)**, scegliere **Pipeline Execution State Change (Modifica dello stato di esecuzione della pipeline)**.

1. Selezionare **Specific state(s) (Stati specifici)**, quindi scegliere **FAILED**.

1. Scegliere **Edit (Modifica)** per aprire l'editor JSON per il riquadro **Event Pattern Preview (Anteprima modello di eventi)**. Aggiungere il parametro **pipeline** con il nome della pipeline come nell'esempio seguente per la pipeline denominata "myPipeline."

   Puoi copiare il modello di evento qui e incollarlo nella console:

   ```
   {
     "source": [
       "aws.codepipeline"
     ],
     "detail-type": [
       "CodePipeline Pipeline Execution State Change"
     ],
     "detail": {
       "state": [
         "FAILED"
       ],
       "pipeline": [
         "myPipeline"
       ]
     }
   }
   ```

1. In **Targets** (Destinazioni), seleziona **Add target** (Aggiungi destinazione). 

1. Nell'elenco degli obiettivi, selezionare **SNS topic (Argomento SNS)**; Per **Topic (Argomento)**, immettere l'argomento creato.

1. Espandere **Configure input (Configura input)**, quindi selezionare **Input Transformer (Trasformatore di input)**. 

1. Nella casella **Input Path (Percorso input)** digitare le seguenti coppie chiave-valore.

   ```
   { "pipeline" : "$.detail.pipeline" }
   ```

   Nella casella **Input Template (Modello di input)** digitare quanto segue: 

   ```
   "The Pipeline <pipeline> has failed."
   ```

1. Scegli **Configura dettagli**.

1. Nella pagina **Configure rule details (Configura i dettagli della regola)**, digitare un nome e una descrizione facoltativa. Lasciare la casella **Enabled (Abilitato)** selezionata per **State (Stato)**.

1. Scegli **Crea regola**. 

1. Conferma che ora CodePipeline sta inviando le notifiche di build. Ad esempio, verificare se le e-mail di notifica di compilazione si trovano nella casella di posta.

1. Per modificare il comportamento di una regola, nella CloudWatch console, scegli la regola, quindi scegli **Azioni**, **Modifica**. Modificare la regola, scegliere **Configure details (Configura dettagli)** e quindi selezionare **Update rule (Aggiorna regola)**.

   Per smettere di usare una regola per inviare notifiche di build, nella CloudWatch console, scegli la regola, quindi scegli **Azioni**, **Disabilita**.

   Per eliminare una regola, nella CloudWatch console, scegli la regola, quindi scegli **Azioni**, **Elimina**.

## Fase 3: Eliminazione delle risorse
<a name="notifications-clean-up-resources"></a>

Dopo aver completato questo tutorial, devi eliminare la pipeline e le risorse utilizzate per evitare che ti venga addebitato un costo per l'utilizzo continuo di tali risorse. 

Per informazioni su come ripulire la notifica SNS ed eliminare la regola Amazon CloudWatch Events, consulta [Clean Up (Unsubscribe from an Amazon SNS Topic) e consulta il riferimento `DeleteRule` nell'Amazon](https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html) Events API [Reference CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/).

# Tutorial: crea una pipeline con cui creare e testare la tua app Android AWS Device Farm
<a name="tutorials-codebuild-devicefarm"></a>

Puoi utilizzarla AWS CodePipeline per configurare un flusso di integrazione continuo in cui la tua app viene creata e testata ogni volta che viene inviato un commit. Questo tutorial mostra come creare e configurare una pipeline per creare e testare la tua app Android con codice sorgente in un GitHub repository. La pipeline rileva l'arrivo di un nuovo GitHub commit e quindi la utilizza [CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)per creare l'app e [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) per testarlo.

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

**Importante**  
Molte delle azioni che aggiungi alla pipeline in questa procedura coinvolgono AWS risorse che devi creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

Puoi provarlo utilizzando l'app Android esistente e le definizioni di test oppure puoi utilizzare l'[app di esempio e le definizioni di test fornite da Device Farm](https://github.com/aws-samples/aws-device-farm-sample-app-for-android).

**Prima di iniziare**

1. Accedi alla AWS Device Farm console e scegli **Crea un nuovo progetto**.

1. Scegliere il progetto. Nel browser, copiare l'URL del nuovo progetto. L'URL contiene l'ID del progetto. 

1. Copiare e conservare questo ID del progetto. Viene utilizzato quando si crea la pipeline in CodePipeline.

   Ecco un URL di esempio per un progetto. Per estrarre l'ID del progetto, copiare il valore dopo `projects/`. In questo esempio l'ID del prodotto è `eec4905f-98f8-40aa-9afc-4c1cfexample`.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Configura CodePipeline per utilizzare i test Device Farm
<a name="codepipeline-configure-tests"></a>

1. 

   Aggiungi e esegui il commit di un file chiamato [https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)nella radice del codice dell'app e invialo al tuo repository. CodeBuild utilizza questo file per eseguire comandi e accedere agli artefatti necessari per creare l'app.

   ```
   version: 0.2
   
   phases:
     build:
       commands:
         - chmod +x ./gradlew
         - ./gradlew assembleDebug
   artifacts:
     files:
        - './android/app/build/outputs/**/*.apk'
     discard-paths: yes
   ```

1. (Facoltativo) Se [utilizzi Calabash o Appium per testare la tua applicazione](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html), aggiungi il file di definizione del test al repository. In una fase successiva, puoi configurare Device Farm per utilizzare le definizioni per eseguire la tua suite di test. 

   Se utilizzi i test integrati di Device Farm, puoi saltare questo passaggio.

1. Per creare la pipeline e aggiungere una fase di origine, procedi nel seguente modo:

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

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

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

   1. Nella pagina **Passaggio 2: Scegli le impostazioni della pipeline**, in Nome **pipeline, inserisci il nome** della pipeline.

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

   1. Alla voce **Service role (Ruolo del servizio)**, lasciare selezionato **New service role (Nuovo ruolo del servizio)** e lasciare immutata la voce **Role name (Nome ruolo)**. È anche possibile scegliere di utilizzare un ruolo di servizio esistente, se disponibile.
**Nota**  
Se utilizzi un ruolo CodePipeline di servizio creato prima di luglio 2018, devi aggiungere le autorizzazioni per Device Farm. A tale scopo, apri la console IAM, trova il ruolo, quindi aggiungi le seguenti autorizzazioni alla policy del ruolo. Per ulteriori informazioni, consulta [Aggiungi le autorizzazioni al ruolo di servizio CodePipeline](how-to-custom-role.md#how-to-update-role-new-services).  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

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

   1. Nella pagina **Step 3: Aggiungi la fase di origine**, in **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Repository**, scegliere il repository di origine.

   1. In **Branch (Ramificazione)**, scegliere la ramificazione che si desidera utilizzare.

   1. Lascia le impostazioni predefinite rimanenti per l'azione di origine. Scegli **Next (Successivo)**.

1. Nel **passaggio 4: Aggiungi fase di compilazione, aggiungi una fase** di compilazione:

   1. In **Build provider**, scegli **Altri fornitori di build**, quindi scegli **AWS CodeBuild**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. **Per **Image**, scegli:5.0aws/codebuild/standard.**

      CodeBuild utilizza questa immagine del sistema operativo, su cui è installato Android Studio, per creare l'app.

   1. Per **Ruolo di servizio**, scegli il ruolo CodeBuild di servizio esistente o creane uno nuovo.

   1. Per **Build specifications (Compila specifiche)**, scegli **Use a buildspec file (Usa un file buildspec)**.

   1. Scegli **Continua a CodePipeline**. Questo ritorna alla CodePipeline console e crea un CodeBuild progetto che utilizza il file `buildspec.yml` nel tuo repository per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.** Dovresti visualizzare uno schema che mostra le fasi di origine e compilazione.

1. Aggiungi un'azione di test di Device Farm alla tua pipeline:

   1. In alto a destra, scegli **Edit (Modifica)**.

   1. In fondo al diagramma, scegliere **\$1 Add stage (\$1 Aggiungi fase)** In **Nome fase** immetti un nome, ad esempio **Test**.

   1. Scegliere **\$1 Add action group (\$1 Aggiungi gruppo di operazioni)**.

   1. Alla voce **Action name (Nome operazione)**, inserire un nome. 

   1. In **Action provider**, scegli **AWS Device Farm**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. In **Input artifacts (Artefatti di input)**, scegli l'artefatto di input che corrisponde all'artefatto di output della fase precedente alla fase di test, ad esempio `BuildArtifact`. 

      Nella AWS CodePipeline console, puoi trovare il nome dell'elemento di output per ogni fase passando il mouse sull'icona delle informazioni nel diagramma della pipeline. **Se la pipeline verifica l'app direttamente dalla fase Source, scegli. **SourceArtifact**** Se la pipeline include una fase di **creazione**, scegli. **BuildArtifact**

   1. Nel **ProjectId**, inserisci l'ID del tuo progetto Device Farm. Utilizzare la procedura all'inizio di questo tutorial per recuperare l'ID del progetto.

   1. In **DevicePoolArn**, inserisci l'ARN per il pool di dispositivi. Per ottenere il pool di dispositivi disponibile ARNs per il progetto, incluso l'ARN per i dispositivi principali, utilizza la AWS CLI per immettere il seguente comando: 

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. **In **AppType**, inserisci Android.**

      Di seguito è riportato un elenco di valori validi per **AppType**:
      + **iOS**
      + **Android**
      + **App**

   1. In **App**, inserisci il percorso del pacchetto dell'applicazione compilata. Il percorso è relativo alla cartella principale dell'artefatto di input della fase di sviluppo. Di solito, questo percorso è simile a `app-release.apk`.

   1. In **TestType**, inserisci il tipo di test, quindi in **Test**, inserisci il percorso del file di definizione del test. Il percorso è relativo alla cartella principale dell'artefatto di input del test.

      Di seguito è riportato un elenco di valori validi per **TestType**:
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **NODO\$1APPIUM**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **NODO APPIUM\$1WEB**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**Nota**  
I nodi di ambiente personalizzati non sono supportati.

   1. Nei campi rimanenti, inserire la configurazione appropriata per il test e il tipo di applicazione.

   1. (Facoltativo) IN **Advanced (Avanzate)**, fornire informazioni di configurazione per la sessione di test.

   1. Scegli **Save** (Salva).

   1. Nella fase che stai modificando, scegli **Done (Fatto)**. Nel riquadro AWS CodePipeline , scegli **Save (Salva)** e quindi scegli **Save (Salva)** sul messaggio di avviso.

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

# Tutorial: crea una pipeline con cui testare la tua app iOS AWS Device Farm
<a name="tutorials-codebuild-devicefarm-S3"></a>

 Puoi usarlo AWS CodePipeline per configurare facilmente un flusso di integrazione continuo in cui la tua app viene testata ogni volta che il bucket di origine cambia. Questo tutorial illustra come creare e configurare una pipeline per testare l'app iOS compilata da un bucket S3. La pipeline rileva l'arrivo di una modifica salvata tramite Amazon CloudWatch Events, quindi utilizza [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) per testare l'applicazione creata. 

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

**Importante**  
Molte delle azioni che aggiungi alla pipeline in questa procedura coinvolgono AWS risorse che devi creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

Puoi sperimentare utilizzando una tua app iOS preesistente oppure puoi utilizzare l'[app iOS di esempio](samples/s3-ios-test-1.zip).

**Prima di iniziare**

1. Accedi alla AWS Device Farm console e scegli **Crea un nuovo progetto**.

1. Scegliere il progetto. Nel browser, copiare l'URL del nuovo progetto. L'URL contiene l'ID del progetto.

1. Copiare e conservare questo ID del progetto. Viene utilizzato quando si crea la pipeline in CodePipeline.

   Ecco un URL di esempio per un progetto. Per estrarre l'ID del progetto, copiare il valore dopo `projects/`. In questo esempio l'ID del prodotto è `eec4905f-98f8-40aa-9afc-4c1cfexample`.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Configura CodePipeline per utilizzare i test Device Farm (esempio Amazon S3)
<a name="codepipeline-configure-tests-S3"></a>

1. Creare o utilizzare un bucket S3 con la funzione versioni multiple attivata. Per creare un bucket S3, segui le istruzioni contenute in [Passaggio 1: crea un bucket di origine S3 per la tua applicazione](tutorials-simple-s3.md#s3-create-s3-bucket).

1. Nella console Amazon S3 del tuo bucket, scegli **Carica** e segui le istruzioni per caricare il tuo file.zip.

   L'applicazione di esempio deve essere compressa in un file .zip.

1. Per creare la pipeline e aggiungere una fase di origine, procedi nel seguente modo:

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

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

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

   1. Nella pagina **Passaggio 2: Scegli le impostazioni della pipeline**, in Nome **pipeline, inserisci il nome** della pipeline.

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

   1. Alla voce **Service role (Ruolo del servizio)**, lasciare selezionato **New service role (Nuovo ruolo del servizio)** e lasciare immutata la voce **Role name (Nome ruolo)**. È anche possibile scegliere di utilizzare un ruolo di servizio esistente, se disponibile.
**Nota**  
Se si utilizza un ruolo CodePipeline di servizio creato prima di luglio 2018, è necessario aggiungere le autorizzazioni per Device Farm. A tale scopo, apri la console IAM, trova il ruolo e aggiungi le seguenti autorizzazioni alla policy del ruolo. Per ulteriori informazioni, consulta [Aggiungi le autorizzazioni al ruolo di servizio CodePipeline](how-to-custom-role.md#how-to-update-role-new-services).  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

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

   1. Nella pagina **Fase 3: Aggiungi fase di origine**, in **Provider di origine**, scegli **Amazon S3**.

   1. Nella **posizione Amazon S3**, inserisci il bucket, ad esempio, e la chiave oggetto`my-storage-bucket`, ad esempio `s3-ios-test-1.zip` per il tuo file.zip.

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

1. Nel **passaggio 4: aggiungi la fase di costruzione, crea una fase** di compilazione segnaposto per la tua pipeline. In questo modo è possibile creare la pipeline nella procedura guidata. Dopo aver utilizzato la procedura guidata per creare la pipeline a due fasi, questo segnaposto per la fase di compilazione non è più necessario. Una volta completata la creazione della pipeline, questa seconda fase viene eliminata e viene aggiunta la nuova fase di test nel passaggio 5.

   

   1. Alla voce **Build provider (Provider di compilazione)**, scegliere **Add Jenkins (Aggiungi Jenkins)**. Questa selezione per la compilazione è un segnaposto. Non viene utilizzato.

   1. Alla voce **Provider name (Nome provider)**, inserire un nome. Il nome è un segnaposto. Non viene utilizzato.

   1. Alla voce **Server URL (URL server)**, inserire il testo. Il testo è un segnaposto. Non viene utilizzato.

   1. Alla voce **Project name (Nome progetto)**, inserire un nome. Il nome è un segnaposto. Non viene utilizzato.

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

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

      Scegli **Next (Successivo)**.

   1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.**

   1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.** Dovresti visualizzare uno schema che mostra le fasi di origine e compilazione.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/codepipeline-view-pipeline-S3.png)

1. Aggiungi un'azione di test di Device Farm alla tua pipeline come segue:

   1. In alto a destra, scegli **Edit (Modifica)**. 

   1. Scegli **Edit stage (Modifica fase)**. Scegli **Elimina**. Ciò elimina il segnaposto della fase ora che non è più necessaria per la creazione della pipeline.

   1. In fondo al diagramma, scegliere **\$1 Add stage (\$1 Aggiungi fase)**

   1. In "Nome fase", immetti un nome per la fase, ad esempio Test, quindi scegli **Add stage (Aggiungi fase)**.

   1. Scegliere **\$1 Add action group (\$1 Aggiungi gruppo di operazioni)**.

   1. In **Nome azione**, inserisci un nome, ad esempio DeviceFarmTest.

   1. In **Action provider**, scegli **AWS Device Farm**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. In **Input artifacts (Artefatti di input)**, scegli l'artefatto di input che corrisponde all'artefatto di output della fase precedente alla fase di test, ad esempio `SourceArtifact`. 

      Nella AWS CodePipeline console, puoi trovare il nome dell'elemento di output per ogni fase passando il mouse sull'icona delle informazioni nel diagramma della pipeline. **Se la pipeline verifica l'app direttamente dalla fase Source, scegli. **SourceArtifact**** Se la pipeline include una fase di **creazione**, scegli. **BuildArtifact**

   1. Nel **ProjectId**, scegli l'ID del tuo progetto Device Farm. Utilizzare la procedura all'inizio di questo tutorial per recuperare l'ID del progetto.

   1. In **DevicePoolArn**, inserisci l'ARN per il pool di dispositivi. Per ottenere il pool di dispositivi disponibile ARNs per il progetto, incluso l'ARN per i dispositivi principali, utilizza la AWS CLI per immettere il seguente comando: 

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. Nel **AppType**, inserisci **iOS**.

      Di seguito è riportato un elenco di valori validi per **AppType**:
      + **iOS**
      + **Android**
      + **App**

   1. In **App**, inserisci il percorso del pacchetto dell'applicazione compilata. Il percorso è relativo alla cartella principale dell'artefatto di input della fase di sviluppo. Di solito, questo percorso è simile a `ios-test.ipa`.

   1. In **TestType**, inserisci il tipo di test, quindi in **Test**, inserisci il percorso del file di definizione del test. Il percorso è relativo alla cartella principale dell'artefatto di input del test.

      Se utilizzi uno dei test Device Farm integrati, inserisci il tipo di test configurato nel tuo progetto Device Farm, ad esempio BUILTIN\$1FUZZ. In **FuzzEventCount**, inserisci un tempo in millisecondi, ad esempio 6000. In **FuzzEventThrottle**, immettete un tempo in millisecondi, ad esempio 50.

      Se non stai utilizzando uno dei test Device Farm integrati, inserisci il tipo di test, quindi in **Test** inserisci il percorso del file di definizione del test. Il percorso è relativo alla cartella principale dell'artefatto di input del test. 

      Di seguito è riportato un elenco di valori validi per **TestType**:
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **NODO\$1APPIUM**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **NODO APPIUM\$1WEB**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**Nota**  
I nodi di ambiente personalizzati non sono supportati.

   1. Nei campi rimanenti, inserire la configurazione appropriata per il test e il tipo di applicazione.

   1. (Facoltativo) IN **Advanced (Avanzate)**, fornire informazioni di configurazione per la sessione di test.

   1. Scegli **Save** (Salva).

   1. Nella fase che stai modificando, scegli **Done (Fatto)**. Nel riquadro AWS CodePipeline , scegli **Save (Salva)** e quindi scegli **Save (Salva)** sul messaggio di avviso.

   1. Per inviare le modifiche e avviare l'esecuzione della pipeline, scegli **Release change (Rilascia modifica)** e quindi scegli **Release (Rilascia)**.

# Tutorial: crea una pipeline da distribuire su Service Catalog
<a name="tutorials-S3-servicecatalog"></a>

Service Catalog consente di creare e fornire prodotti basati su AWS CloudFormation modelli. 

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

Questo tutorial mostra come creare e configurare una pipeline per distribuire il modello di prodotto su Service Catalog e fornire le modifiche apportate nel repository di origine (già creato in GitHub CodeCommit, o Amazon S3).

**Nota**  
Se Amazon S3 è il provider di origine per la tua pipeline, devi caricare nel tuo bucket tutti i file sorgente impacchettati come un unico file.zip. In caso contrario, l'azione di origine ha esito negativo.

Innanzitutto, crei un prodotto in Service Catalog, quindi crei una pipeline in AWS CodePipeline. Questo tutorial offre due opzioni per l'impostazione della configurazione della distribuzione:
+ Crea un prodotto in Service Catalog e carica un file modello nel tuo repository di origine. Fornisci la versione del prodotto e la configurazione di distribuzione nella CodePipeline console (senza un file di configurazione separato). Per informazioni, consulta [Opzione 1: distribuzione su Service Catalog senza un file di configurazione](#tutorials-S3-servicecatalog-ex1-configure).
**Nota**  
Il file di modello può essere creato in formato JSON o YAML.
+ Crea un prodotto in Service Catalog e carica un file modello nel tuo repository di origine. Fornisci la versione del prodotto e la configurazione della distribuzione nella console (senza un file di configurazione separato). Per informazioni, consulta [Opzione 2: eseguire la distribuzione su Service Catalog utilizzando un file di configurazione](#tutorials-S3-servicecatalog-ex2-configure).

## Opzione 1: distribuzione su Service Catalog senza un file di configurazione
<a name="tutorials-S3-servicecatalog-ex1-configure"></a>

In questo esempio, carichi il file AWS CloudFormation modello di esempio per un bucket S3, quindi crei il prodotto in Service Catalog. Successivamente, crei la pipeline e specifichi la configurazione di distribuzione nella console. CodePipeline 

### Fase 1: caricamento di file di modello di esempio nel repository di origine
<a name="tutorials-S3-servicecatalog-configure"></a>

1. Aprire un editor di testo. Creare un modello di esempio incollando quanto segue nel file. Salva il file con nome `S3_template.json`.

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   Questo modello consente di AWS CloudFormation creare un bucket S3 che può essere utilizzato da Service Catalog.

1. Caricare il file `S3_template.json` nel repository AWS CodeCommit .

### Fase 2: Creare un prodotto in Service Catalog
<a name="tutorials-S3-servicecatalog-product"></a>

1. In qualità di amministratore IT, accedi alla console Service Catalog, vai alla pagina **Prodotti**, quindi scegli **Carica nuovo prodotto**.

1. Nella pagina **Upload new product (Carica nuovo prodotto)**, procedere come segue:

   1. In **Product name (Nome prodotto)**, immettere il nome da utilizzare per il nuovo prodotto.

   1. In **Description (Descrizione)**, immettere la descrizione del catalogo dei prodotti. Questa descrizione è visualizzata nell'elenco dei prodotti per consentire all'utente di scegliere il prodotto corretto. 

   1. In **Provided by (Fornito da)**, immettere il nome dell'amministratore o del reparto IT.

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

1. (Facoltativo) In **Enter support details (Inserisci i dettagli di supporto)**, immettere le informazioni di contatto per il supporto del prodotto e scegliere **Next (Successivo)**.

1. In **Version details (Dettagli versione)**, procedere come segue:

   1. Scegliere **Upload a template file (Carica un file di modello)**. Individuare il file `S3_template.json` e caricarlo.

   1. In **Version title (Titolo versione)**, immettere il nome della versione del prodotto (ad esempio **devops S3 v2**).

   1. In **Description (Descrizione)**, immettere i dettagli che distinguono questa versione dalle altre versioni.

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

1. Nella pagina **Review (Verifica)**, verificare che le informazioni siano corrette, quindi scegliere **Create (Crea)**. 

1. Nella pagina **Products (Prodotti)**, copiare nel browser l'URL del nuovo prodotto. L'URL contiene l'ID del prodotto. Copiare e conservare questo ID del prodotto. Viene utilizzato quando si crea la pipeline in CodePipeline.

   Ecco l'URL per un prodotto denominato `my-product`. Per estrarre l'ID del prodotto, copiare il valore compreso tra il segno di uguale (`=`) e la E commerciale (`&`). In questo esempio l'ID del prodotto è `prod-example123456`.

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**Nota**  
Copiare l'URL per il prodotto prima di uscire da questa pagina. Una volta che si esce da questa pagina, è necessario utilizzare l'interfaccia a riga di comando per ottenere l'ID prodotto.

   Dopo alcuni secondi, il prodotto viene visualizzato nella pagina **Products (Prodotti)**. È possibile che sia necessario aggiornare il browser per visualizzare il prodotto nell'elenco.

### Fase 3: creazione della pipeline
<a name="tutorials-S3-servicecatalog-pipeline"></a>

1. Per assegnare un nome alla pipeline e selezionare i parametri per la pipeline, procedere nel seguente modo:

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

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

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

   1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in Nome della **pipeline, inserite un nome** per la pipeline.

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

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

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

1. Per aggiungere una fase di origine nella pagina **Passaggio 3: Aggiungi fase di origine**, procedi come segue:

   1. In **Source provider (Provider origine)**, scegliere **AWS CodeCommit**.

   1. In **Repository name (Nome del repository)** e **Branch name (Nome ramo)**, immettere il repository e il ramo da utilizzare per l'operazione di origine.

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

1. Nel **passaggio 4: aggiungi la fase di creazione**, scegli **Ignora fase di creazione**, quindi accetta il messaggio di avviso scegliendo nuovamente **Ignora**.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di distribuzione**, completa quanto segue:

   1. In **Deploy provider (Provider di distribuzione)**, scegliere **AWS Service Catalog**.

   1. Per la configurazione della distribuzione, scegli **Enter deployment configuration (Inserisci configurazione distribuzione)**.

   1. In **Product ID**, incolla l'ID del prodotto che hai copiato dalla console Service Catalog.

   1. In **Template file path (Percorso file di modello)**, immettere il percorso relativo dove è archiviato il file di modello.

   1. In **Tipo di prodotto**, scegli **CloudFormation modello**.

   1. Nel **Nome della versione del prodotto**, inserisci il nome della versione del prodotto specificata in Service Catalog. Se si desidera che la modifica del modello venga distribuita in una nuova versione del prodotto, immettere un nome della versione del prodotto che non è stato utilizzato per una versione precedente dello stesso prodotto.

   1. Per **Input artifact (Artefatto di input)**, scegliere l'artefatto di origine di input.

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

1. Nel **Passaggio 7: Rivedi**, rivedi le impostazioni della pipeline, quindi scegli **Crea**.

1. Dopo che la pipeline è in esecuzione, nella fase di distribuzione, scegliere **Details (Dettagli)**. Verrà aperto il prodotto in Service Catalog.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. Nelle informazioni sul prodotto, scegliere il nome della versione per aprire il modello di prodotto. Visualizzare la distribuzione del modello.

### Passaggio 4: invia una modifica e verifica il prodotto in Service Catalog
<a name="tutorials-S3-servicecatalog-change"></a>

1. Visualizza la pipeline nella CodePipeline console e, nella fase di origine, scegli **Dettagli**. Il tuo AWS CodeCommit repository di origine si apre nella console. Scegliere **Edit (Modifica)** ed effettuare una modifica nel file (ad esempio la descrizione). 

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. Eseguire il commit e il push della modifica. La pipeline viene avviata dopo il push della modifica. Una volta completata l'esecuzione della pipeline, nella fase di implementazione, scegli **Dettagli** per aprire il prodotto in Service Catalog.

1. Nelle informazioni sul prodotto, scegliere il nome della nuova versione per aprire il modello di prodotto. Visualizzare la modifica del modello distribuito.

## Opzione 2: eseguire la distribuzione su Service Catalog utilizzando un file di configurazione
<a name="tutorials-S3-servicecatalog-ex2-configure"></a>

In questo esempio, carichi il file AWS CloudFormation modello di esempio per un bucket S3, quindi crei il prodotto in Service Catalog. Inoltre carichi un file di configurazione separato che specifica la configurazione della distribuzione. Successivamente, crei la pipeline e specifichi il percorso del file di configurazione.

### Fase 1: caricamento di file di modello di esempio nel repository di origine
<a name="tutorials-S3-servicecatalog-upload2"></a>

1. Aprire un editor di testo. Creare un modello di esempio incollando quanto segue nel file. Salva il file con nome `S3_template.json`.

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   Questo modello consente di AWS CloudFormation creare un bucket S3 che può essere utilizzato da Service Catalog.

1. Caricare il file `S3_template.json` nel repository AWS CodeCommit .

### Fase 2: creazione del file di configurazione della distribuzione del prodotto
<a name="tutorials-S3-servicecatalog-configure2"></a>

1. Aprire un editor di testo. Creare il file di configurazione per il prodotto. Il file di configurazione viene utilizzato per definire i parametri/le preferenze di distribuzione del Service Catalog. Questo file viene utilizzato quando si crea la pipeline.

   In questo esempio viene usato il `ProductVersionName` "devops S3 v2" e la `ProductVersionDescription` `MyProductVersionDescription`. Se si desidera che la modifica del modello venga distribuita in una nuova versione del prodotto, è sufficiente immettere un nome della versione del prodotto che non è stato utilizzato per una versione precedente dello stesso prodotto.

    Salva il file con nome `sample_config.json`.

   ```
   {
       "SchemaVersion": "1.0",
       "ProductVersionName": "devops S3 v2",
       "ProductVersionDescription": "MyProductVersionDescription",
       "ProductType": "CLOUD_FORMATION_TEMPLATE",
       "Properties": {
           "TemplateFilePath": "/S3_template.json"
       }
   }
   ```

   Questo file crea le informazioni sulla versione del prodotto per ogni volta che si esegue la pipeline.

1. Caricare il file `sample_config.json` nel repository AWS CodeCommit . Assicurarsi di caricare questo file nel repository di origine.

### Fase 3: Creare un prodotto in Service Catalog
<a name="tutorials-S3-servicecatalog-product2"></a>

1. In qualità di amministratore IT, accedi alla console Service Catalog, vai alla pagina **Prodotti**, quindi scegli **Carica nuovo prodotto**.

1. Nella pagina **Upload new product (Carica nuovo prodotto)**, procedere come segue:

   1. In **Product name (Nome prodotto)**, immettere il nome da utilizzare per il nuovo prodotto.

   1. In **Description (Descrizione)**, immettere la descrizione del catalogo dei prodotti. Questa descrizione è presente nell'elenco dei prodotti per consentire all'utente di scegliere il prodotto corretto. 

   1. In **Provided by (Fornito da)**, immettere il nome dell'amministratore o del reparto IT.

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

1. (Facoltativo) In **Enter support details (Inserisci i dettagli di supporto)**, immettere le informazioni di contatto per il supporto del prodotto e scegliere **Next (Successivo)**.

1. In **Version details (Dettagli versione)**, procedere come segue:

   1. Scegliere **Upload a template file (Carica un file di modello)**. Individuare il file `S3_template.json` e caricarlo.

   1. In **Version title (Titolo versione)**, inserire il nome della versione del prodotto (ad esempio "devops S3 v2").

   1. In **Description (Descrizione)**, immettere i dettagli che distinguono questa versione dalle altre versioni.

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

1. Nella pagina **Review (Verifica)**, verificare che le informazioni siano corrette, quindi scegliere **Confirm and upload (Conferma e carica)**. 

1. Nella pagina **Products (Prodotti)**, copiare nel browser l'URL del nuovo prodotto. L'URL contiene l'ID del prodotto. Copiare e conservare questo ID del prodotto. Viene utilizzato quando si crea la pipeline in CodePipeline.

   Ecco l'URL per un prodotto denominato `my-product`. Per estrarre l'ID del prodotto, copiare il valore compreso tra il segno di uguale (`=`) e la E commerciale (`&`). In questo esempio l'ID del prodotto è `prod-example123456`. 

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**Nota**  
Copiare l'URL per il prodotto prima di uscire da questa pagina. Una volta che si esce da questa pagina, è necessario utilizzare l'interfaccia a riga di comando per ottenere l'ID prodotto.

   Dopo alcuni secondi, il prodotto viene visualizzato nella pagina **Products (Prodotti)**. È possibile che sia necessario aggiornare il browser per visualizzare il prodotto nell'elenco.

### Fase 4: creazione della pipeline
<a name="tutorials-S3-servicecatalog-pipeline2"></a>

1. Per assegnare un nome alla pipeline e selezionare i parametri per la pipeline, procedere nel seguente modo:

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

   1. Selezionare **Getting started (Nozioni di base)**. Scegliere **Create pipeline (Crea pipeline)** e immettere un nome per la pipeline.

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

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

1. Per aggiungere una fase di origine, procedere come segue:

   1. In **Source provider (Provider origine)**, scegliere **AWS CodeCommit**.

   1. In **Repository name (Nome del repository)** e **Branch name (Nome ramo)**, immettere il repository e il ramo da utilizzare per l'operazione di origine.

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

1. In **Add build stage (Aggiunta della fase di compilazione)**, scegli **Skip build stage (Ignora fase di compilazione)** e quindi accetta il messaggio di avviso scegliendo **Skip (Ignora)**.

1. In **Aggiunta della fase di distribuzione**, procedere come segue:

   1. In **Deploy provider (Provider di distribuzione)**, scegliere **AWS Service Catalog**.

   1. Selezionare **Use configuration file (Usa file di configurazione)**.

   1. In **Product ID**, incolla l'ID del prodotto che hai copiato dalla console Service Catalog.

   1. In **Configuration file path (Percorso file di configurazione)**, immettere il percorso del file di configurazione nel repository.

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

1. In **Review (Verifica)**, esaminare le impostazioni della pipeline e selezionare **Create (Crea)**.

1. Dopo il corretto funzionamento della pipeline, nella fase di implementazione, scegli **Dettagli** per aprire il prodotto in Service Catalog.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. Nelle informazioni sul prodotto, scegliere il nome della versione per aprire il modello di prodotto. Visualizzare la distribuzione del modello.

### Fase 5: push di una modifica e verifica del prodotto in Service Catalog
<a name="tutorials-S3-servicecatalog-change2"></a>

1. **Visualizza la pipeline nella CodePipeline console e, nella fase di origine, scegli Dettagli.** Il tuo AWS CodeCommit repository di origine si apre nella console. Scegliere **Edit (Modifica)** ed effettuare una modifica nel file (ad esempio la descrizione).

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. Eseguire il commit e il push della modifica. La pipeline viene avviata dopo il push della modifica. Una volta completata l'esecuzione della pipeline, nella fase di implementazione, scegli **Dettagli** per aprire il prodotto in Service Catalog.

1. Nelle informazioni sul prodotto, scegliere il nome della nuova versione per aprire il modello di prodotto. Visualizzare la modifica del modello distribuito.

# Tutorial: Creare una pipeline con AWS CloudFormation
<a name="tutorials-cloudformation"></a>

Gli esempi forniscono modelli di esempio che ti consentono di AWS CloudFormation creare una pipeline che distribuisce l'applicazione sulle tue istanze ogni volta che il codice sorgente cambia. Il modello di esempio crea una pipeline che è possibile visualizzare in AWS CodePipeline. La pipeline rileva l'arrivo di una modifica salvata tramite Amazon CloudWatch Events.

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

**Topics**
+ [

# Esempio 1: creare una AWS CodeCommit pipeline con AWS CloudFormation
](tutorials-cloudformation-codecommit.md)
+ [

# Esempio 2: creare una pipeline Amazon S3 con AWS CloudFormation
](tutorials-cloudformation-s3.md)

# Esempio 1: creare una AWS CodeCommit pipeline con AWS CloudFormation
<a name="tutorials-cloudformation-codecommit"></a>

Questa procedura dettagliata mostra come utilizzare la AWS CloudFormation console per creare un'infrastruttura che includa una pipeline connessa a un repository di origine. CodeCommit In questo tutorial, utilizzi il file modello di esempio fornito per creare il tuo stack di risorse, che include l'archivio degli artefatti, la pipeline e le risorse di rilevamento delle modifiche, come la regola Amazon Events. CloudWatch Dopo aver creato lo stack di risorse in AWS CloudFormation, puoi visualizzare la pipeline nella console. AWS CodePipeline La pipeline è una pipeline a due fasi con una fase di CodeCommit origine e una fase di distribuzione. CodeDeploy 

**Prerequisiti:**

È necessario aver creato le seguenti risorse da utilizzare con il AWS CloudFormation modello di esempio:
+ È necessario aver creato un repository di origine. È possibile utilizzare il AWS CodeCommit repository in [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md) cui è stato creato.
+ È necessario aver creato un' CodeDeploy applicazione e un gruppo di distribuzione. Puoi usare le risorse CodeDeploy create in [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md).
+ [Scegliete uno di questi link per scaricare il file AWS CloudFormation modello di esempio per la creazione di una pipeline: [YAML](samples/codepipeline-codecommit-events-yaml.zip) \$1 JSON](samples/codepipeline-codecommit-events-json.zip)

  Decomprimi il file e memorizzalo nel computer locale.
+ Scaricate il file dell'applicazione di esempio [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip).



**Crea la tua pipeline in AWS CloudFormation**

1. Decomprimi i file da [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) e carica i file nel tuo AWS CodeCommit repository. È necessario caricare i file estratti nella directory radice del repository. È possibile seguire le istruzioni disponibili in [Passaggio 2: aggiungi codice di esempio al tuo CodeCommit repository](tutorials-simple-codecommit.md#codecommit-add-code) per inviare i file nel repository.

1. Apri la AWS CloudFormation console e scegli **Create** Stack. Scegliere **Con nuove risorse (standard)**.

1. In **Specificare modello**, scegli **Carica un modello**. Seleziona **Scegli file**, quindi scegli il file modello dal tuo computer locale. Scegli **Next (Successivo)**.

1. Nel campo **Stack name (Nome stack)**, immetti un nome per la pipeline. Vengono visualizzati i parametri specificati dal modello di esempio. Immetti i seguenti parametri: 

   1. In **ApplicationName**, inserisci il nome della tua CodeDeploy applicazione.

   1. In **BetaFleet**, inserisci il nome del tuo gruppo di CodeDeploy distribuzione.

   1. In **BranchName**, inserisci il ramo del repository che desideri utilizzare.

   1. In **RepositoryName**, inserisci il nome del tuo repository di CodeCommit origine.

1. Scegli **Next (Successivo)**. Accetta i valori predefiniti nella pagina successiva e scegli **Next (Successivo)**.

1. In **Capacità**, seleziona **Riconosco che AWS CloudFormation potrebbe creare risorse IAM**, quindi scegli **Create stack**.

1. Alla fine della creazione dello stack, visualizza l'elenco di eventi per verificare che non vi siano errori.

   **Risoluzione dei problemi**

   L'utente IAM che sta creando la pipeline in AWS CloudFormation potrebbe richiedere autorizzazioni aggiuntive per creare risorse per la pipeline. Le seguenti autorizzazioni sono richieste nella policy AWS CloudFormation per consentire la creazione delle risorse Amazon CloudWatch Events richieste per la CodeCommit pipeline:

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

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

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.
**Nota**  
Per visualizzare la pipeline che è stata creata, trova la colonna **Logical ID** nella scheda **Risorse** relativa al tuo stack in. CloudFormation Annota il nome nella colonna **Physical ID** per la pipeline. In CodePipeline, puoi visualizzare la pipeline con lo stesso ID fisico (nome della pipeline) nella regione in cui hai creato lo stack.

1. Nel repository di origine, confermare e inviare una modifica. Le risorse con rilevamento delle modifiche raccolgono la modifica e la pipeline inizia.

# Esempio 2: creare una pipeline Amazon S3 con AWS CloudFormation
<a name="tutorials-cloudformation-s3"></a>

Questa procedura dettagliata mostra come utilizzare la AWS CloudFormation console per creare un'infrastruttura che include una pipeline connessa a un bucket sorgente Amazon S3. In questo tutorial, utilizzi il file modello di esempio fornito per creare il tuo stack di risorse, che include il bucket di origine, l'artifact store, la pipeline e le risorse di rilevamento delle modifiche, come la regola e il percorso di Amazon Events. CloudWatch CloudTrail Dopo aver creato lo stack di risorse in AWS CloudFormation, puoi visualizzare la pipeline nella console. AWS CodePipeline La pipeline è una pipeline a due fasi con una fase di origine di Amazon S3 e una fase di distribuzione. CodeDeploy

**Prerequisiti:**

È necessario disporre delle seguenti risorse da utilizzare con il modello di esempio: AWS CloudFormation 
+ Devi aver creato le istanze Amazon EC2, dove hai installato l' CodeDeploy agente sulle istanze. È necessario aver creato un' CodeDeploy applicazione e un gruppo di distribuzione. Usa Amazon EC2 e CodeDeploy le risorse in cui hai creato. [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)
+ Scegli i seguenti link per scaricare i file AWS CloudFormation modello di esempio per la creazione di una pipeline con un sorgente Amazon S3: 
  + Scaricare il modello di esempio per la pipeline: [YAML](samples/codepipeline-s3-events-yaml.zip) \$1 [JSON](samples/codepipeline-s3-events-json.zip)
  + [samples/codepipeline-s3-cloudtrail-yaml.zip](samples/codepipeline-s3-cloudtrail-yaml.zip)
  + Decomprimi i file e memorizzali nel computer locale.
+ [Scarica l'applicazione di esempio da \$1Linux.zip. SampleApp](samples/SampleApp_Linux.zip)

  Salva il file .zip nel computer locale. Puoi caricare il file .zip dopo aver creato lo stack.

**Crea la tua pipeline in AWS CloudFormation**

1. Apri la AWS CloudFormation console e scegli **Create Stack**. Scegliere **Con nuove risorse (standard)**.

1. In **Scegli un modello**, scegli **Carica un modello**. Seleziona **Scegli file**, quindi scegli il file modello dal tuo computer locale. Scegli **Next (Successivo)**.

1. Nel campo **Stack name (Nome stack)**, immetti un nome per la pipeline. Vengono visualizzati i parametri specificati dal modello di esempio. Immetti i seguenti parametri: 

   1. In **ApplicationName**, inserisci il nome della tua CodeDeploy applicazione. Puoi sostituire il nome predefinito `DemoApplication`.

   1. In **BetaFleet**, inserisci il nome del tuo gruppo di CodeDeploy distribuzione. Puoi sostituire il nome predefinito `DemoFleet`.

   1. In **SourceObjectKey**, entra`SampleApp_Linux.zip`. Carica questo file nel bucket dopo che il modello ha creato il bucket e la pipeline.

1. Scegli **Next (Successivo)**. Accetta i valori predefiniti nella pagina successiva e scegli **Next (Successivo)**.

1. In **Capacità**, seleziona **Riconosco che AWS CloudFormation potrebbe creare risorse IAM**, quindi scegli **Create stack**.

1. Alla fine della creazione dello stack, visualizza l'elenco di eventi per verificare che non vi siano errori.

   **Risoluzione dei problemi**

   L'utente IAM che sta creando la pipeline in AWS CloudFormation potrebbe richiedere autorizzazioni aggiuntive per creare risorse per la pipeline. Le seguenti autorizzazioni sono richieste nella policy AWS CloudFormation per consentire la creazione delle risorse Amazon CloudWatch Events richieste per la pipeline Amazon S3:

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. Nella CloudFormation scheda **Risorse** del tuo stack, visualizza le risorse che sono state create per il tuo stack. 
**Nota**  
Per visualizzare la pipeline che è stata creata, trova la colonna **ID logico** nella scheda **Risorse** relativa al tuo stack in. CloudFormation Annota il nome nella colonna **Physical ID** per la pipeline. In CodePipeline, puoi visualizzare la pipeline con lo stesso ID fisico (nome della pipeline) nella regione in cui hai creato lo stack.

   Scegliere il bucket S3 con un'etichetta `sourcebucket` nel nome, ad esempio `s3-cfn-codepipeline-sourcebucket-y04EXAMPLE.`. Non scegliere il bucket dell'artefatto della pipeline.

   Il bucket di origine è vuoto perché la risorsa è stata appena creata da CloudFormation. Apri la console Amazon S3 e individua il tuo `sourcebucket` bucket. Scegliere **Upload (Carica)** e seguire le istruzioni per caricare il file .zip `SampleApp_Linux.zip`.
**Nota**  
Se Amazon S3 è il fornitore di origine per la tua pipeline, devi caricare nel tuo bucket tutti i file sorgente impacchettati come un unico file.zip. In caso contrario, l'azione di origine ha esito negativo.

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

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Completare i passaggi nella procedura seguente per creare le risorse AWS CloudTrail .

**Crea le tue AWS CloudTrail risorse in AWS CloudFormation**

1. Apri la AWS CloudFormation console e scegli **Create Stack**.

1. In **Choose a template (Scegli un modello)**, scegliere **Upload a template to Amazon S3 (Carica un modello su Amazon S3)**. Scegli **Sfoglia**, quindi seleziona il file modello per le AWS CloudTrail risorse dal tuo computer locale. Scegli **Next (Successivo)**.

1. In **Stack name (Nome stack)** immetti un nome per lo stack di risorse. Vengono visualizzati i parametri specificati dal modello di esempio. Immetti i seguenti parametri: 

   1. In **SourceObjectKey**, accettate l'impostazione predefinita per il file zip dell'applicazione di esempio.

1. Scegli **Next (Successivo)**. Accetta i valori predefiniti nella pagina successiva e scegli **Next (Successivo)**.

1. In **Capacità**, seleziona **Riconosco che AWS CloudFormation potrebbe creare risorse IAM**, quindi scegli **Crea**.

1. Alla fine della creazione dello stack, visualizza l'elenco di eventi per verificare che non vi siano errori.

   Le seguenti autorizzazioni sono richieste nella policy per consentire AWS CloudFormation la creazione CloudTrail delle risorse richieste per la pipeline Amazon S3:

   ```
   {
        "Effect": "Allow",
        "Action": [
           "cloudtrail:CreateTrail",
           "cloudtrail:DeleteTrail",
           "cloudtrail:StartLogging",
           "cloudtrail:StopLogging",
           "cloudtrail:PutEventSelectors"
        ],
        "Resource": "resource_ARN"
   }
   ```

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

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Nel bucket di origine, confermare e inviare una modifica. Le risorse con rilevamento delle modifiche raccolgono la modifica e la pipeline si avvia.

# Tutorial: crea una pipeline che utilizza le variabili delle azioni di AWS CloudFormation distribuzione
<a name="tutorials-cloudformation-action"></a>

In questo tutorial, utilizzi la AWS CodePipeline console per creare una pipeline con un'azione di distribuzione. Quando viene eseguita la pipeline, il modello crea uno stack e un file `outputs`. Gli output generati dal modello di stack sono le variabili generate dall' AWS CloudFormation azione in. CodePipeline

Nell'operazione in cui viene creato lo stack dal modello, designi uno spazio dei nomi variabile. Le variabili prodotte dal file `outputs` possono quindi essere utilizzate da operazioni successive. In questo esempio, crei un set di modifiche basato sulla `StackName` variabile prodotta dall'azione AWS CloudFormation . Dopo un'approvazione manuale, puoi eseguire il set di modifiche e quindi creare un'operazione che elimina lo stack in base alla variabile `StackName`.

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

**Topics**
+ [

## Prerequisiti: creare un ruolo AWS CloudFormation di servizio e un repository CodeCommit
](#tutorials-cloudformation-action-prereq)
+ [

## Passaggio 1: scarica, modifica e carica il modello di esempio AWS CloudFormation
](#tutorials-cloudformation-action-upload)
+ [

## Fase 2: creazione della pipeline
](#tutorials-cloudformation-action-pipeline)
+ [

## Fase 3: Aggiungere un'azione di CloudFormation distribuzione per creare il set di modifiche
](#tutorials-cloudformation-action-changeset)
+ [

## Fase 4: aggiunta di un'operazione di approvazione manuale
](#tutorials-cloudformation-action-approval)
+ [

## Passaggio 5: aggiungere un'azione di CloudFormation distribuzione per eseguire il set di modifiche
](#tutorials-cloudformation-action-deployment)
+ [

## Passaggio 6: aggiungere un'azione di CloudFormation distribuzione per eliminare lo stack
](#tutorials-cloudformation-action-delete)

## Prerequisiti: creare un ruolo AWS CloudFormation di servizio e un repository CodeCommit
<a name="tutorials-cloudformation-action-prereq"></a>

Devi avere già quanto segue:
+ Un CodeCommit repository. Puoi usare il AWS CodeCommit repository in cui hai creato. [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)
+ Questo esempio crea uno stack Amazon DocumentDB da un modello. È necessario utilizzare AWS Identity and Access Management (IAM) per creare un ruolo di AWS CloudFormation servizio con le seguenti autorizzazioni per Amazon DocumentDB.

  ```
  "rds:DescribeDBClusters",
  "rds:CreateDBCluster",
  "rds:DeleteDBCluster",
  "rds:CreateDBInstance"
  ```

## Passaggio 1: scarica, modifica e carica il modello di esempio AWS CloudFormation
<a name="tutorials-cloudformation-action-upload"></a>

Scarica il file AWS CloudFormation modello di esempio e caricalo nel tuo CodeCommit repository.

1. Vai al modello di esempio per la tua regione. Ad esempio, utilizza la tabella in [https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack](https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack) per scegliere la regione e scaricare il modello. Scarica il modello per un cluster Amazon DocumentDB. Il nome del file è `documentdb_full_stack.yaml`.

1. Decomprimi il file `documentdb_full_stack.yaml` e aprilo in un editor di testo. Apportare le seguenti modifiche:

   1. Per questo esempio, aggiungi il seguente parametro `Purpose:` alla sezione `Parameters` del modello.

      ```
        Purpose:
          Type: String
          Default: testing
          AllowedValues:
            - testing
            - production
          Description: The purpose of this instance.
      ```

   1. Per questo esempio, aggiungi il seguente output `StackName` alla sezione `Outputs:` del modello.

      ```
        StackName:
          Value: !Ref AWS::StackName
      ```

1. Carica il file modello nel tuo AWS CodeCommit repository. Devi caricare il file del modello decompresso e modificato nella directory root del repository. 

   Per utilizzare la CodeCommit console per caricare i file: 

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

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

   1. Seleziona **Choose file (Scegli file)** e vai al file. Conferma la modifica inserendo il tuo nome utente e indirizzo e-mail. Scegliere **Commit changes (Applica modifiche)**.

   Il tuo file dovrebbe essere simile al seguente a livello di root nel tuo repository:

   ```
   documentdb_full_stack.yaml
   ```

## Fase 2: creazione della pipeline
<a name="tutorials-cloudformation-action-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un' CodeCommit azione in cui l'elemento sorgente è il file modello.
+ Una fase di distribuzione con un' CloudFormation azione di distribuzione.

A ogni operazione delle fasi di origine e distribuzione create dalla procedura guidata viene assegnato uno spazio dei nomi variabile `SourceVariables` e `DeployVariables`, rispettivamente. Poiché alle operazioni è assegnato uno spazio dei nomi, le variabili configurate in questo esempio sono disponibili per le operazioni downstream. Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).

**Per creare una pipeline con la procedura guidata**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyCFNDeployPipeline**

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

1. In **Service role (Ruolo del servizio)**, procedere in uno dei seguenti modi:
   + Scegli **Nuovo ruolo di servizio** CodePipeline per consentire la creazione di un ruolo di servizio in IAM.
   + Scegli **Existing service role (Ruolo di servizio esistente)**. In **Role name (Nome ruolo)**, scegli il ruolo del servizio dall'elenco.

1. In **Artifact store (Archivio di artefatti)**: 

   1. Scegli **Posizione predefinita** per utilizzare l'archivio di artifact predefinito, ad esempio il bucket di artifact Amazon S3 designato come predefinito, per la tua pipeline nella regione selezionata per la tua pipeline.

   1. Scegli **Ubicazione personalizzata** se disponi già di un archivio di artefatti, ad esempio un bucket di artefatti Amazon S3, nella stessa regione della pipeline.
**Nota**  
Non si tratta del bucket di origine per il codice sorgente, ma dell'archivio artefatti per la pipeline. È richiesto un archivio artefatti separato, ad esempio un bucket S3, per ogni pipeline. Quando crei o modifichi una pipeline, devi avere un bucket di artefatti nella regione della pipeline e un bucket di artefatti per regione in cui stai eseguendo un'azione. AWS   
Per ulteriori informazioni, consultare [Artefatti di input e output](welcome-introducing-artifacts.md) e [CodePipeline riferimento alla struttura della tubazione](reference-pipeline-structure.md).

   Scegli **Next (Successivo)**.

1. **Nel passaggio 3: Aggiungere la fase di origine:** 

   1. In **Source provider (Provider origine)**, scegliere **AWS CodeCommit**.

   1. In **Nome archivio**, scegli il nome del CodeCommit repository in cui hai creato. [Passaggio 1: crea un CodeCommit repository](tutorials-simple-codecommit.md#codecommit-create-repository)

   1. In **Branch name (Nome ramo)**, scegliere il nome del ramo che contiene l'aggiornamento di codice più recente.

   Dopo aver selezionato il nome e il ramo del repository, viene visualizzata la regola Amazon CloudWatch Events da creare per questa pipeline. 

   Scegli **Next (Successivo)**.

1. **Nel **passaggio 4: aggiungi la fase di creazione**, scegli **Ignora fase di creazione**, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** 

   Scegli **Next (Successivo)**.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di implementazione**:

   1. In **Nome azione**, scegli **Distribuisci**. In **Deploy provider (Provider di distribuzione)**, scegliere **CloudFormation**.

   1. In **Modalità azione**, scegli **Crea o aggiorna uno stack**.

   1. In **Nome stack**, immetti un nome per lo stack. Questo è il nome dello stack che viene creato dal modello.

   1. In **Nome file di output**, immetti un nome per il file di output, ad esempio **outputs**. Questo è il nome del file che viene creato dall'operazione dopo la creazione dello stack.

   1. Espandere **Advanced (Avanzate)**. In **Sostituzioni di parametro**, immetti le sostituzioni del modello come coppie chiave-valore. Ad esempio, questo modello richiede le sostituzioni seguenti.

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "testing"}
      ```

      Se non immetti le sostituzioni, il modello crea uno stack con valori predefiniti.

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

   1. Nel **passaggio 7: revisione**, scegli **Crea pipeline**. Dovresti vedere un diagramma che mostra le fasi della pipeline. Consenti l'esecuzione della pipeline. La pipeline in due fasi è completa e pronta per l'aggiunta di altre fasi.

## Fase 3: Aggiungere un'azione di CloudFormation distribuzione per creare il set di modifiche
<a name="tutorials-cloudformation-action-changeset"></a>

Crea un'azione successiva nella tua pipeline che CloudFormation consenta di creare il set di modifiche prima dell'azione di approvazione manuale.



1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Scegli questa opzione per modificare la pipeline o continuare a visualizzare la pipeline in modalità **Modifica**.

1. Scegli di modificare la fase di **distribuzione.**

1. Aggiungi un'azione di distribuzione che creerà un set di modifiche per lo stack creato nell'azione precedente. Aggiungi questa azione dopo l'azione esistente nella fase.

   1. In **Nome azione**, immetti **Change\$1Set**. In **Action provider**, scegli **AWS CloudFormation **.

   1. In **Input artifact, scegli**. **SourceArtifact**

   1. In **Action mode (Modalità operazione)** selezionare **Create or replace a change set (Crea o sostituisci un set di modifiche)**.

   1. In **Nome stack**, immetti la sintassi della variabile come indicato di seguito. Si tratta del nome dello stack per cui viene creato il set di modifiche in cui lo spazio dei nomi predefinito `DeployVariables` viene assegnato all'operazione.

      ```
      #{DeployVariables.StackName}
      ```

   1. In **Nome del set di modifiche**, immetti il nome del set di modifiche.

      ```
      my-changeset
      ```

   1. In **Sostituzioni di parametro**, modifica il parametro `Purpose` da `testing` a `production`.

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "production"}
      ```

   1. Seleziona **Fatto** per salvare l'operazione.

## Fase 4: aggiunta di un'operazione di approvazione manuale
<a name="tutorials-cloudformation-action-approval"></a>

Crea un'operazione di approvazione manuale nella pipeline.



1. Scegli questa opzione per modificare la pipeline o continuare a visualizzare la pipeline in modalità **Modifica**.

1. Scegliete di modificare la fase **Deploy**.

1. Aggiungi un'operazione di approvazione manuale dopo l'operazione di distribuzione che crea il set di modifiche. Questa azione consente di verificare l'impostazione della modifica della risorsa creata CloudFormation prima che la pipeline esegua il set di modifiche.

## Passaggio 5: aggiungere un'azione di CloudFormation distribuzione per eseguire il set di modifiche
<a name="tutorials-cloudformation-action-deployment"></a>

Crea un'azione successiva nella tua pipeline che CloudFormation consenta di eseguire il set di modifiche dopo l'azione di approvazione manuale.



1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Scegli questa opzione per modificare la pipeline o continuare a visualizzare la pipeline in modalità **Modifica**.

1. Scegli di modificare la fase di **distribuzione.**

1. Aggiungi un'azione di distribuzione che eseguirà il set di modifiche approvato nella precedente azione manuale:

   1. In **Nome azione**, immetti **Execute\$1Change\$1Set**. In **Action provider**, scegli **AWS CloudFormation**.

   1. In **Input artifact, scegli**. **SourceArtifact**

   1. In **Action mode (Modalità operazione)**, selezionare **Execute a change set (Esegui un set di modifiche)**.

   1. In **Nome stack**, immetti la sintassi della variabile come indicato di seguito. Questo è il nome dello stack per cui viene creato il set di modifiche.

      ```
      #{DeployVariables.StackName}
      ```

   1. In **Nome del set di modifiche**, immetto il nome del set di modifiche creato nell'operazione precedente.

      ```
      my-changeset
      ```

   1. Seleziona **Fatto** per salvare l'operazione.

   1. Continua l'esecuzione della pipeline.

## Passaggio 6: aggiungere un'azione di CloudFormation distribuzione per eliminare lo stack
<a name="tutorials-cloudformation-action-delete"></a>

Crea un'azione finale nella tua pipeline che permetta di CloudFormation ottenere il nome dello stack dalla variabile nel file di output ed eliminare lo stack.



1. Apri la console all'indirizzo. CodePipeline [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Scegli questa opzione per modificare la pipeline.

1. Scegli di modificare la fase di **distribuzione.**

1. Aggiungi un'operazione di distribuzione che elimina lo stack:

   1. In **Nome azione**, scegli **DeleteStack**. In **Deploy provider (Provider di distribuzione)**, scegliere **CloudFormation**.

   1. In **Modalità azione**, scegli **Elimina uno stack**.

   1. In **Nome stack**, immetti la sintassi della variabile come indicato di seguito. Questo è il nome dello stack che viene eliminato dall'operazione.

   1. Seleziona **Fatto** per salvare l'operazione.

   1. Seleziona **Salva** per salvare la pipeline.

   La pipeline viene eseguita quando viene salvata.

# Tutorial: distribuzione standard di Amazon ECS con CodePipeline
<a name="ecs-cd-pipeline"></a>

Questo tutorial ti aiuta a creare una pipeline di distribuzione end-to-end continua (CD) completa con Amazon ECS with. CodePipeline

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

**Nota**  
Questo tutorial riguarda l'azione di distribuzione standard di Amazon ECS per CodePipeline. Per un tutorial che utilizza Amazon ECS per un'azione di distribuzione CodeDeploy blu/green in CodePipeline, consulta. [Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)

**Nota**  
Questo tutorial riguarda l'azione di distribuzione standard di Amazon ECS CodePipeline con un'azione di origine. Per un tutorial che utilizza l'azione di ECSstandard distribuzione di Amazon insieme all'azione di ECRBuild AndPublish compilazione CodePipeline per inserire la tua immagine, consulta[Tutorial: crea e invia un'immagine Docker ad Amazon ECR con CodePipeline (tipo V2)](tutorials-ecr-build-publish.md).

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

Per utilizzare questo tutorial per creare la pipeline di distribuzione continua, è necessario disporre di alcune risorse. Ecco di cosa hai bisogno prima di iniziare: 

**Nota**  
Tutte queste risorse devono essere create all'interno della stessa AWS regione.
+ Un repository per il controllo del codice sorgente (utilizzato in questo tutorial CodeCommit) con il Dockerfile e l'origine dell'applicazione. *Per ulteriori informazioni, consulta [Creare un CodeCommit repository](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html) nella Guida per l'utente.AWS CodeCommit *
+ Un repository di immagini Docker (questo tutorial utilizza Amazon ECR) che contiene un'immagine che hai creato dal tuo Dockerfile e dall'origine dell'applicazione. Per ulteriori informazioni, consulta [Creating a Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) and [Pushing an Image](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) nella *Amazon Elastic Container Registry User Guide*.
+ Una definizione di attività Amazon ECS che fa riferimento all'immagine Docker ospitata nel tuo repository di immagini. Per ulteriori informazioni, consulta [Creating a Task Definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html) nella *Amazon Elastic Container Service Developer Guide*.
**Importante**  
L'azione di distribuzione standard di Amazon ECS CodePipeline crea la propria revisione della definizione dell'attività in base alla revisione utilizzata dal servizio Amazon ECS. Se crei nuove revisioni per la definizione dell'attività senza aggiornare il servizio Amazon ECS, l'azione di distribuzione ignorerà tali revisioni.

  Di seguito è riportato un esempio di definizione di attività utilizzata per questo tutorial. Il valore utilizzato `name` e che `family` verrà utilizzato nel passaggio successivo per il file delle specifiche della build.

  ```
  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }
  ```
+ Un cluster Amazon ECS che esegue un servizio che utilizza la definizione di attività menzionata in precedenza. Per ulteriori informazioni, consulta [Creazione di un cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) e [creazione di un servizio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) nella *Amazon Elastic Container Service Developer Guide*.

Dopo aver soddisfatto questi prerequisiti, puoi procedere con il tutorial e creare la pipeline di distribuzione continua.

## Fase 1: aggiunta di un file di specifica di compilazione all'archivio di codice sorgente
<a name="cd-buildspec"></a>

Questo tutorial serve CodeBuild per creare la tua immagine Docker e inviarla ad Amazon ECR. Aggiungi un file `buildspec.yml` all'archivio del codice sorgente per indicare a CodeBuild come effettuare l'operazione. La specifica di compilazione di esempio in basso comprende quanto segue:
+ Fase precedente alla compilazione:
  + Accedi ad Amazon ECR.
  + Imposta l'URI dell'archivio sull'immagine ECR e aggiungi un tag di immagine con i primi sette caratteri dell'ID commit di Git del codice sorgente.
+ Fase di compilazione:
  + Crea l'immagine Docker e contrassegna con dei tag l'immagine sia come `latest` che con l'ID commit di Git.
+ Fase posteriore alla compilazione:
  + Inserisci l'immagine nell'archivio ECR con entrambi i tag.
  + Scrivi un file chiamato `imagedefinitions.json` nella build root che contenga il nome del contenitore del servizio Amazon ECS, l'immagine e il tag. La fase di distribuzione della pipeline di distribuzione utilizza queste informazioni per creare una nuova revisione della definizione di attività del servizio, quindi aggiorna il servizio per utilizzare la nuova definizione di attività. Il file `imagedefinitions.json` è richiesto per l'esecutore del processo ECS.

Incolla questo testo di esempio per creare il `buildspec.yml` file e sostituisci i valori per la definizione dell'immagine e dell'attività. Questo testo utilizza l'ID di account di esempio 111122223333.

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json
```

La specifica di build è stata scritta per la definizione di attività di esempio fornita in[Prerequisiti](#ecs-cd-prereqs), utilizzata dal servizio Amazon ECS per questo tutorial. Il valore `REPOSITORY_URI` corrisponde all'archivio `image` (senza tag di immagini); il valore `hello-world` alla fine del file corrisponde al nome del container nella definizione di attività del servizio. 

**Aggiunta di un file `buildspec.yml` nell'archivio di codice sorgente**

1. Apri un editor di testo e copia e incolla la specifica di compilazione riportata in alto in un nuovo file.

1. Sostituisci il `REPOSITORY_URI` valore (`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`) con l'URI del tuo repository Amazon ECR (senza tag di immagine) per la tua immagine Docker. Sostituisci `hello-world` con il nome del container della definizione di attività del servizio riferito all'immagine Docker.

1. Conferma e inserisci il file `buildspec.yml` nell'archivio del codice sorgente.

   1. Aggiungi il file.

      ```
      git add .
      ```

   1. Conferma la modifica.

      ```
      git commit -m "Adding build specification."
      ```

   1. Invia la conferma.

      ```
      git push
      ```

## Fase 2: creazione della pipeline di distribuzione continua
<a name="pipeline-wizard"></a>

Utilizza la CodePipeline procedura guidata per creare le fasi della pipeline e connettere il repository di origine al servizio ECS.

**Creazione della pipeline**

1. Apri la console all'indirizzo. CodePipeline [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

1. Nella pagina **Welcome** (Benvenuto), seleziona **Create pipeline** (Crea pipeline). 

   **Se è la prima volta che lo usi CodePipeline, viene visualizzata una pagina introduttiva anziché Benvenuto.** Scegliere **Get Started Now** (Inizia subito).

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della pipeline**, digitate il nome della pipeline. Per questo tutorial, il nome della pipeline è **hello-world**.

1. **In **Pipeline type**, mantieni la selezione predefinita su V2.** I tipi di tubazioni differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md). Scegli **Next (Successivo)**.

1. Nella **fase 3: Aggiungi la pagina della fase di origine**, per **Provider di origine**, scegli ** AWS CodeCommit**.

   1. In **Repository name (Nome archivio)**, seleziona il nome dell'archivio CodeCommit da utilizzare come ubicazione di origine della pipeline.

   1. In **Branch name (Nome ramo)**, seleziona il ramo da utilizzare e seleziona **Next (Fase successiva)**.

1. **Nella pagina Step 4: Aggiungi la fase** di compilazione, per **Build provider** scegli **AWS CodeBuild**, quindi scegli **Crea progetto**.

   1. In **Project name** (Nome progetto), scegli un nome univoco per il progetto di compilazione. Per questo tutorial, il nome della progetto è **hello-world**.

   1. Per **Environment image (Immagine ambiente)**, scegliere **Managed image (Immagine gestita)**.

   1. Per **Operating system (Sistema operativo)**, scegliere **Amazon Linux 2**.

   1. In **Runtime(s) (Runtime)**, seleziona **Standard**.

   1. Per **Immagine**, scegli **`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**.

   1. Per la **Image version (Versione immagine)** e **Environment type (Tipo di ambiente)**, utilizzare i valori predefiniti.

   1. Seleziona **Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Abilita questo flag se desideri creare immagini Docker o se desideri che le build ottengano privilegi elevati)**.

   1. Deseleziona i **CloudWatch registri**. **Potrebbe essere necessario espandere Advanced.**

   1. Scegli **Continua con CodePipeline**.

   1. Scegli **Next (Successivo)**.
**Nota**  
La procedura guidata crea un ruolo di CodeBuild servizio per il tuo progetto di compilazione, chiamato **codebuild- *build-project-name* -service-role**. Prendi nota di questo nome di ruolo, man mano che aggiungerai le autorizzazioni Amazon ECR in un secondo momento.

1. Nella pagina **Fase 5: Aggiungi fase di distribuzione**, per **provider di distribuzione**, scegli **Amazon ECS**.

   1. Per **il nome del cluster**, scegli il cluster Amazon ECS in cui è in esecuzione il tuo servizio. Per questo tutorial, il cluster è **predefinito**.

   1. In **Service name (Nome del servizio)**, scegli il servizio da aggiornare, quindi seleziona **Next (Fase successiva)**. Per questo tutorial, il nome del servizio è **hello-world**.

1. Nella pagina **Step 6: Review** (Fase 6: esamina), esamina la configurazione della pipeline, quindi seleziona **Create pipeline** (Crea pipeline) per creare la pipeline.
**Nota**  
Ora che la pipeline è stata creata, tenta l'esecuzione tramite le varie fasi della pipeline. Tuttavia, il CodeBuild ruolo predefinito creato dalla procedura guidata non dispone delle autorizzazioni per eseguire tutti i comandi contenuti nel `buildspec.yml` file, quindi la fase di compilazione fallisce. La sezione successiva aggiunge le autorizzazioni necessarie per la fase di compilazione.

## Fase 3: aggiungere le autorizzazioni Amazon ECR al ruolo CodeBuild
<a name="code-build-perms"></a>

La CodePipeline procedura guidata ha creato un ruolo IAM per il progetto di compilazione, chiamato CodeBuild **codebuild** - -service-role. *build-project-name* **Per questo tutorial, il nome è -role. codebuild-hello-world-service** Poiché il `buildspec.yml` file effettua chiamate alle operazioni dell'API Amazon ECR, il ruolo deve disporre di una policy che consenta le autorizzazioni per effettuare queste chiamate Amazon ECR. La procedura seguente consente di collegare al ruolo le autorizzazioni appropriate.

**Per aggiungere le autorizzazioni Amazon ECR al ruolo CodeBuild**

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

1. Nel pannello di navigazione a sinistra, seleziona **Ruoli**.

1. Nella casella di ricerca, digita **codebuild-** e scegli il ruolo creato dalla procedura guidata. CodePipeline **Per questo tutorial, il nome del ruolo è codebuild-hello-world-service -role.**

1. Nella pagina **Summary (Riepilogo)**, seleziona **Attach policy (Collega policy)**.

1. Seleziona la casella a sinistra della EC2 ContainerRegistryPowerUser politica di **Amazon** e scegli **Allega politica**.

## Fase 4: test della pipeline
<a name="commit-change"></a>

La tua pipeline dovrebbe avere tutto il necessario per eseguire una distribuzione AWS continua end-to-end nativa. Ora, testane la funzionalità inserendo una modifica del codice all'archivio del codice sorgente.

**Test della pipeline**

1. Effettua una modifica del codice nell'archivio del codice sorgente configurato, conferma e inserisci la modifica.

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleziona la pipeline nell'elenco.

1. Osserva l'avanzamento della pipeline attraverso le varie fasi. La pipeline dovrebbe essere completata e il servizio Amazon ECS esegue l'immagine Docker creata dalla modifica del codice.

# Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy
<a name="tutorials-ecs-ecr-codedeploy"></a>

In questo tutorial, configuri una pipeline AWS CodePipeline che distribuisce applicazioni container utilizzando una blue/green distribuzione che supporta le immagini Docker. In una distribuzione blu/verde, è possibile avviare la nuova versione dell'applicazione insieme alla versione precedente e testare la nuova versione prima di reindirizzare il traffico. Puoi anche monitorare il processo di distribuzione ed eseguire rapidamente il rollback in caso di problemi.

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

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

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

La pipeline è inoltre configurata per utilizzare una posizione di origine CodeCommit, ad esempio dove è archiviata la definizione delle attività di Amazon ECS. In questo tutorial, configurerai ognuna di queste AWS risorse e poi creerai la tua pipeline con fasi che contengono azioni per ogni risorsa.

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

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

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

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

**Topics**
+ [

## Prerequisiti
](#tutorials-ecs-ecr-codedeploy-prereq)
+ [

## Fase 1: creare un'immagine e inviarla a un repository Amazon ECR
](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [

## Fase 2: Creare la definizione delle attività e i file AppSpec sorgente e inviarli a un repository CodeCommit
](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [

## Fase 3: creazione dell'Application Load Balancer e dei gruppi di destinazione
](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [

## Fase 4: crea il cluster e il servizio Amazon ECS
](#tutorials-ecs-ecr-codedeploy-cluster)
+ [

## Fase 5: Crea CodeDeploy l'applicazione e il gruppo di distribuzione (piattaforma di calcolo ECS)
](#tutorials-ecs-ecr-codedeploy-deployment)
+ [

## Fase 6: creazione della pipeline
](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [

## Fase 7: modifica della pipeline e verifica della distribuzione
](#tutorials-ecs-ecr-codedeploy-update)

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

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

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

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

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

**Come creare un’immagine**

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

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

   ```
   docker pull nginx
   ```

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

   ```
   docker images
   ```

**Per creare un repository Amazon ECR e inviare la tua immagine**

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

   ```
   aws ecr create-repository --repository-name nginx
   ```

   Output:

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

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

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

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

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

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

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

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

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

**Per creare una definizione di attività per l'immagine**

1. Crea un file denominato `taskdef.json` con i seguenti contenuti. Per `image`, immetti il nome dell'immagine, ad esempio nginx. Tale valore viene aggiornato quando la pipeline viene eseguita.
**Nota**  
Assicurati che il ruolo di esecuzione specificato nella definizione dell'attività contenga `AmazonECSTaskExecutionRolePolicy`. Per ulteriori informazioni, consulta [Amazon ECS Task Execution IAM Role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) nella *Amazon ECS Developer Guide.*

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

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

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

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

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

**Per creare un file AppSpec**
+ Il AppSpec file viene utilizzato per le CodeDeploy distribuzioni. Il file, che comprende campi opzionali, utilizza questo formato:

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

  Per ulteriori informazioni sul AppSpec file, inclusi esempi, vedere [CodeDeploy AppSpec File](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) Reference.

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

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

**Per inviare file al tuo CodeCommit repository**

1. Invia o carica i file nel tuo CodeCommit repository. Questi file sono l'artefatto di origine creato dalla procedura guidata **Create pipeline (Crea pipeline)** per l'operazione di distribuzione in CodePipeline. I file dovrebbero avere questo aspetto nella directory locale:

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

1. Scegli un metodo per caricare i file:

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

      1. Cambia le directory nel repository locale:

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

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

         ```
         git add -A
         ```

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

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

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

         ```
         git push
         ```

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

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

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

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

      1. Ripeti questa fase per ogni file da caricare.

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

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

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

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

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

1. Scegli **Subnets (Sottoreti)**. Scegli due sottoreti che mostrano **Yes (Sì)** nella colonna **Default subnet (Sottorete predefinita)**.
**Nota**  
Prendi nota della tua sottorete IDs. Saranno necessari più avanti in questo tutorial.

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

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

**Per creare un Application Load Balancer di Amazon EC2**

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

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

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

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

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

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

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

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

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

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

   1. In **Load Balancer Protocol (Protocollo del sistema di bilanciamento del carico)** per il secondo listener, scegli **HTTP**. In **Load Balancer Port (Porta del sistema di bilanciamento del carico)**, immettere **8080**.

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

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

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

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

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

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

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

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

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

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

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

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

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

1. Scegliere **Crea gruppo target**.

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

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

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

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

1. Scegli **Create** (Crea).
**Nota**  
È necessario disporre di due gruppi di destinazione creati per il sistema di bilanciamento del carico affinché la distribuzione si avvii. È necessario solo annotare l'ARN del primo gruppo di destinazione. Questo ARN è utilizzato nel file JSON `create-service` nella prossima fase.

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

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

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

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

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

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

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

**Come creare un cluster Amazon ECS**

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

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

1. Scegli **Crea cluster**.

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

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

**Per creare un servizio Amazon ECS**

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

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

   Per il `taskDefinition` campo, quando registri una definizione di attività in Amazon ECS, le dai una famiglia. L'operazione è analoga a un nome per più versioni della definizione di attività, specificato con un numero di revisione. In questo esempio, utilizza "`ecs-demo:1`" per la famiglia e il numero di revisione nel file. Utilizzare i nomi di sottorete, il gruppo di sicurezza e il valore del gruppo di destinazione creati con il sistema di bilanciamento del carico in [Fase 3: creazione dell'Application Load Balancer e dei gruppi di destinazione](#tutorials-ecs-ecr-codedeploy-loadbal).
**Nota**  
È necessario includere l'ARN del gruppo di destinazione in questo file. **Apri la console Amazon EC2 e dal pannello di navigazione, in **LOAD BALANCING**, scegli Target Groups.** Scegli il primo gruppo di destinazione. Copia l'ARN dalla scheda **Description (Descrizione)**.

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

1. Esegui il comando **create-service** e specifica il file JSON:
**Importante**  
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.

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

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

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

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

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

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

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

**Per creare CodeDeploy un'applicazione**

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

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

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

1. Scegli **Crea applicazione**.

**Per creare un gruppo CodeDeploy di distribuzione**

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

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

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

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

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

   1. Scegli **Crea ruolo**.

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

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

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

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

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

1. Da **Production listener port (Porta del listener di produzione)**, scegli la porta e il protocollo per il listener che serve il traffico di produzione al servizio Amazon ECS. Da **Test listener port (Porta listener test)**, scegli la porta e il protocollo per il listener test.

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

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

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

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

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

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

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

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

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

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

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

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

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **AWS CodeCommit**. In **Repository name (Nome repository)**, scegliere il nome del repository CodeCommit creato in [Passaggio 1: crea un CodeCommit repository](tutorials-simple-codecommit.md#codecommit-create-repository). In **Branch name (Nome ramo)**, scegliere il nome del ramo che contiene l'aggiornamento di codice più recente.

   Scegli **Next (Successivo)**.

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

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di implementazione**:

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

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

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

   1. In **AWS CodeDeploy AppSpec File**, scegli **SourceArtifact**. Nel campo, immetti **appspec.yaml**.
**Nota**  
In questa fase, non immettere nessuna informazione in **Dynamically update task definition image (Aggiorna dinamicamente l'immagine di definizione dell'attività)**.

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

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

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

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

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

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

1. Aggiungi un'azione parallela selezionando **\$1 Aggiungi azione** accanto all'azione CodeCommit sorgente.

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

1. In **Action provider (Provider operazione)**, scegli **Amazon ECR**.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ECR-source-action.png)

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

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

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

1. Scegli **Save (Salva)** nella schermata dell'operazione. Scegli **Done (Fatto)** nella schermata della fase. Scegli **Save (Salva)** nella pipeline. Un messaggio mostra la regola Amazon CloudWatch Events da creare per l'azione sorgente di Amazon ECR.

**Per collegare gli artefatti di origine all'operazione di distribuzione**

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

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

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

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

1. In **Aggiorna dinamicamente l'immagine di definizione dell'attività**, in **Input Artifact with Image** URI, **MyImage**scegli, quindi inserisci il testo segnaposto utilizzato nel file:. `taskdef.json` ** IMAGE1\$1NAME** Scegli **Save** (Salva).

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

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

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

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

1. Scegli l'azione di distribuzione in cui visualizzarla CodeDeploy e vedere l'avanzamento dello spostamento del traffico.
**Nota**  
È possibile che venga visualizzato un passaggio di distribuzione che mostra un tempo di attesa opzionale. Per impostazione predefinita, CodeDeploy attende un'ora dopo una corretta distribuzione prima di terminare il set di attività originale. È possibile utilizzare questo tempo per ripristinare o terminare l'attività. La distribuzione viene completata al termine del set di attività.

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

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

# Tutorial: creazione di una pipeline che distribuisce una competenza Amazon Alexa
<a name="tutorials-alexa-skills-kit"></a>

In questo tutorial, è possibile configurare una pipeline che distribuisce in modo continuo le competenze Alexa utilizzando Alexa Skills Kit come provider di operazioni di distribuzione nella fase di distribuzione. La pipeline completata rileva le modifiche alla competenza quando si modificano i file di origine nel repository di origine. La pipeline usa quindi Alexa Skills Kit per distribuire alla fase di sviluppo di competenze Alexa.

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

**Nota**  
Questa funzionalità non è disponibile nella regione Asia Pacifico (Hong Kong) o Europa (Milano). Per utilizzare altre azioni di distribuzione disponibili in quella regione, vedi[Integrazioni di operazioni di distribuzione](integrations-action-type.md#integrations-deploy).

Per creare un'abilità personalizzata come funzione Lambda, consulta [Ospitare un'abilità personalizzata come funzione Lambda AWS](https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html). Puoi anche creare una pipeline che utilizza i file sorgente Lambda e CodeBuild un progetto per implementare le modifiche a Lambda per le tue competenze.

## Prerequisiti
<a name="tutorials-alexa-skills-kit-prereq"></a>

Devi avere già quanto segue:
+ Un repository. CodeCommit È possibile utilizzare il AWS CodeCommit repository in cui è stato creato. [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)
+ Un account sviluppatore Amazon. Questo è l'account che possiede le competenze Alexa. È possibile creare un account gratuitamente nell'[Alexa Skills Kit](https://developer.amazon.com/alexa-skills-kit). 
+ Una competenza Alexa. È possibile creare una competenza di esempio utilizzando il tutorial [Ottieni il codice di esempio per competenze personalizzate](https://developer.amazon.com/docs/custom-skills/use-the-alexa-skills-kit-samples.html).
+ Installa la CLI ASK e configurala utilizzando le tue `ask init` AWS credenziali. Consulta [Installazione e inizializzazione di ASK CLI](https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize).

## Fase 1: creazione di un profilo di sicurezza LWA Alexa Developer Services
<a name="tutorials-alexa-skills-kit-profile"></a>

In questa sezione crei un profilo di sicurezza da usare con Login with Amazon (LWA). Se hai già un profilo, questa fase può essere ignorata.
+ Utilizza le istruzioni [generate-lwa-tokens](https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens) per creare un profilo di sicurezza.
+ Dopo aver creato il profilo, annotare il **Client ID (ID client)** e il **Client Secret (Segreto client)**.
+ Assicurati di inserire la **restituzione consentita URLs** come indicato nelle istruzioni. URLs Consenti al comando ASK CLI di reindirizzare le richieste di token di aggiornamento.

## Passaggio 2: crea i file sorgente delle abilità Alexa e inviali al tuo repository CodeCommit
<a name="tutorials-alexa-skills-kit-push"></a>

In questa sezione, è possibile creare e inviare i file di origine di competenza Alexa nel repository che la pipeline impiega per la fase di origine. Per la competenza creata nella console per sviluppatori di Amazon, devi produrre e inviare quanto segue: 
+ Un file `skill.json`.
+ Una cartella `interactionModel/custom`.
**Nota**  
Questa struttura di directory è conforme ai requisiti del formato dei pacchetti di skill di Alexa Skills Kit, come descritto in [Formato del pacchetto di competenze](https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format). Se la struttura di directory non utilizza il formato dei pacchetti di skill corretto, le modifiche non vengono distribuite correttamente alla console Alexa Skills Kit.

**Per creare file di origine per la competenza**

1. Recupera l'ID competenza dalla console per sviluppatori Alexa Skills Kit. Usa questo comando:

   ```
   ask api list-skills
   ```

   Individua la competenza in base al nome e copia il relativo ID nel campo `skillId`.

1. Genera un file `skill.json` che contiene i dettagli della competenza. Usa questo comando:

   ```
   ask api get-skill -s skill-ID > skill.json
   ```

1. (Facoltativo) Crea una cartella `interactionModel/custom`.

   Utilizza questo comando per generare il file del modello di interazione all'interno della cartella. Come impostazione, questo tutorial utilizza en-US come lingua locale nel nome del file.

   ```
   ask api get-model --skill-id skill-ID --locale locale >
       ./interactionModel/custom/locale.json
   ```

**Per inviare file al tuo repository CodeCommit**

1. Invia o carica i file nel tuo CodeCommit repository. Questi file sono l'artefatto di origine creato dalla procedura guidata **Create Pipeline (Crea pipeline)** per l'operazione di distribuzione in AWS CodePipeline. I file dovrebbero avere questo aspetto nella directory locale:

   ```
   skill.json
   /interactionModel
     /custom
       |en-US.json
   ```

1. Scegli un metodo per caricare i file:

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

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

         ```
         git add -A
         ```

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

         ```
         git commit -m "Added Alexa skill files"
         ```

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

         ```
         git push
         ```

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

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

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

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

      1. Ripeti questa fase per ogni file da caricare.

## Fase 3: utilizzo dei comandi ASK CLI per creare un token di aggiornamento
<a name="tutorials-alexa-skills-kit-token"></a>

CodePipeline utilizza un token di aggiornamento basato sull'ID cliente e sul segreto nel tuo account sviluppatore Amazon per autorizzare le azioni che esegue per tuo conto. In questa sezione, è possibile utilizzare l'interfaccia a riga di comando ASK per creare il token. Usa queste credenziali quando utilizzi la procedura guidata **Create Pipeline (Crea pipeline)**.

**Per creare un token di aggiornamento con le credenziali dell'account sviluppatore Amazon**

1. Utilizza il seguente comando: 

   ```
   ask util generate-lwa-tokens
   ```

1. Quando richiesto, immetti l'ID e il segreto client come illustrato in questo esempio: 

   ```
   ? Please type in the client ID: 
   amzn1.application-client.example112233445566
   ? Please type in the client secret:
   example112233445566
   ```

1. Viene visualizzata la pagina di accesso del browser. Accedi con le credenziali dell'account sviluppatore Amazon.

1. Torna alla schermata della riga di comando. Il token di accesso e di aggiornamento vengono generati nell'output. Copia il token di aggiornamento restituito nell'output.

## Fase 4: creazione della pipeline
<a name="tutorials-alexa-skills-kit-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un' CodeCommit azione in cui gli artefatti di origine sono i file delle abilità di Alexa che supportano la tua abilità.
+ Una fase di distribuzione con un'operazione di distribuzione Alexa Skills Kit.

**Per creare una pipeline con la procedura guidata**

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

1. Scegli la AWS regione in cui desideri creare il progetto e le relative risorse. Il runtime delle competenze Alexa è disponibile solo nelle seguenti regioni:
   + Asia Pacifico (Tokyo)
   + Europa (Irlanda)
   + Stati Uniti orientali (Virginia settentrionale)
   + Stati Uniti occidentali (Oregon)

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyAlexaPipeline**

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

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

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **AWS CodeCommit**. In **Nome archivio**, scegli il nome del CodeCommit repository in cui hai creato. [Passaggio 1: crea un CodeCommit repository](tutorials-simple-codecommit.md#codecommit-create-repository) In **Branch name (Nome ramo)**, scegliere il nome del ramo che contiene l'aggiornamento di codice più recente.

   Dopo aver selezionato il nome del repository e il ramo, un messaggio mostra la regola Amazon CloudWatch Events da creare per questa pipeline. 

   Scegli **Next (Successivo)**.

1. **Nel **passaggio 4: aggiungi la fase di creazione**, scegli **Ignora fase di compilazione**, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.**

   Scegli **Next (Successivo)**.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di implementazione**:

   1. In **Deploy provider (Provider di distribuzione)**, scegli **Alexa Skills Kit**. 

   1. In **Alexa skill ID (ID competenza Alexa)**, immetti l'ID competenza assegnato alla tua competenza nella console per sviluppatori Alexa Skills Kit.

   1. In **Client ID (ID client)**, immetti l'ID dell'applicazione registrata.

   1. In **Client secret (Segreto client)**, immetti il segreto scelto al momento della registrazione.

   1. In **Refresh token (Token di aggiornamento)**, immetti il token generato alla fase 3.  
![\[Passaggio 6: Distribuisci la pagina per un'azione dell'Alexa Skills Kit\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/alexa-deploy.png)

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

1. Nel **Passaggio 7: esamina**, rivedi le informazioni, quindi scegli **Crea** pipeline.

## Fase 5: modifica di un file di origine e verifica della distribuzione
<a name="tutorials-alexa-skills-kit-update"></a>

Modifica la competenza e applica la modifica al repository. In questo modo viene attivata la pipeline per l'esecuzione. Verifica che la competenza sia aggiornata nella [console per sviluppatori Alexa Skills Kit](https://developer.amazon.com/alexa/console/ask).

# Tutorial: crea una pipeline che utilizzi Amazon S3 come provider di distribuzione
<a name="tutorials-s3deploy"></a>

In questo tutorial, configuri una pipeline che distribuisce continuamente file utilizzando Amazon S3 come provider di azioni di distribuzione nella fase di distribuzione. La pipeline completata rileva le modifiche quando si modificano i file di origine nel repository di origine. La pipeline utilizza quindi Amazon S3 per distribuire i file nel bucket. Ogni volta che modifichi o aggiungi i file del tuo sito Web nella posizione di origine, la distribuzione crea il sito Web con i file più recenti. 

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

**Nota**  
Anche se elimini file dal repository di origine, l'azione di distribuzione di S3 non elimina gli oggetti S3 corrispondenti ai file eliminati.

Questo tutorial offre due opzioni:
+ Crea una pipeline che consente di distribuire un sito Web statico al bucket pubblico S3. Questo esempio crea una pipeline con un'azione di AWS CodeCommit origine e un'azione di distribuzione di Amazon S3. Per informazioni, consulta [Opzione 1: distribuire file statici di siti Web su Amazon S3](#tutorials-s3deploy-acc).
+ Crea una pipeline che compili il TypeScript codice di esempio JavaScript e distribuisca l'artefatto di CodeBuild output nel bucket S3 per l'archiviazione. Questo esempio crea una pipeline con un'azione di origine di Amazon S3, CodeBuild un'azione di compilazione e un'azione di distribuzione di Amazon S3. Per informazioni, consulta [Opzione 2: distribuzione di file di archivio integrati su Amazon S3 da un bucket di origine S3](#tutorials-s3deploy-s3source).

**Importante**  
Molte delle azioni che aggiungi alla tua pipeline in questa procedura coinvolgono AWS risorse che devi creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

## Opzione 1: distribuire file statici di siti Web su Amazon S3
<a name="tutorials-s3deploy-acc"></a>

In questo esempio, scarichi il file modello di sito web statico di esempio, carichi i file nel tuo AWS CodeCommit repository, crei il tuo bucket e lo configuri per l'hosting. Successivamente, usi la AWS CodePipeline console per creare la pipeline e specificare una configurazione di distribuzione di Amazon S3.

### Prerequisiti
<a name="tutorials-s3deploy-acc-prereq"></a>

Devi avere già quanto segue:
+ Un CodeCommit repository. Puoi usare il AWS CodeCommit repository in cui hai creato. [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)
+ I file di origine per il sito Web statico. Utilizza questo collegamento per scaricare un [sito Web statico di esempio](samples/sample-website.zip). Il download di sample-website.zip produce i file seguenti: 
  + Un file `index.html`
  + Un file `main.css`
  + Un file `graphic.jpg`
+ Un bucket S3 configurato per l'hosting di siti Web. Consulta [Hosting di un sito Web statico su Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html). Accertati di creare il bucket nella stessa regione della pipeline.
**Nota**  
Per ospitare un sito Web, il bucket deve disporre di accesso in lettura pubblico, che consente a tutti di avere l'accesso in lettura. Fatta eccezione per l'hosting di siti Web, è consigliabile mantenere le impostazioni predefinite di accesso che bloccano l'accesso pubblico ai bucket S3.

### Passaggio 1: invia i file sorgente al tuo repository CodeCommit
<a name="tutorials-s3deploy-acc-push"></a>

In questa sezione, effettua il push dei file di origine al repository che la pipeline impiega per la fase di origine.

**Per inviare file al tuo repository CodeCommit**

1. Estrai i file di esempio scaricati. Non caricare il file ZIP nel repository.

1. Invia o carica i file nel tuo CodeCommit repository. Questi file sono l'artefatto di origine creato dalla procedura guidata **Create Pipeline (Crea pipeline)** per l'operazione di distribuzione in CodePipeline. I file dovrebbero avere questo aspetto nella directory locale:

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. Puoi usare Git o la CodeCommit console per caricare i tuoi file:

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

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

         ```
         git add -A
         ```

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

         ```
         git commit -m "Added static website files"
         ```

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

         ```
         git push
         ```

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

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

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

      1. Seleziona **Choose file (Scegli file)** e vai al file. Conferma la modifica inserendo il tuo nome utente e indirizzo e-mail. Scegliere **Commit changes (Applica modifiche)**.

      1. Ripeti questa fase per ogni file da caricare.

### Fase 2: creazione della pipeline
<a name="tutorials-s3deploy-acc-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un' CodeCommit azione in cui gli artefatti di origine sono i file del tuo sito web.
+ Una fase di distribuzione con un'azione di distribuzione di Amazon S3.

**Per creare una pipeline con la procedura guidata**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyS3DeployPipeline**

1. **In **Tipo di tubazione**, scegliete V2.** Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md). Scegli **Next (Successivo)**.

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

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **AWS CodeCommit**. In **Repository name (Nome repository)**, scegliere il nome del repository CodeCommit creato in [Passaggio 1: crea un CodeCommit repository](tutorials-simple-codecommit.md#codecommit-create-repository). In **Branch name (Nome ramo)**, scegliere il nome del ramo che contiene l'aggiornamento di codice più recente. Se l'utente non ha creato personalmente un ramo diverso, è disponibile solo `main`. 

   Dopo aver selezionato il nome e il ramo del repository, viene visualizzata la regola Amazon CloudWatch Events da creare per questa pipeline. 

   Scegli **Next (Successivo)**.

1. **Nel **passaggio 4: aggiungi la fase di creazione**, scegli **Ignora fase di creazione**, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** 

   Scegli **Next (Successivo)**.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di implementazione**:

   1. In **Deploy provider (Provider di distribuzione)**, scegli **Amazon S3**. 

   1. In **Bucket**, inserisci il nome del bucket pubblico.

   1. Seleziona **Extract file before deploy (Estrai file prima di distribuire)**.
**Nota**  
La distribuzione non riesce se non selezioni **Estrai il file prima di distribuire** Questo perché l' AWS CodeCommit azione nella pipeline comprime gli artefatti di origine e il file è un file ZIP.

      Quando **Extract file before deploy (Estrai file prima di distribuire)** è selezionato, viene visualizzato **Deployment path (Percorso di distribuzione)**. Inserisci il nome del percorso che vuoi utilizzare. Questo crea una struttura di cartelle in Amazon S3 in cui vengono estratti i file. Per questo tutorial, lascia questo campo vuoto.  
![\[Passaggio 6: aggiungere la pagina della fase di distribuzione per un'azione di distribuzione di S3 con un'origine AWS CodeCommit\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-codecommit.png)

   1. (Facoltativo) In **Canned ACL (ACL predefinita)**, puoi applicare un set di concessioni predefinite, note come [ACL predefinita](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl), agli artefatti caricati. 

   1. (Facoltativo) In **Cache control (Controllo cache)**, immetti i parametri della memorizzazione nella cache. Con questa impostazione puoi controllare il comportamento della memorizzazione nella cache per le richieste/risposte. Per i valori validi, vedi il campo di intestazione [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) per le operazioni HTTP.

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

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

1. Una volta eseguita correttamente la pipeline, apri la console Amazon S3 e verifica che i file vengano visualizzati nel bucket pubblico come mostrato:

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. Accedi all'endpoint per testare il sito Web. L'endpoint segue questo formato: `http://bucket-name.s3-website-region.amazonaws.com/`.

   Endpoint di esempio: `http://my-bucket.s3-website-us-west-2.amazonaws.com/` 

   Viene visualizzata la pagina Web di esempio.

### Fase 3: modifica di un file di origine e verifica della distribuzione
<a name="tutorials-s3deploy-acc-update"></a>

Modifica i file di origine e applica la modifica al repository. In questo modo viene attivata la pipeline per l'esecuzione. Verifica che il sito Web sia aggiornato.

## Opzione 2: distribuzione di file di archivio integrati su Amazon S3 da un bucket di origine S3
<a name="tutorials-s3deploy-s3source"></a>

In questa opzione, i comandi di compilazione in fase di compilazione compilano il TypeScript codice in JavaScript codice e distribuiscono l'output nel bucket di destinazione S3 in una cartella separata con data e ora. Innanzitutto, create il codice e un file buildspec.yml. TypeScript Dopo aver combinato i file di origine in un file ZIP, caricate il file ZIP di origine nel bucket di origine S3 e utilizzate una CodeBuild fase per distribuire un file ZIP dell'applicazione creato nel bucket di destinazione S3. Il codice compilato viene conservato come un archivio nel bucket di destinazione.

### Prerequisiti
<a name="tutorials-s3deploy-s3source-prereq"></a>

Devi avere già quanto segue:
+ Un bucket di origine S3. Puoi usare il bucket creato in [Tutorial: creazione di una semplice pipeline (bucket S3)](tutorials-simple-s3.md).
+ Un bucket di destinazione S3. Consulta [Hosting di un sito Web statico su Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html). Assicurati di creare il bucket nella stessa Regione AWS pipeline che desideri creare.
**Nota**  
In questo esempio viene illustrata la distribuzione dei file in un bucket privato. Non abilitare il bucket di destinazione per l'hosting di siti Web o collegare policy che rendono il bucket pubblico.

### Fase 1: creazione e caricamento dei file di origine nel bucket di origine S3
<a name="tutorials-s3deploy-s3source-upload"></a>

In questa sezione, è possibile creare e caricare i file di origine nel bucket che la pipeline impiega per la fase di origine. Questa sezione include istruzioni per creare i seguenti file di origine:
+ Un `buildspec.yml` file, che viene utilizzato per CodeBuild creare progetti.
+ Un file `index.ts`. 

**Per creare un file buildspec.yml**
+ Crea un file denominato `buildspec.yml` con i seguenti contenuti. Questi comandi di compilazione installano TypeScript e utilizzano il TypeScript compilatore per riscrivere il codice in `index.ts` codice. JavaScript

  ```
  version: 0.2
  
  phases:
    install:
      commands:
        - npm install -g typescript
    build:
      commands:
        - tsc index.ts
  artifacts:
    files:
      - index.js
  ```

**Per creare un file index.ts**
+ Crea un file denominato `index.ts` con i seguenti contenuti.

  ```
  interface Greeting {
      message: string;
  }
  
  class HelloGreeting implements Greeting {
      message = "Hello!";
  }
  
  function greet(greeting: Greeting) {
      console.log(greeting.message);
  }
  
  let greeting = new HelloGreeting();
  
  greet(greeting);
  ```

**Per caricare i file nel bucket di origine S3**

1. I file dovrebbero avere questo aspetto nella directory locale:

   ```
   buildspec.yml
   index.ts
   ```

   Comprimi i file e assegna al file il nome `source.zip`.

1. **Nella console Amazon S3, per il tuo bucket di origine, scegli Upload.** Scegli **Add files (Aggiungi file)**, quindi individua il file ZIP creato.

1.  Scegli **Carica**. Questi file sono l'artefatto di origine creato dalla procedura guidata **Create Pipeline (Crea pipeline)** per l'operazione di distribuzione in CodePipeline. Il file dovrebbe avere questo aspetto nel bucket:

   ```
   source.zip
   ```

### Fase 2: creazione della pipeline
<a name="tutorials-s3deploy-s3source-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un'azione Amazon S3 in cui gli artefatti di origine sono i file per l'applicazione scaricabile.
+ Una fase di distribuzione con un'azione di distribuzione di Amazon S3.

**Per creare una pipeline con la procedura guidata**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyS3DeployPipeline**

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

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **Amazon S3**. In **Bucket**, scegli il nome del bucket di origine. In **S3 object key (Chiave oggetto S3)**, inserisci il nome del file ZIP di origine. Assicurati di includere l'estensione del file.zip.

   Scegli **Next (Successivo)**.

1. Nel **passaggio 4: aggiungi la fase di compilazione**:

   1. In **Build provider (Provider compilazione)**, scegli **CodeBuild**.

   1. Scegliere **Create build project (Crea progetto di compilazione)**. Nella pagina **Create project (Crea progetto)**:

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment (Ambiente)**, scegliere **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. **Per la **versione Runtime**, scegliere:1.0aws/codebuild/standard.**

   1. In **Image version (Versione immagine)**, scegli **Always use the latest image for this runtime version (Usa sempre l'immagine più recente per questa versione di runtime)**.

   1. Per **Ruolo di servizio, scegli il tuo ruolo** di CodeBuild servizio o creane uno.

   1. Per **Build specifications (Compila specifiche)**, scegli **Use a buildspec file (Usa un file buildspec)**.

   1. Scegli **Continua a CodePipeline**. Viene visualizzato un messaggio se il progetto è stato creato correttamente.

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

1. Nel **passaggio 5: aggiungi la fase di distribuzione**:

   1. In **Deploy provider (Provider di distribuzione)**, scegli **Amazon S3**. 

   1. In **Bucket**, inserisci il nome del bucket di destinazione S3.

   1. Assicurati che **Extract file before deploy (Estrai file prima di distribuire)** sia deselezionato.

      Quando **Extract file before deploy (Estrai file prima di distribuire)** è deselezionato, viene visualizzato **S3 object key (Chiave oggetto S3)**. Inserisci il nome del percorso che vuoi utilizzare: `js-application/{datetime}.zip`.

      Questo crea una `js-application` cartella in Amazon S3 in cui vengono estratti i file. In questa cartella, la variabile `{datetime}` crea un timestamp su ciascun file di output quando la pipeline viene eseguita.  
![\[Fase 5: pagina di distribuzione per un'azione di distribuzione di Amazon S3 con un'origine Amazon S3\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-s3source.png)

   1. (Facoltativo) In **Canned ACL (ACL predefinita)**, puoi applicare un set di concessioni predefinite, note come [ACL predefinita](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl), agli artefatti caricati. 

   1. (Facoltativo) In **Cache control (Controllo cache)**, immetti i parametri della memorizzazione nella cache. Con questa impostazione puoi controllare il comportamento della memorizzazione nella cache per le richieste/risposte. Per i valori validi, vedi il campo di intestazione [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) per le operazioni HTTP.

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

1. **Nel **passaggio 6: esamina, esamina** le informazioni, quindi scegli Crea pipeline.**

1. Una volta eseguita correttamente la pipeline, visualizza il bucket nella console Amazon S3. Verifica che il file ZIP distribuito sia visualizzato nel bucket di destinazione nella cartella `js-application`. Il JavaScript file contenuto nel file ZIP dovrebbe essere. `index.js` Il file `index.js` contiene il seguente output:

   ```
   var HelloGreeting = /** @class */ (function () {
       function HelloGreeting() {
           this.message = "Hello!";
       }
       return HelloGreeting;
   }());
   function greet(greeting) {
       console.log(greeting.message);
   }
   var greeting = new HelloGreeting();
   greet(greeting);
   ```

### Fase 3: modifica di un file di origine e verifica della distribuzione
<a name="tutorials-s3deploy-s3source-update"></a>

Modifica i file di origine e caricali nel bucket di origine. In questo modo viene attivata la pipeline per l'esecuzione. Visualizza il bucket di destinazione e verifica che i file di output distribuiti siano disponibili nella cartella `js-application` come illustrato:

![\[Download dello ZIP di esempio\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/tutorial-s3deploy-pipeline-appzip.png)


# Tutorial: crea una pipeline che pubblichi la tua applicazione serverless su AWS Serverless Application Repository
<a name="tutorials-serverlessrepo-auto-publish"></a>

Puoi utilizzarla AWS CodePipeline per fornire continuamente la tua applicazione AWS SAM serverless a. AWS Serverless Application Repository

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

Questo tutorial mostra come creare e configurare una pipeline per creare un'applicazione serverless ospitata su e pubblicarla automaticamente. GitHub AWS Serverless Application Repository La pipeline utilizza GitHub come provider di origine e CodeBuild come provider di build. Per pubblicare la tua applicazione serverless su AWS Serverless Application Repository, distribuisci un'[applicazione](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish ) (da AWS Serverless Application Repository) e associ la funzione Lambda creata da quell'applicazione come provider di azioni Invoke nella tua pipeline. Quindi è possibile fornire continuamente aggiornamenti dell'applicazione a AWS Serverless Application Repository, senza scrivere alcun codice.

**Importante**  
Molte delle azioni aggiunte alla pipeline in questa procedura coinvolgono AWS risorse che è necessario creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

## Prima di iniziare
<a name="tutorials-serverlessrepo-auto-publish-prereq"></a>

In questo tutorial si presuppone quanto segue. 
+ Familiarità con [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/) e [AWS Serverless Application Repository](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/).
+ Hai un'applicazione serverless ospitata in GitHub che hai pubblicato AWS Serverless Application Repository utilizzando la AWS SAM CLI. Per pubblicare un'applicazione di esempio su AWS Serverless Application Repository, consulta [Quick Start: Publishing Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html) nella *AWS Serverless Application Repository Developer* Guide. Per pubblicare la tua applicazione su AWS Serverless Application Repository, consulta [Pubblicazione di applicazioni utilizzando la AWS SAM CLI nella Guida](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html) per gli *AWS Serverless Application Model sviluppatori*.

## Fase 1: creazione di un file buildspec.yml
<a name="serverlessrepo-auto-publish-create-buildspec"></a>

Create un `buildspec.yml` file con i seguenti contenuti e aggiungetelo al repository dell' GitHub applicazione serverless. *template.yml*Sostituiscilo con il AWS SAM modello dell'applicazione e *bucketname* con il bucket S3 in cui è archiviata l'applicazione in pacchetto.

```
version: 0.2
phases:
  install:
    runtime-versions:
        python: 3.8
  build:
    commands:
      - sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.yml
artifacts:
  files:
    - packaged-template.yml
```

## Fase 2: creazione e configurazione della pipeline
<a name="serverlessrepo-auto-publish-create-pipeline"></a>

Segui questi passaggi per creare la tua pipeline nel luogo in Regione AWS cui desideri pubblicare l'applicazione serverless.

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

1. Se necessario, passa al Regione AWS punto in cui desideri pubblicare l'applicazione serverless.

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

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

1. Scegliere **Create pipeline (Crea pipeline)**. Nella pagina **Passaggio 2: Scegli le impostazioni della pipeline**, in Nome **pipeline, inserisci il nome** della pipeline.

1. **In **Tipo di tubazione**, scegliete V2.** Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md). Scegli **Next (Successivo)**.

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

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

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, in **Provider di origine**, scegli **GitHub**.

1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

1. In **Repository**, scegli il tuo repository GitHub di origine.

1. In **Branch**, scegli la tua GitHub filiale.

1. Lascia le impostazioni predefinite rimanenti per l'azione di origine. Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 4: Aggiungi fase di creazione**, aggiungi una fase di creazione:

   1. In **Build provider (Provider compilazione)**, scegli **AWS CodeBuild**. Per **Region (Regione)**, utilizza la regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. Per **Runtime** e **Runtime versione (Versione runtime)**, scegli il runtime e la versione richiesti per l'applicazione serverless.

   1. Per **Service Role (Ruolo del servizio)**, scegli **New service role (Nuovo ruolo del servizio)**.

   1. Per **Build specifications (Compila specifiche)**, scegli **Use a buildspec file (Usa un file buildspec)**.

   1. Scegli **Continua a CodePipeline**. In questo modo si apre la CodePipeline console e viene creato un CodeBuild progetto che utilizza la console presente `buildspec.yml` nel repository per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.** Dovresti vedere un diagramma che mostra le fasi.

1. Concedi al ruolo CodeBuild di servizio l'autorizzazione ad accedere al bucket S3 in cui è archiviata l'applicazione in pacchetto.

   1. Nella fase **Build (Compilazione)** della nuova pipeline, scegli **CodeBuild**.

   1. Seleziona la scheda **Build details (Dettagli compilazione)**.

   1. In **Ambiente**, scegli il ruolo di CodeBuild servizio per aprire la console IAM.

   1. Espandi la selezione per `CodeBuildBasePolicy` e scegli **Edit policy (Modifica policy)**.

   1. Scegli **JSON**.

   1. Aggiungi una nuova istruzione della policy con i seguenti contenuti. L'istruzione consente di CodeBuild inserire oggetti nel bucket S3 in cui è archiviata l'applicazione in pacchetto. *bucketname*Sostituiscilo con il nome del tuo bucket S3.

      ```
              {
                  "Effect": "Allow",
                  "Resource": [
                      "arn:aws:s3:::bucketname/*"
                  ],
                  "Action": [
                      "s3:PutObject"
                  ]
              }
      ```

   1. Scegliere **Esamina policy**.

   1. Scegli **Save changes** (Salva modifiche).

## Fase 3: distribuzione dell'applicazione di pubblicazione
<a name="serverlessrepo-auto-publish-deploy-app"></a>

Segui questi passaggi per distribuire l'applicazione che contiene la funzione Lambda che esegue la pubblicazione su. AWS Serverless Application Repository**Questa applicazione è aws-serverless-codepipeline-serverlessrepo -publish.**

**Nota**  
È necessario distribuire l'applicazione nella Regione AWS stessa pipeline.

1. Vai alla pagina delle [applicazioni](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish ) e scegli **Deploy (Distribuisci)**.

1. Seleziona **I acknowledge that this app creates custom IAM roles (Sono consapevole che questa app crea ruoli IAM personalizzati)**. 

1. Seleziona **Implementa**.

1. Scegli **View CloudFormation Stack** per aprire la console. CloudFormation 

1. Espandere la sezione **Resources (Risorse)**. Vedi **ServerlessRepoPublish**, qual è del tipo **AWS::Lambda::Function**. Prendi nota dell'ID fisico di questa risorsa per la prossima fase. Puoi usare questo ID fisico nel momento in cui crei la nuova operazione di pubblicazione in CodePipeline.

## Fase 4: creazione dell'operazione di pubblicazione
<a name="serverlessrepo-auto-publish-create-action"></a>

Segui questi passaggi per creare l'operazione di pubblicazione nella pipeline.

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Nella sezione di navigazione a sinistra, scegli la pipeline che desideri modificare.

1. Scegli **Modifica**.

1. Dopo l'ultima fase della pipeline corrente, scegli **\$1 Add stage (\$1 Aggiungi fase)**. In **Stage name (Nome fase)** immetti un nome, ad esempio **Publish**, quindi scegli **Add stage (Aggiungi fase)**.

1. Nella nuova fase, scegliere **\$1 Add action group (Aggiungi gruppo di operazioni)**.

1. Immetti un nome per l'operazione. Da **Action provider (Provider operazione)**, in **Invoke (Richiama)**, scegli **AWS Lambda**.

1. Da **Inserisci artefatti, scegli**. **BuildArtifact**

1. Da **Nome funzione**, scegli l'ID fisico della funzione Lambda che hai annotato nel passaggio precedente.

1. Scegli **Save (Salva)** per l'operazione.

1. Scegli **Done (Fatto)** per la fase.

1. In alto a destra, scegli **Save (Salva)**.

1. Per verificare la pipeline, apporta una modifica all'applicazione in. GitHub Ad esempio, modifica la descrizione dell'applicazione nella `Metadata` sezione del file AWS SAM modello. Applica la modifica e inviala alla tua GitHub filiale. In questo modo viene attivata la pipeline per l'esecuzione. Una volta che la pipeline è completa, controlla che l'applicazione sia stata aggiornata con la modifica in [AWS Serverless Application Repository](https://console.aws.amazon.com/serverlessrepo/home).

# Tutorial: implementazioni di funzioni Lambda con CodePipeline
<a name="tutorials-lambda-deploy"></a>

Questo tutorial ti aiuta a creare un'azione di distribuzione CodePipeline che distribuisce il codice alla funzione che hai configurato in Lambda. Creerai una funzione Lambda di esempio in cui creerai un alias e una versione, aggiungerai la funzione Lambda compressa alla posizione di origine ed eseguirai l'azione Lambda nella pipeline.

**Nota**  
Come parte della creazione di una pipeline nella console, per gli artefatti verrà utilizzato un bucket di artefatti S3. CodePipeline (Questo è diverso dal bucket utilizzato per un'azione sorgente S3.) Se il bucket di artefatti S3 si trova in un account diverso da quello della pipeline, assicurati che il bucket di artefatti S3 sia di proprietà di utenti sicuri e affidabili. Account AWS 

**Nota**  
L'`Lambda`azione di distribuzione è disponibile solo per le pipeline di tipo V2.

## Prerequisiti
<a name="tutorials-lambda-deploy-prereqs"></a>

Per utilizzare questo tutorial per creare la pipeline di distribuzione continua, è necessario disporre di alcune risorse. Ecco di cosa hai bisogno prima di iniziare:

**Nota**  
Tutte queste risorse devono essere create all'interno della stessa regione. AWS 
+ Un repository di controllo del codice sorgente, ad esempio GitHub, o un bucket S3 di origine (questo tutorial utilizza S3) in cui archivierai un `.zip` file creato per la tua funzione Lambda.
+ È necessario utilizzare un ruolo di CodePipeline servizio esistente che è stato aggiornato con le autorizzazioni per questa azione. Per aggiornare il tuo ruolo di servizio, consulta[Autorizzazioni della policy del ruolo di servizio per l'azione di distribuzione Lambda](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action).

Dopo aver soddisfatto questi prerequisiti, puoi procedere con il tutorial e creare la pipeline di distribuzione continua.

## Fase 1: Creare la funzione Lambda di esempio
<a name="tutorials-lambda-deploy-instances"></a>

In questo passaggio, creerai la funzione Lambda in cui verrà distribuita.

**Per creare la tua funzione Lambda**

1. Accedi alla console Lambda e segui i passaggi del seguente tutorial per creare una funzione Lambda di esempio: link.

1. Dalla barra di navigazione in alto, scegli **Crea** e seleziona **Inizia da zero** nella parte superiore della pagina.

1. In **Nome**, inserisci **MyLambdaFunction**. 

1. Pubblica una nuova versione. Questa sarà la versione a cui punterà l'alias.

   1. Seleziona la tua funzione.

   1. Scegli il menu a discesa **Azioni**.

   1. Selezionare **Publish new version** (Pubblica nuova versione).

   1. (Facoltativo) Aggiungi alla descrizione in **Descrizione**.

   1. Seleziona **Pubblica**.

1. Crea un alias per la tua funzione, ad esempio`aliasV1`.

1. Assicurati che l'alias punti alla versione che hai appena creato (ad esempio 1).
**Nota**  
Se scegli \$1LATEST, non puoi utilizzare le funzionalità di spostamento del traffico perché Lambda non supporta \$1LATEST per un alias che punta a più di una versione.

## Passaggio 2: carica il file della funzione nel tuo repository
<a name="tutorials-lambda-deploy-file"></a>

Scaricate la funzione e salvatela come file zip. Carica il file compresso nel tuo bucket S3 seguendo i seguenti passaggi.

**Aggiunta di un file `.zip` nell'archivio di codice sorgente**

1. Apri il tuo bucket S3.

1. Scegli **Carica**.

1. Carica il file zip contenente il `sample_lambda_source.zip` file nel bucket di origine.

   Prendi nota del percorso.

   ```
   object key
   ```

## Fase 3: Creazione della pipeline
<a name="tutorials-lambda-deploy-pipeline"></a>

Usa la CodePipeline procedura guidata per creare le fasi della pipeline e connettere il tuo repository di origine.

**Creazione della pipeline**

1. Apri la console all' CodePipeline indirizzo. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyPipeline**

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

1. In **Ruolo di servizio**, scegli **Usa il ruolo di servizio esistente**, quindi scegli il ruolo di CodePipeline servizio che è stato aggiornato con le autorizzazioni richieste per questa azione. Per configurare il ruolo CodePipeline di servizio per questa azione, consulta[Autorizzazioni della policy del ruolo di servizio per l'azione di distribuzione Lambda](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action).

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

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Provider di origine**, scegli **Amazon S3**.

   1. Nella **chiave Object**, aggiungi il nome del tuo file.zip, inclusa l'estensione del file, ad esempio. `sample_lambda_source.zip`

      

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 4: Aggiungi fase di compilazione**, scegli **Ignora**.

1. Nella pagina **Passaggio 5: Aggiungi fase di test**, scegli **Salta**.

1. Nella pagina **Fase 6: Aggiungi fase di distribuzione**, scegli **Lambda**.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)

   1. Aggiungi il nome e l'alias della funzione. 

   1. Scegli la tua strategia di implementazione.

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

1. Nella pagina **Passaggio 7: revisione**, rivedi la configurazione della pipeline e scegli **Crea pipeline per creare la pipeline**.  
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/lambdadeploy-pipeline-screen.png)

## Fase 4: test della pipeline
<a name="tutorials-lambda-deploy-test"></a>

La tua pipeline dovrebbe avere tutto il necessario per eseguire una distribuzione continua nativa. end-to-end AWS Ora, testane la funzionalità inserendo una modifica del codice all'archivio del codice sorgente.

**Test della pipeline**

1. Effettua una modifica del codice nell'archivio del codice sorgente configurato, conferma e inserisci la modifica.

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleziona la pipeline nell'elenco.

1. Osserva l'avanzamento della pipeline attraverso le varie fasi. La pipeline dovrebbe essere completata e l'azione verrà implementata nella funzione Lambda.

## Ulteriori informazioni
<a name="tutorials-lambda-deploy-learn"></a>

L'azione di implementazione Lambda consente due metodi di distribuzione. Un metodo consiste nel solo spostamento del traffico senza alcun elemento di input proveniente dall'azione di origine. L'altro metodo consiste nell'aggiornare il codice della funzione utilizzando un elemento di input dell'azione sorgente, quindi nella pubblicazione di una nuova versione basata sul codice aggiornato. Per il secondo metodo, se viene fornito l'alias, CodePipeline effettuerà anche lo spostamento del traffico. Questo tutorial sulle azioni di implementazione di Lambda mostra l'aggiornamento della funzione utilizzando un artefatto sorgente.

Per ulteriori informazioni sull'azione, consulta la pagina di riferimento dell'azione all'indirizzo. [AWS Lambda distribuire un riferimento all'azione](action-reference-LambdaDeploy.md)

# Tutorial: Utilizzo delle variabili con le azioni di richiamo Lambda
<a name="tutorials-lambda-variables"></a>

Un'azione di richiamo Lambda può utilizzare le variabili di un'altra azione come parte del suo input e restituire nuove variabili insieme al relativo output. Per informazioni sulle variabili per le azioni in CodePipeline, vedi. [Riferimento alle variabili](reference-variables.md)

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

Alla fine di questo tutorial, avrai:
+ Un'azione di richiamo Lambda che:
  + Consuma la `CommitId` variabile da un'azione di origine CodeCommit 
  + Restituisce tre nuove variabili: `dateTime`, `testRunId`, e `region`
+ Un'azione di approvazione manuale che utilizza le nuove variabili dell'azione di invocazione Lambda per fornire un URL di test e un ID di esecuzione del test
+ Una pipeline aggiornata con le nuove operazioni

**Topics**
+ [

## Prerequisiti
](#lambda-variables-prereqs)
+ [

## Fase 1: creare una funzione Lambda
](#lambda-variables-function)
+ [

## Fase 2: aggiungi un'azione di richiamo Lambda e un'azione di approvazione manuale alla tua pipeline
](#lambda-variables-pipeline)

## Prerequisiti
<a name="lambda-variables-prereqs"></a>

Prima di iniziare, devi: 
+ Puoi creare o utilizzare la pipeline con il codice sorgente inserito. CodeCommit [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)
+ Modifica la pipeline esistente in modo che l'azione di CodeCommit origine abbia un namespace. Assegna all'operazione le `SourceVariables` dello spazio dei nomi.

## Fase 1: creare una funzione Lambda
<a name="lambda-variables-function"></a>

Utilizza i seguenti passaggi per creare una funzione Lambda e un ruolo di esecuzione Lambda. L'azione Lambda viene aggiunta alla pipeline dopo aver creato la funzione Lambda.

**Per creare una funzione Lambda e un ruolo di esecuzione**

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

1. Scegli **Crea funzione**. Lasciare selezionato **Author from scratch (Crea da zero)**.

1. In **Function name (Nome funzione)**, immettere il nome della funzione, ad esempio **myInvokeFunction**. In **Runtime**, lasciare selezionata l'opzione predefinita.

1. Espandere **Choose or create an execution role (Scegli o crea un ruolo di esecuzione)**. Scegliere **Create a new role with basic Lambda permissions (Crea un nuovo ruolo con le autorizzazioni Lambda di base)**.

1. Scegli **Crea funzione**.

1. Per utilizzare una variabile da un'altra operazione, deve essere passata ai `UserParameters` nella configurazione dell'operazione di invocazione Lambda. Configuri l'operazione nella pipeline più avanti in questo tutorial, ma aggiungi il codice presumendo che la variabile venga passata.

   Per produrre nuove variabili, imposta una proprietà denominata `outputVariables` sull'input di `putJobSuccessResult`. Tieni presente che non è possibile produrre variabili come parte di un file `putJobFailureResult`.

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   Nella nuova funzione, nella scheda **Codice**, incolla il seguente codice di esempio sotto`index.mjs`.

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. Consenti il salvataggio automatico della funzione.

1. Copia l'Amazon Resource Name (ARN) contenuto nel campo **Function ARN** nella parte superiore dello schermo.

1. Come ultimo passaggio, apri la console AWS Identity and Access Management (IAM) all'indirizzo. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) Modifica il ruolo di esecuzione Lambda per aggiungere la seguente politica:. [AWSCodePipelineCustomActionAccess](https://console.aws.amazon.com/iam/home?region=us-west-2#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCodePipelineCustomActionAccess) Per le fasi della creazione di un ruolo di esecuzione Lambda o della modifica della policy di ruolo, consulta [Fase 2: Creare la funzione Lambda](actions-invoke-lambda-function.md#actions-invoke-lambda-function-create-function) . 

## Fase 2: aggiungi un'azione di richiamo Lambda e un'azione di approvazione manuale alla tua pipeline
<a name="lambda-variables-pipeline"></a>

In questo passaggio, aggiungi un'azione di richiamo Lambda alla tua pipeline. È possibile aggiungere l'operazione come parte di una fase denominata **Test**. Il tipo di operazione è un'operazione di richiamo. È quindi possibile aggiungere un'operazione di approvazione manuale dopo l'operazione di richiamo.

**Per aggiungere un'azione Lambda e un'azione di approvazione manuale alla pipeline**

1. Apri la CodePipeline console all'indirizzo. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

   Vengono visualizzati i nomi di tutte le pipeline associate al tuo AWS account. Scegliere la pipeline in cui si desidera aggiungere l'operazione.

1. Aggiungi l'azione di test Lambda alla tua pipeline.

   1. Per modificare la pipeline, scegliere **Edit (Modifica)**. Aggiungere una fase dopo l'operazione di origine nella pipeline esistente. Immettere un nome per la fase, ad esempio **Test**.

   1. Nella nuova fase, scegli **Aggiungi gruppo di azioni** per aggiungere un'azione. In **Action name (Nome operazione)**, immettere il nome dell'operazione di richiamo, ad esempio **Test\$1Commit**.

   1. In **Action provider**, scegli **AWS Lambda**.

   1. In **Input artifacts (Artefatti di input)**, scegliere il nome dell'artefatto di output dell'operazione di origine, ad esempio `SourceArtifact`.

   1. In **FunctionName**, aggiungi l'ARN della funzione Lambda che hai creato.

   1. In **Variable namespace (Spazio dei nomi delle variabili)** aggiungere il nome dello spazio dei nomi, ad esempio **TestVariables**.

   1. In **Elementi di output, aggiungi il nome dell'artefatto** di output, ad esempio. **LambdaArtifact**

   1. Seleziona **Fatto**.

1. Aggiungere l'operazione di approvazione manuale alla pipeline.

   1. Con la pipeline ancora in modalità di modifica, aggiungere una fase dopo l'operazione di richiamo. Immettere un nome per la fase, ad esempio **Approval**.

   1. Nella nuova fase, scegliere l'icona per aggiungere un'operazione. In **Action name (Nome operazione)**, immettere il nome dell'operazione di approvazione, ad esempio **Change\$1Approval**.

   1. In **Action provider (Provider operazione)**, scegliere **Manual approval (Approvazione manuale)**.

   1. In **URL for review (URL per revisione)**, costruire l'URL aggiungendo la sintassi della variabile per le variabili `region` e `CommitId`. Assicurarsi di utilizzare gli spazi dei nomi assegnati alle operazioni che forniscono le variabili di output. 

      Per questo esempio, l'URL con la sintassi variabile per un' CodeCommit azione ha lo spazio dei nomi predefinito. `SourceVariables` La variabile di output della regione Lambda ha lo spazio dei nomi `TestVariables`. L'URL ha il seguente aspetto:

      ```
      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}
      ```

      In **Comments (Commenti)**, costruire il testo del messaggio di approvazione aggiungendo la sintassi della variabile per la variabile `testRunId`. Per questo esempio, l'URL con la sintassi della variabile di output `testRunId` Lambda ha lo spazio dei nomi `TestVariables`. Inserire il seguente messaggio.

      ```
      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}
      ```

1. Scegliere **Done (Fatto)** per chiudere la schermata di modifica per l'operazione, quindi scegliere **Done (Fatto)** per chiudere la schermata di modifica per la fase. Per salvare la pipeline, scegliere **Done (Fatto)**. La pipeline completata ora contiene una struttura con fasi di origine, test, approvazione e distribuzione.

   Scegliere **Release change (Rilascia modifica)** per eseguire l'ultima modifica nella struttura della pipeline.

1. Quando la pipeline raggiunge la fase di approvazione manuale, scegliere **Review (Revisione)**. Le variabili risolte vengono visualizzate come URL per l'ID commit. L'approvatore può scegliere l'URL per visualizzare il commit.

1. Dopo che la pipeline è stata eseguita correttamente, è anche possibile visualizzare i valori delle variabili nella pagina della cronologia dell'esecuzione delle operazioni.

# Tutorial: utilizzare un'azione di AWS Step Functions richiamo in una pipeline
<a name="tutorials-step-functions"></a>

È possibile utilizzare AWS Step Functions per creare e configurare macchine a stati. Questo tutorial illustra come aggiungere un'operazione di richiamo a una pipeline che attiva le esecuzioni della macchina a stati dalla pipeline. 

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

In questo tutorial, vengono effettuate le seguenti operazioni:
+ Crea una macchina a stati standard in. AWS Step Functions
+ Immettere direttamente l'input JSON della macchina a stati. Puoi anche caricare il file di input della macchina a stati in un bucket Amazon Simple Storage Service (Amazon S3).
+ Aggiornare la pipeline aggiungendo l'operazione della macchina a stati.

**Topics**
+ [

## Prerequisito: creare o scegliere una pipeline semplice
](#tutorials-step-functions-prereq)
+ [

## Fase 1: creazione della macchina a stati di esempio
](#tutorials-step-functions-sample)
+ [

## Passaggio 2: aggiungi un'azione di invocazione Step Functions alla tua pipeline
](#tutorials-step-functions-pipeline)

## Prerequisito: creare o scegliere una pipeline semplice
<a name="tutorials-step-functions-prereq"></a>

In questo tutorial viene aggiunta un'operazione di richiamo su una pipeline esistente. È possibile utilizzare la pipeline creata in [Tutorial: creazione di una semplice pipeline (bucket S3)](tutorials-simple-s3.md) o [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md).

Si utilizza una pipeline esistente con un'operazione di origine e almeno una struttura a due fasi, ma non si utilizzano gli artefatti di origine per questo esempio.

**Nota**  
Potrebbe essere necessario aggiornare il ruolo del servizio utilizzato dalla pipeline con autorizzazioni aggiuntive necessarie per eseguire questa operazione. A tale scopo, apri la console AWS Identity and Access Management (IAM), trova il ruolo e aggiungi le autorizzazioni alla policy del ruolo. Per ulteriori informazioni, consulta [Aggiungi le autorizzazioni al ruolo di servizio CodePipeline](how-to-custom-role.md#how-to-update-role-new-services).

## Fase 1: creazione della macchina a stati di esempio
<a name="tutorials-step-functions-sample"></a>

Nella console Step Functions, create una macchina a stati utilizzando il modello `HelloWorld` di esempio. Per istruzioni, consulta [Creare una macchina a stati](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started.html#create-state-machine) nella *Guida per gli AWS Step Functions sviluppatori*.

## Passaggio 2: aggiungi un'azione di invocazione Step Functions alla tua pipeline
<a name="tutorials-step-functions-pipeline"></a>

Aggiungi un'azione di richiamo Step Functions alla tua pipeline come segue:

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

   Vengono visualizzati i nomi di tutte le pipeline associate al tuo AWS account.

1. In **Name (Nome)**, scegliere il nome della pipeline da modificare. Questa operazione apre una visualizzazione dettagliata della pipeline. compreso lo stato di ciascuna delle operazioni in ciascuna fase della pipeline.

1. Nella pagina dei dettagli della pipeline, scegliere **Edit (Modifica)**.

1. Nella seconda fase della pipeline semplice, scegliere **Edit stage (Modifica fase)**. Scegli **Elimina**. Questo elimina la seconda fase ora che non ne hai più bisogno.

1. In fondo al diagramma, scegliere **\$1 Add stage (\$1 Aggiungi fase)**

1. In **Stage name (Nome fase)**, inserire un nome per la fase, ad esempio **Invoke**, e poi scegliere **Add stage (Aggiungi fase)**.

1. Scegliere **\$1 Add action group (\$1 Aggiungi gruppo di operazioni)**.

1. Alla voce **Action name (Nome operazione)**, inserire un nome, ad esempio **Invoke**.

1. Nel **provider Action**, scegli **AWS Step Functions**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

1. In **Input artifacts (Artefatti di input)**, scegliere `SourceArtifact`.

1. In **State machine ARN (ARN macchina a stati)**, scegliere l’Amazon Resource Name (ARN) per la macchina a stati creata in precedenza.

1. (Facoltativo) In **Execution name prefix (Prefisso nome esecuzione)**, immettere un prefisso da aggiungere all'ID di esecuzione della macchina a stati.

1. In **Input type (Tipo di input)**, scegliere **Literal (Letterale)**.

1. In **Input**, immettere il codice JSON di input previsto dalla macchina a stati di esempio `HelloWorld`.
**Nota**  
L'input per l'esecuzione della macchina a stati è diverso dal termine usato CodePipeline per descrivere gli artefatti di input per le azioni.

   In questo esempio, inserire il seguente codice JSON:

   ```
   {"IsHelloWorldExample": true}
   ```

1. Seleziona **Fatto**.

1. Nello fase che si sta modificando, scegliere **Done (Fatto)**. Nel riquadro AWS CodePipeline , scegli **Save (Salva)** e quindi scegli **Save (Salva)** sul messaggio di avviso.

1. Per inviare le modifiche e avviare l'esecuzione della pipeline, scegli **Release change (Rilascia modifica)** e quindi scegli **Release (Rilascia)**.

1. Sulla pipeline completata, scegli **AWS Step Functions** nell'azione di invoca. Nella AWS Step Functions console, visualizza l'ID di esecuzione della tua macchina a stati. L'ID mostra il nome della macchina a stati `HelloWorld` e l'ID di esecuzione della macchina a stati con il prefisso `my-prefix`.

   ```
   arn:aws:states:us-west-2:account-ID:execution:HelloWorld:my-prefix-0d9a0900-3609-4ebc-925e-83d9618fcca1
   ```

# Tutorial: crea una pipeline da utilizzare AWS AppConfig come provider di distribuzione
<a name="tutorials-AppConfig"></a>

In questo tutorial, configurerai una pipeline che fornisce continuamente file di configurazione, utilizzandola AWS AppConfig come provider di azioni di distribuzione nella fase di distribuzione.

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

**Topics**
+ [

## Prerequisiti
](#tutorials-AppConfig-prereq)
+ [

## Fase 1: Crea le tue risorse AWS AppConfig
](#tutorials-AppConfig-application)
+ [

## Passaggio 2: carica i file nel tuo bucket di origine S3
](#tutorials-AppConfig-bucket)
+ [

## Fase 3: creazione della pipeline
](#tutorials-AppConfig-pipeline)
+ [

## Passaggio 4: apporta una modifica a qualsiasi file di origine e verifica la distribuzione
](#tutorials-AppConfig-verify)

## Prerequisiti
<a name="tutorials-AppConfig-prereq"></a>

Prima di iniziare, devi completare quanto segue:
+ Questo esempio utilizza una sorgente S3 per la pipeline. Crea o usa un bucket Amazon S3 con il controllo delle versioni abilitato. Per creare un bucket S3, segui le istruzioni contenute in [Passaggio 1: crea un bucket di origine S3 per la tua applicazione](tutorials-simple-s3.md#s3-create-s3-bucket).

## Fase 1: Crea le tue risorse AWS AppConfig
<a name="tutorials-AppConfig-application"></a>

In questa sezione, crei le seguenti risorse:
+ Un'*applicazione* in AWS AppConfig è un'unità logica di codice che fornisce funzionalità ai clienti.
+ Un *ambiente* in AWS AppConfig è un gruppo logico di AppConfig destinazione di distribuzione, ad esempio applicazioni in un ambiente beta o di produzione.
+ Un *profilo di configurazione* è una raccolta di impostazioni che influenzano il comportamento dell'applicazione. Il profilo di configurazione consente AWS AppConfig di accedere alla configurazione nella posizione memorizzata.
+ (Facoltativo) Una *strategia di distribuzione* AWS AppConfig definisce il comportamento di una distribuzione di configurazione, ad esempio la percentuale di client che deve ricevere la nuova configurazione distribuita in un dato momento durante una distribuzione.

**Per creare un'applicazione, un ambiente, un profilo di configurazione e una strategia di distribuzione**

1. Accedi alla Console di gestione AWS.

1. Utilizza i passaggi descritti nei seguenti argomenti per creare le tue risorse in AWS AppConfig.
   + [Crea un'applicazione](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-application.html).
   + [Crea un ambiente](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-environment.html).
   + [Crea un profilo AWS CodePipeline di configurazione](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html).
   + (Facoltativo) [Scegli una strategia di implementazione predefinita o creane una personalizzata.](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-deployment-strategy.html)

## Passaggio 2: carica i file nel tuo bucket di origine S3
<a name="tutorials-AppConfig-bucket"></a>

In questa sezione, crea uno o più file di configurazione. Quindi comprimi e invia i file sorgente nel bucket utilizzato dalla pipeline per la fase di origine.

**Per creare file di configurazione**

1. Crea un `configuration.json` file per ogni configurazione in ogni regione. Includi i seguenti contenuti:

   ```
   Hello World!
   ```

1. Utilizza i seguenti passaggi per comprimere e caricare i file di configurazione.

**Per comprimere e caricare i file sorgente**

1. Crea un file.zip con i tuoi file e assegna un nome al file.zip. `configuration-files.zip` Ad esempio, il tuo file.zip può utilizzare la seguente struttura:

   ```
   .
   └── appconfig-configurations
       └── MyConfigurations
           ├── us-east-1
           │   └── configuration.json
           └── us-west-2
               └── configuration.json
   ```

1. Nella console Amazon S3 del tuo bucket, scegli **Carica** e segui le istruzioni per caricare il tuo file.zip.

## Fase 3: creazione della pipeline
<a name="tutorials-AppConfig-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un'azione Amazon S3 in cui gli artefatti di origine sono i file per la configurazione.
+ Una fase di distribuzione con un' AppConfig azione di distribuzione.

**Per creare una pipeline con la procedura guidata**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyAppConfigPipeline**

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

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

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

1. Nel **passaggio 3: Aggiungi la fase di origine**, in **Provider di origine**, scegli **Amazon S3**. In **Bucket**, scegli il nome del tuo bucket di origine S3. 

   Nella **chiave dell'oggetto S3**, inserisci il nome del tuo file.zip:. `configuration-files.zip`

   Scegli **Next (Successivo)**.

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

   Scegli **Next (Successivo)**.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di implementazione**:

   1. In **Deploy provider, scegli**. **AWS AppConfig** 

   1. In **Applicazione**, scegli il nome dell'applicazione in AWS AppConfig cui hai creato. Il campo mostra l'ID dell'applicazione.

   1. In **Ambiente**, scegli il nome dell'ambiente in cui hai creato AWS AppConfig. Il campo mostra l'ID del tuo ambiente.

   1. In **Profilo di configurazione**, scegli il nome del profilo di configurazione in cui hai creato AWS AppConfig. Il campo mostra l'ID del tuo profilo di configurazione.

   1. In **Strategia di implementazione**, scegli il nome della tua strategia di distribuzione. Può trattarsi di una strategia di distribuzione creata in precedenza AppConfig o di una strategia di distribuzione scelta tra quelle predefinite. AppConfig Il campo mostra l'ID della tua strategia di distribuzione.

   1. In **Input artifact configuration path**, inserisci il percorso del file. Assicurati che il percorso di configurazione degli artefatti di input corrisponda alla struttura di directory nel file.zip del bucket S3. Per questo esempio, inserisci il seguente percorso del file:. `appconfig-configurations/MyConfigurations/us-west-2/configuration.json` 

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

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

## Passaggio 4: apporta una modifica a qualsiasi file di origine e verifica la distribuzione
<a name="tutorials-AppConfig-verify"></a>

Apporta una modifica ai file sorgente e carica la modifica nel tuo bucket. In questo modo viene attivata la pipeline per l'esecuzione. Verifica che la tua configurazione sia disponibile visualizzando la versione.

# Tutorial: usa il clone completo con una sorgente di GitHub pipeline
<a name="tutorials-github-gitclone"></a>

Puoi scegliere l'opzione di clonazione completa per la tua azione di GitHub origine in. CodePipeline Usa questa opzione per eseguire CodeBuild comandi per i metadati Git nell'azione di creazione della pipeline.

**Nota**  
L'opzione full clone descritta qui si riferisce alla specifica se clonare i metadati del repository, che possono CodePipeline essere utilizzati solo dai comandi. CodeBuild Per utilizzare un [token di accesso GitHub utente](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app) da utilizzare con i CodeBuild progetti, segui i passaggi riportati qui per installare il AWS Connector for GitHub app, quindi lascia vuoto il campo di installazione dell'app. CodeConnections utilizzerà il token di accesso utente per la connessione.



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

In questo tutorial, creerai una pipeline che si connette al tuo GitHub repository, utilizza l'opzione full clone per i dati di origine ed CodeBuild eseguirai una build che clona il tuo repository ed esegue comandi Git per il repository.

**Nota**  
Questa funzionalità non è disponibile nelle regioni Asia Pacifico (Hong Kong), Africa (Città del Capo), Medio Oriente (Bahrein), Europa (Zurigo) o AWS GovCloud (Stati Uniti occidentali). Per fare riferimento ad altre azioni disponibili, consulta. [Integrazioni di prodotti e servizi con CodePipeline](integrations.md) Per considerazioni su questa azione nella regione Europa (Milano), si veda la nota in[CodeStarSourceConnection per Bitbucket Cloud, GitHub Enterprise Server GitHub, GitLab .com e GitLab azioni autogestite](action-reference-CodestarConnectionSource.md).

**Topics**
+ [

## Prerequisiti
](#tutorials-github-gitclone-prereq)
+ [

## Fase 1: Creare un file README
](#tutorials-github-gitclone-file)
+ [

## Fase 2: Crea la tua pipeline e crea il progetto
](#tutorials-github-gitclone-pipeline)
+ [

## Passaggio 3: Aggiornare la politica del ruolo CodeBuild di servizio per utilizzare le connessioni
](#tutorials-github-gitclone-rolepolicy)
+ [

## Passaggio 4: Visualizza i comandi del repository nell'output della build
](#tutorials-github-gitclone-view)

## Prerequisiti
<a name="tutorials-github-gitclone-prereq"></a>

Prima di iniziare è necessario:
+ Crea un GitHub repository con il tuo GitHub account.
+ Tieni a portata di mano GitHub le tue credenziali. Quando utilizzi il Console di gestione AWS per configurare una connessione, ti viene chiesto di accedere con GitHub le tue credenziali. 

## Fase 1: Creare un file README
<a name="tutorials-github-gitclone-file"></a>

Dopo aver creato il GitHub repository, segui questi passaggi per aggiungere un file README.

1. Accedi al tuo GitHub repository e scegli il tuo repository.

1. Per creare un nuovo file, scegli **Aggiungi file > Crea nuovo** file. Assegna un nome al file`README.md`. file e aggiungi il testo seguente.

   ```
   This is a GitHub repository!
   ```

1. Scegliere **Commit changes (Applica modifiche)**.

   Assicurati che il file `README.md` si trovi al livello root del repository.

## Fase 2: Crea la tua pipeline e crea il progetto
<a name="tutorials-github-gitclone-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con una connessione al GitHub repository e all'azione.
+ Una fase di compilazione con un'azione di AWS CodeBuild compilazione.

**Per creare una pipeline con la procedura guidata**

1. Accedi alla CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyGitHubPipeline**

1. In **Tipo di tubazione**, scegliete **V1** ai fini di questo tutorial. Puoi anche scegliere **V2**; tuttavia, tieni presente che i tipi di tubazione differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md).

1. In **Service Role (Ruolo del servizio)**, scegliere **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Se invece scegli di utilizzare il tuo ruolo di CodePipeline servizio esistente, assicurati di aver aggiunto l'autorizzazione `codestar-connections:UseConnection` IAM alla tua policy sul ruolo di servizio. Per istruzioni sul ruolo CodePipeline di servizio, consulta [Aggiungere autorizzazioni al ruolo CodePipeline di servizio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. In **Impostazioni avanzate** non modificare le impostazioni predefinite. In **Artifact store (Archivio artefatti)**, seleziona **Default location (Posizione predefinita)** per utilizzare l'archivio artefatti predefinito, ad esempio il bucket Amazon S3 dedicato agli artefatti designato come predefinito, per la pipeline nella regione selezionata.
**Nota**  
Non si tratta del bucket di origine per il codice sorgente, ma dell'archivio artefatti per la pipeline. È richiesto un archivio artefatti separato, ad esempio un bucket S3, per ogni pipeline.

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider**, scegli **GitHub (tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md). 

      È sufficiente installare una sola app per tutte le connessioni a un provider specifico. Se hai già installato l' GitHub app AWS Connector for, sceglilo e salta questo passaggio.
**Nota**  
Se desideri creare un [token di accesso utente](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app), assicurati di aver già installato AWS Connector per GitHub app, quindi lascia vuoto il campo di installazione dell'app. CodeConnections utilizzerà il token di accesso utente per la connessione. Per ulteriori informazioni, consulta [Accedere al provider di origine in CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/access-tokens.html).

   1. In **Repository name (Nome repository)**, scegli il nome del repository GitHub.

   1. In **Nome del ramo**, scegli il ramo del repository che desideri utilizzare.

   1. Assicurati che l'opzione **Avvia la pipeline alla modifica del codice sorgente** sia selezionata.

   1. In **Formato artefatto di output**, scegli **Clone completo** per abilitare l'opzione Git clone per il repository di origine. Solo le azioni fornite da CodeBuild possono utilizzare l'opzione Git clone. [Passaggio 3: Aggiornare la politica del ruolo CodeBuild di servizio per utilizzare le connessioni](#tutorials-github-gitclone-rolepolicy)In questo tutorial utilizzerai questa opzione per aggiornare le autorizzazioni per il tuo ruolo di CodeBuild project service.

   Scegli **Next (Successivo)**.

1. Nel **passaggio 4: Aggiungi fase di compilazione, aggiungi una fase** di compilazione:

   1. In **Build provider (Provider compilazione)**, scegli **AWS CodeBuild**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. **Per **Image**, scegliete: 5.0aws/codebuild/standard.**

   1. Per **Service Role (Ruolo del servizio)**, scegli **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Annota il nome del tuo ruolo di servizio. CodeBuild Avrai bisogno del nome del ruolo per l'ultimo passaggio di questo tutorial.

   1. In **Buildspec**, per **Build specifications** (Specifiche di compilazione), scegli **Insert build commands (Inserisci comandi di compilazione)**. Scegli **Passa all'editor** e incolla quanto segue nei **comandi di creazione**.
**Nota**  
Nella `env` sezione delle specifiche di compilazione, assicurati che l'helper delle credenziali per i comandi git sia abilitato come mostrato in questo esempio.

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git archive --format=zip HEAD > application.zip
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
          - application.zip
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. **Scegli Continua a. CodePipeline** Questo ritorna alla CodePipeline console e crea un CodeBuild progetto che utilizza i comandi di build per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.**

## Passaggio 3: Aggiornare la politica del ruolo CodeBuild di servizio per utilizzare le connessioni
<a name="tutorials-github-gitclone-rolepolicy"></a>

L'esecuzione iniziale della pipeline avrà esito negativo perché il ruolo CodeBuild di servizio deve essere aggiornato con le autorizzazioni per utilizzare le connessioni. Aggiungi l'autorizzazione `codestar-connections:UseConnection` IAM alla tua policy sui ruoli di servizio. Per istruzioni su come aggiornare la policy nella console IAM, consulta[Aggiungi le autorizzazioni per le connessioni a Bitbucket, Enterprise Server o.com CodeBuild GitClone GitHub GitHub GitLab](troubleshooting.md#codebuild-role-connections).

## Passaggio 4: Visualizza i comandi del repository nell'output della build
<a name="tutorials-github-gitclone-view"></a>

1. Quando il ruolo di servizio viene aggiornato correttamente, scegli **Riprova** nella fase non riuscita CodeBuild .

1. Dopo che la pipeline è stata eseguita correttamente, nella fase di compilazione corretta, scegli **Visualizza** dettagli.

   Nella pagina dei dettagli, scegli la scheda **Registri.** Visualizza l'output della CodeBuild build. I comandi restituiscono il valore della variabile inserita.

   I comandi generano il contenuto del `README.md` file, elencano i file nella directory, clonano il repository, visualizzano il registro e archiviano il repository come file ZIP.

# Tutorial: usa il clone completo con una sorgente di CodeCommit pipeline
<a name="tutorials-codecommit-gitclone"></a>

Puoi scegliere l'opzione di clonazione completa per la tua azione di CodeCommit origine in. CodePipeline Usa questa opzione per consentire l'accesso CodeBuild ai metadati Git nell'azione di creazione della pipeline.

In questo tutorial, crei una pipeline che accede al tuo CodeCommit repository, utilizza l'opzione full clone per i dati di origine ed esegue una CodeBuild build che clona il tuo repository ed esegue comandi Git per il repository.

**Nota**  
CodeBuild le azioni sono le uniche azioni a valle che supportano l'uso dei metadati Git disponibili con l'opzione Git clone. Inoltre, sebbene la pipeline possa contenere azioni tra più account, l' CodeCommitazione e l' CodeBuild azione devono trovarsi nello stesso account affinché l'opzione di clonazione completa abbia successo.

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

**Topics**
+ [

## Prerequisiti
](#tutorials-codecommit-gitclone-prereq)
+ [

## Passaggio 1: creare un file README
](#tutorials-codecommit-gitclone-file)
+ [

## Fase 2: Crea la tua pipeline e crea il progetto
](#tutorials-codecommit-gitclone-pipeline)
+ [

## Passaggio 3: Aggiornare la politica del ruolo CodeBuild di servizio per clonare il repository
](#tutorials-codecommit-gitclone-rolepolicy)
+ [

## Passaggio 4: Visualizza i comandi del repository nell'output della build
](#tutorials-codecommit-gitclone-view)

## Prerequisiti
<a name="tutorials-codecommit-gitclone-prereq"></a>

Prima di iniziare, devi creare un CodeCommit repository nello stesso account e nella stessa regione della pipeline. AWS 

## Passaggio 1: creare un file README
<a name="tutorials-codecommit-gitclone-file"></a>

Segui questi passaggi per aggiungere un file README al tuo repository di origine. Il file README fornisce un file sorgente di esempio da leggere per l'azione a CodeBuild valle.

**Per aggiungere un file README**

1. Accedi al tuo repository e scegli il tuo repository.

1. Per creare un nuovo file, scegli **Aggiungi file > Crea file**. Assegna un nome al file`README.md`. file e aggiungi il testo seguente.

   ```
   This is a CodeCommit repository!
   ```

1. Scegliere **Commit changes (Applica modifiche)**.

   Assicurati che il file `README.md` si trovi al livello root del repository.

## Fase 2: Crea la tua pipeline e crea il progetto
<a name="tutorials-codecommit-gitclone-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un'azione CodeCommit di origine.
+ Una fase di compilazione con un'azione di AWS CodeBuild compilazione.

**Per creare una pipeline con la procedura guidata**

1. Accedi alla CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyCodeCommitPipeline**

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

1. In **Service role (Ruolo del servizio)**, procedere in uno dei seguenti modi:
   + Scegli **Existing service role (Ruolo di servizio esistente)**.
   + Scegli il tuo ruolo CodePipeline di servizio esistente. Questo ruolo deve disporre dell'autorizzazione `codecommit:GetRepository` IAM per la tua politica relativa ai ruoli di servizio. Vedi [Aggiungere autorizzazioni al ruolo di CodePipeline servizio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. In **Impostazioni avanzate** non modificare le impostazioni predefinite. Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, procedi come segue:

   1. In **Source provider (Provider origine)**, scegliere **CodeCommit**.

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

   1. In **Nome del ramo, scegli il nome** del tuo ramo.

   1. Assicurati che l'opzione **Avvia la pipeline alla modifica del codice sorgente** sia selezionata.

   1. In **Formato artefatto di output**, scegli **Clone completo** per abilitare l'opzione Git clone per il repository di origine. Solo le azioni fornite da CodeBuild possono utilizzare l'opzione Git clone. 

   Scegli **Next (Successivo)**.

1. Nel **passaggio 4: Aggiungere la fase di compilazione**, procedi come segue:

   1. In **Build provider (Provider compilazione)**, scegli **AWS CodeBuild**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. **Per **Image**, scegliete: 5.0aws/codebuild/standard.**

   1. Per **Service Role (Ruolo del servizio)**, scegli **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Annota il nome del tuo ruolo di servizio. CodeBuild Avrai bisogno del nome del ruolo per l'ultimo passaggio di questo tutorial.

   1. In **Buildspec**, per **Build specifications** (Specifiche di compilazione), scegli **Insert build commands (Inserisci comandi di compilazione)**. Scegli **Passa all'editor**, quindi in **Comandi di creazione** incolla il codice seguente.

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git describe --all
        #post_build:
          #commands:
            # - command
            # - command
      #artifacts:
        #files:
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Scegli **Continua a CodePipeline**. Questo ti riporta alla CodePipeline console e crea un CodeBuild progetto che utilizza i comandi di build per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.**

## Passaggio 3: Aggiornare la politica del ruolo CodeBuild di servizio per clonare il repository
<a name="tutorials-codecommit-gitclone-rolepolicy"></a>

L'esecuzione iniziale della pipeline avrà esito negativo perché è necessario aggiornare il ruolo di CodeBuild servizio con le autorizzazioni per l'estrazione dal repository.

Aggiungi l'autorizzazione `codecommit:GitPull` IAM alla tua policy sui ruoli di servizio. Per istruzioni su come aggiornare la policy nella console IAM, consulta[Aggiungi le CodeBuild GitClone autorizzazioni per le azioni di origine CodeCommit](troubleshooting.md#codebuild-role-codecommitclone).

## Passaggio 4: Visualizza i comandi del repository nell'output della build
<a name="tutorials-codecommit-gitclone-view"></a>

**Per visualizzare l'output della build**

1. Quando il ruolo di servizio viene aggiornato correttamente, scegli **Riprova** nella CodeBuild fase non riuscita.

1. Dopo che la pipeline è stata eseguita correttamente, nella fase di compilazione corretta, scegli **Visualizza** dettagli.

   Nella pagina dei dettagli, scegli la scheda **Registri.** Visualizza l'output della CodeBuild build. I comandi restituiscono il valore della variabile inserita.

   I comandi generano il contenuto del `README.md` file, elencano i file nella directory, clonano il repository, visualizzano il registro ed eseguono. `git describe --all` 

# Tutorial: creare una pipeline con azioni AWS CloudFormation StackSets di distribuzione
<a name="tutorials-stackset-deployment"></a>

In questo tutorial, utilizzi la AWS CodePipeline console per creare una pipeline con azioni di distribuzione per la creazione di uno stack set e la creazione di istanze di stack. Quando la pipeline viene eseguita, il modello crea uno stack set e inoltre crea e aggiorna le istanze in cui viene distribuito lo stack set.

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

Esistono due modi per gestire le autorizzazioni per uno stack set: ruoli IAM autogestiti e ruoli IAM gestiti. AWS Questo tutorial fornisce esempi di autorizzazioni autogestite.

Per utilizzare nel modo più efficace gli Stacksets in CodePipeline, è necessario avere una chiara comprensione dei concetti alla base CloudFormation StackSets e del loro funzionamento. Consulta [StackSets i concetti](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html) nella Guida per l'*AWS CloudFormation utente*.

**Topics**
+ [

## Prerequisiti
](#tutorials-stackset-deployment-prereq)
+ [

## Fase 1: Caricare il AWS CloudFormation modello di esempio e il file dei parametri
](#tutorials-stackset-deployment-upload)
+ [

## Fase 2: creazione della pipeline
](#tutorials-stackset-action-pipeline)
+ [

## Fase 3: Visualizza la distribuzione iniziale
](#tutorials-stackset-action-initial)
+ [

## Fase 4: Aggiungere un' CloudFormationStackInstances azione
](#tutorials-stacksets-instances)
+ [

## Fase 5: Visualizza le risorse dello stack set per la distribuzione
](#tutorials-stacksets-view)
+ [

## Passaggio 6: Effettua un aggiornamento al tuo set di stack
](#tutorials-stacksets-update)

## Prerequisiti
<a name="tutorials-stackset-deployment-prereq"></a>

Per le operazioni di stack set, si utilizzano due account diversi: un account di amministrazione e un account di destinazione. I set di stack vengono creati nell'account amministratore. Crei singoli stack che appartengono a uno stack impostato nell'account di destinazione.

**Per creare un ruolo di amministratore con il tuo account amministratore**
+ Segui le istruzioni riportate in [Configurare le autorizzazioni di base per le operazioni relative allo stack set](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup). Il tuo ruolo deve avere un nome. **`AWSCloudFormationStackSetAdministrationRole`**

**Per creare un ruolo di servizio nell'account di destinazione**
+ Crea un ruolo di servizio nell'account di destinazione che consideri affidabile l'account amministratore. Segui le istruzioni in [Configurare le autorizzazioni di base per le operazioni di stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup) set. Il tuo ruolo deve avere un nome. **`AWSCloudFormationStackSetExecutionRole`** 

## Fase 1: Caricare il AWS CloudFormation modello di esempio e il file dei parametri
<a name="tutorials-stackset-deployment-upload"></a>

Crea un bucket sorgente per il modello e i file dei parametri del set di stack. Scarica il file AWS CloudFormation modello di esempio, configura un file di parametri, quindi comprimi i file prima di caricarli nel bucket di origine S3.

**Nota**  
Assicurati di comprimere i file sorgente prima di caricarli nel bucket di origine S3, anche se l'unico file sorgente è il modello.



**Per creare un bucket sorgente S3**

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

1. Seleziona **Crea bucket**.

1. In **Nome bucket**, inserisci un nome del bucket.

   In **Regione**, scegli la regione in cui desideri creare la tua pipeline. Seleziona **Crea bucket**.

1. Dopo aver creato il bucket, viene visualizzato un banner di successo. Scegliere **Go to bucket details (Vai ai dettagli del bucket)**.

1. Nella scheda **Properties (Proprietà)** scegliere **Versioning (Funzione Versioni multiple)**. Scegliere **Enable versioning (Abilita funzione Versioni multiple)**, quindi scegliere **Save (Salva)**.

**Per creare il file AWS CloudFormation modello**

1. Scarica il seguente file modello di esempio per generare la CloudTrail configurazione per i set di stack:[https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml](https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml).

1. Salva il file con nome `template.yml`.

**Per creare il file parameters.txt**

1. Crea un file con i parametri per la tua distribuzione. I parametri sono valori che desideri aggiornare nello stack in fase di esecuzione. Il seguente file di esempio aggiorna i parametri del modello per il set di stack per abilitare la convalida della registrazione e gli eventi globali.

   ```
   [
     {
       "ParameterKey": "EnableLogFileValidation",
       "ParameterValue": "true"
     }, 
     {
       "ParameterKey": "IncludeGlobalEvents",
       "ParameterValue": "true"
     }
   ]
   ```

1. Salva il file con nome `parameters.txt`.

**Per creare il file accounts.txt**

1. Create un file con gli account in cui desiderate creare le istanze, come illustrato nel seguente file di esempio.

   ```
   [
       "111111222222","333333444444"
   ]
   ```

1. Salva il file con nome `accounts.txt`.

**Per creare e caricare file sorgente**

1. Combina i file in un unico file ZIP. I tuoi file dovrebbero avere questo aspetto nel tuo file ZIP.

   ```
   template.yml
   parameters.txt
   accounts.txt
   ```

1. Carica il file ZIP nel tuo bucket S3. Questo file è l'elemento di origine creato dalla procedura guidata Create **Pipeline per** l'azione di distribuzione in. CodePipeline

## Fase 2: creazione della pipeline
<a name="tutorials-stackset-action-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con un'azione sorgente S3 in cui l'artefatto di origine è il file modello e tutti i file sorgente di supporto.
+ Una fase di distribuzione con un'azione di distribuzione del set di CloudFormation stack che crea lo stack set.
+ Una fase di distribuzione con un'azione di distribuzione di istanze in CloudFormation stack che crea gli stack e le istanze all'interno degli account di destinazione.

**Per creare una pipeline con un'azione CloudFormationStackSet**

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

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyStackSetsPipeline**

1. In **Tipo di tubazione**, scegliete **V1** ai fini di questo tutorial. Puoi anche scegliere **V2**; tuttavia, tieni presente che i tipi di tubazione differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta [Tipi di tubazioni](pipeline-types.md).

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

1. Nel negozio **Artifact**, lascia le impostazioni predefinite.
**Nota**  
Non si tratta del bucket di origine per il codice sorgente, ma dell'archivio artefatti per la pipeline. È richiesto un archivio artefatti separato, ad esempio un bucket S3, per ogni pipeline. Quando crei o modifichi una pipeline, devi avere un bucket di artefatti nella regione della pipeline e un bucket di artefatti per regione in cui stai eseguendo un'azione. AWS   
Per ulteriori informazioni, consultare [Artefatti di input e output](welcome-introducing-artifacts.md) e [CodePipeline riferimento alla struttura della tubazione](reference-pipeline-structure.md).

   Scegli **Next (Successivo)**.

1. Nella pagina **Fase 3: Aggiungi fase di origine**, in **Provider di origine**, scegli **Amazon S3**.

1. In **Bucket, inserisci il bucket** sorgente S3 che hai creato per questo tutorial, ad esempio. `BucketName` Nella **chiave oggetto S3**, inserisci il percorso e il nome del file per il tuo file ZIP, ad esempio. `MyFiles.zip`

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

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

   Scegli **Next (Successivo)**.

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

   Scegli **Next (Successivo)**.

1. Nel **passaggio 6: aggiungi la fase di implementazione**:

   1. In **Deploy provider**, scegli **AWS CloudFormation Stack** Set.

   1. In **Stack set name, inserisci un nome** per lo stack set. Questo è il nome dello stack set creato dal modello.
**Nota**  
Prendi nota del nome del tuo set di stack. Lo utilizzerai quando aggiungerai la seconda azione di StackSets distribuzione alla tua pipeline.

   1. In **Percorso del modello**, inserisci il nome dell'artefatto e il percorso del file in cui hai caricato il file modello. Ad esempio, immettete quanto segue utilizzando il nome dell'artefatto di origine predefinito. `SourceArtifact`

      ```
      SourceArtifact::template.yml
      ```

   1. In **Destinazioni di distribuzione**, inserisci il nome dell'artefatto e il percorso del file in cui hai caricato il file degli account. Ad esempio, inserisci quanto segue utilizzando il nome dell'artefatto di origine predefinito. `SourceArtifact`

      ```
      SourceArtifact::accounts.txt
      ```

   1. In **Deployment target Regioni AWS**, inserisci una regione per la distribuzione dell'istanza dello stack iniziale, ad esempio. `us-east-1`

   1. Espandi le **opzioni di distribuzione**. In **Parametri**, inserisci il nome dell'artefatto e il percorso del file in cui hai caricato il file dei parametri. Ad esempio, inserite quanto segue utilizzando il nome predefinito dell'artefatto di origine. `SourceArtifact`

      ```
      SourceArtifact::parameters.txt
      ```

      Per immettere i parametri come input letterale anziché come percorso di file, immettete quanto segue:

      ```
      ParameterKey=EnableLogFileValidation,ParameterValue=true
      ParameterKey=IncludeGlobalEvents,ParameterValue=true
      ```

   1. In **Capabilities**, scegliete CAPABILITY\$1IAM e CAPABILITY\$1NAMED\$1IAM.

   1. Nel **modello di autorizzazione,** scegliete SELF\$1MANAGED.

   1. In **Percentuale di tolleranza ai guasti, immettete**. `20`

   1. In **Percentuale simultanea massima**, immettere`25`.

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

   1. Nel **Passo 7: Revisione**, scegliete **Crea pipeline**. Viene visualizzata la pipeline. 

   1. Consenti l'esecuzione della pipeline. 

## Fase 3: Visualizza la distribuzione iniziale
<a name="tutorials-stackset-action-initial"></a>

Visualizza le risorse e lo stato della distribuzione iniziale. Dopo aver verificato che la distribuzione abbia creato correttamente il set di stack, puoi aggiungere la seconda azione alla fase di **distribuzione**.

**Per visualizzare le risorse**

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Scegli l' CloudFormation azione relativa all'**CloudFormationStackSet**azione nella tua pipeline. Il modello, le risorse e gli eventi per il tuo set di stack vengono visualizzati nella CloudFormation console.

1. Nel pannello di navigazione a sinistra, scegli **StackSets**. Nell'elenco, scegli il nuovo set di stack.

1. Scegli la scheda **Stack instances**. Verifica che un'istanza stack per ogni account fornito sia stata creata nella regione us-east-1. Verifica che lo stato di ogni istanza dello stack sia. `CURRENT`

## Fase 4: Aggiungere un' CloudFormationStackInstances azione
<a name="tutorials-stacksets-instances"></a>

Crea un'azione successiva nella tua pipeline che CloudFormation StackSets consenta di creare le restanti istanze dello stack.

**Per creare un'azione successiva nella tua pipeline**

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   In **Pipelines (Pipeline)**, seleziona la pipeline e scegli **View (Visualizza)**. Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Scegli questa opzione per modificare la pipeline. La pipeline viene visualizzata in modalità **Modifica**. 

1. **Nella fase di **distribuzione**, scegliete Modifica.**

1. Nell'azione **AWS CloudFormation Stack Set** deploy, scegli **Aggiungi** gruppo di azioni.

1. Nella pagina **Modifica azione**, aggiungi i dettagli dell'azione:

   1. In **Nome azione**, inserisci un nome per l'azione.

   1. Nel **provider Action**, scegli **AWS CloudFormation Stack Instances**.

   1. In **Input artefacts**, scegli. **SourceArtifact**

   1. In **Stack set name, inserite il nome** del set di stack. Questo è il nome dello stack set che hai fornito nella prima azione.

   1. In **Deployment targets**, inserisci il nome dell'artefatto e il percorso del file in cui hai caricato il file degli account. Ad esempio, inserisci quanto segue utilizzando il nome dell'artefatto di origine predefinito. `SourceArtifact`

      ```
      SourceArtifact::accounts.txt
      ```

   1. In **Deployment target Regioni AWS**, inserisci le regioni per la distribuzione delle istanze dello stack rimanenti, ad esempio e come `us-east-2` segue: `eu-central-1`

      ```
      us-east2, eu-central-1
      ```

   1. In **Percentuale di tolleranza agli errori**, inserisci. `20`

   1. In **Percentuale simultanea massima**, immettere`25`.

   1. Scegli **Save** (Salva).

   1. .Rilasciare manualmente una modifica. La pipeline aggiornata viene visualizzata con due azioni nella fase di distribuzione.

## Fase 5: Visualizza le risorse dello stack set per la distribuzione
<a name="tutorials-stacksets-view"></a>

È possibile visualizzare le risorse e lo stato della distribuzione dello stack set.

**Per visualizzare le risorse**

1. Apri la CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. **In **Pipelines**, scegli la pipeline, quindi scegli Visualizza.** Il diagramma mostra le fasi di distribuzione e di origine della pipeline.

1. Scegli l' CloudFormation azione relativa all'**`AWS CloudFormation Stack Instances`**azione nella tua pipeline. Il modello, le risorse e gli eventi per il tuo set di stack vengono visualizzati nella CloudFormation console.

1. Nel pannello di navigazione a sinistra, scegli **StackSets**. Nell'elenco, scegli il tuo set di stack.

1. Scegli la scheda **Stack instances**. Verifica che tutte le istanze stack rimanenti per ogni account che hai fornito siano state create o aggiornate nelle regioni previste. Verifica che lo stato di ogni istanza dello stack sia. `CURRENT`

## Passaggio 6: Effettua un aggiornamento al tuo set di stack
<a name="tutorials-stacksets-update"></a>

Aggiorna il tuo set di stack e distribuisci l'aggiornamento alle istanze. In questo esempio, apporti anche una modifica agli obiettivi di distribuzione che desideri designare per l'aggiornamento. Le istanze che non fanno parte dell'aggiornamento passano a uno stato obsoleto.

1. Apri la CodePipeline console all'indirizzo. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

1. **In **Pipeline**, scegli la tua pipeline, quindi scegli Modifica.** **Nella fase di **distribuzione, scegli** Modifica.**

1. Scegli di modificare l'azione **AWS CloudFormation Stack Set** nella tua pipeline. In **Descrizione**, sovrascrivi la descrizione esistente con una nuova descrizione per lo stack set.

1. Scegli di modificare l'azione **AWS CloudFormation Stack Instances** nella tua pipeline. In **Deployment target Regioni AWS**, elimina il `us-east-2` valore che è stato inserito al momento della creazione dell'azione.

1. Salvare le modifiche. Scegli **Release change** per eseguire la pipeline.

1. Apri la tua azione in CloudFormation. Scegli la scheda **StackSet Informazioni**. Nella **StackSet descrizione**, verifica che sia mostrata la nuova descrizione.

1. Scegli la scheda **Stack instances.** In **Status**, verifica che lo stato delle istanze dello stack in us-east-2 sia. `OUTDATED`

# Tutorial: crea una regola di controllo variabile per una pipeline come condizione di ingresso
<a name="tutorials-varcheckrule"></a>

In questo tutorial, configurerai una pipeline che distribuisce continuamente i file, GitHub utilizzandola come source action provider nella fase di origine. La pipeline completata rileva le modifiche quando si modificano i file di origine nel repository di origine. La pipeline viene eseguita e quindi confronta le variabili di output con il nome del repository di origine e il nome del ramo forniti nella condizione per l'accesso alla fase di compilazione.

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

**Importante**  
Molte delle azioni che aggiungi alla pipeline in questa procedura coinvolgono AWS risorse che devi creare prima di creare la pipeline. AWS le risorse per le tue azioni di origine devono sempre essere create nella stessa AWS regione in cui crei la pipeline. Ad esempio, se crei la pipeline nella regione Stati Uniti orientali (Ohio), il tuo CodeCommit repository deve trovarsi nella regione Stati Uniti orientali (Ohio).   
Puoi aggiungere azioni interregionali quando crei la pipeline. AWS le risorse per le azioni interregionali devono trovarsi nella stessa AWS regione in cui intendi eseguire l'azione. Per ulteriori informazioni, consulta [Aggiungere un'azione interregionale in CodePipeline](actions-create-cross-region.md).

Questo esempio utilizza la pipeline di esempio con un'azione di origine GitHub (Version2) e un'azione di CodeBuild compilazione in cui la condizione di ingresso per la fase di creazione verificherà la presenza di variabili.

## Prerequisiti
<a name="tutorials-varcheckrule-prereq"></a>

Prima di iniziare è necessario:
+ Crea un GitHub repository con il tuo account. GitHub 
+ Tieni a portata di mano GitHub le tue credenziali. Quando utilizzi il Console di gestione AWS per configurare una connessione, ti viene chiesto di accedere con GitHub le tue credenziali. 
+ Una connessione al tuo repository da configurare GitHub (tramite GitHub app) come azione sorgente per la tua pipeline. Per creare una connessione al tuo GitHub repository, vedi. [GitHub connessioni](connections-github.md)

## Passaggio 1: Crea un file sorgente di esempio e aggiungilo al tuo repository GitHub
<a name="tutorials-varcheckrule-push"></a>

In questa sezione, crei e aggiungi il tuo file sorgente di esempio al repository utilizzato dalla pipeline per la fase di origine. In questo esempio, produci e aggiungi quanto segue: 
+ Un file `README.md`.

Dopo aver creato il GitHub repository, segui questi passaggi per aggiungere il file README.

1. Accedi al tuo GitHub repository e scegli il tuo repository.

1. Per creare un nuovo file, scegli **Aggiungi file**, quindi scegli **Crea nuovo** file. Assegna un nome al file `README.md` e aggiungi il testo seguente.

   ```
   This is a GitHub repository!
   ```

1. Scegliere **Commit changes (Applica modifiche)**. Ai fini di questo tutorial, aggiungi un messaggio di commit che contenga la parola in maiuscolo «Update», come nell'esempio seguente:

   ```
   Update to source files
   ```
**Nota**  
Il controllo delle regole per le stringhe fa distinzione tra maiuscole e minuscole.

   Assicurati che il file `README.md` si trovi al livello root del repository.

## Fase 2: creazione della pipeline
<a name="tutorials-varcheckrule-create-pipeline"></a>

In questa sezione, andrai a creare una pipeline con le operazioni seguenti:
+ Una fase di origine con una connessione al GitHub repository e all'azione.
+ Una fase di CodeBuild compilazione in cui la fase ha una condizione On Entry configurata per la regola di controllo variabile.

**Per creare una pipeline con la procedura guidata**

1. Accedi alla CodePipeline console all'indirizzo [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

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

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

1. Nel **Passaggio 2: Scegliete le impostazioni della pipeline**, in **Nome della tubazione**, immettete. **MyVarCheckPipeline**

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

1. In **Service Role (Ruolo del servizio)**, scegliere **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Se scegli invece di utilizzare il tuo ruolo di CodePipeline servizio esistente, assicurati di aver aggiunto l'autorizzazione `codeconnections:UseConnection` IAM alla tua politica sui ruoli di servizio. Per istruzioni sul ruolo CodePipeline di servizio, consulta [Aggiungere autorizzazioni al ruolo CodePipeline di servizio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. In **Impostazioni avanzate** non modificare le impostazioni predefinite.

   Scegli **Next (Successivo)**.

1. Nella pagina **Passaggio 3: Aggiungi fase di origine**, aggiungi una fase di origine:

   1. In **Source provider**, scegli **GitHub(tramite GitHub app)**.

   1. In **Connessione**, scegli una connessione esistente o creane una nuova. Per creare o gestire una connessione per l'azione GitHub sorgente, consulta[GitHub connessioni](connections-github.md).

   1. In **Repository name (Nome repository)**, scegli il nome del repository GitHub .

   1. In **Nome del ramo**, scegli il ramo del repository che desideri utilizzare.

   1. Assicurati che l'opzione **Nessun trigger** sia selezionata.

   Scegli **Next (Successivo)**.

1. Nel **passaggio 4: Aggiungi fase di costruzione**, aggiungi una fase di compilazione:

   1. In **Build provider (Provider compilazione)**, scegli **AWS CodeBuild**. Consenti a **Region (Regione)** di preimpostarsi sulla regione della pipeline.

   1. Seleziona **Crea progetto**.

   1. In **Project name (Nome progetto)** immettere un nome per questo progetto di compilazione.

   1. In **Environment image (Immagine ambiente)**, scegli **Managed image (Immagine gestita)**. In **Operating system** (Sistema operativo), seleziona **Ubuntu**.

   1. In **Runtime**, seleziona **Standard**. **Per **Image**, scegliete: 5.0aws/codebuild/standard.**

   1. Per **Service Role (Ruolo del servizio)**, scegli **New service role (Nuovo ruolo del servizio)**.
**Nota**  
Annota il nome del tuo ruolo di servizio. CodeBuild Avrai bisogno del nome del ruolo per l'ultimo passaggio di questo tutorial.

   1. In **Buildspec**, per **Build specifications** (Specifiche di compilazione), scegli **Insert build commands (Inserisci comandi di compilazione)**. Scegli **Passa all'editor** e incolla quanto segue nei **comandi di compilazione**.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Scegli **Continua a CodePipeline**. Questo ritorna alla CodePipeline console e crea un CodeBuild progetto che utilizza i comandi di compilazione per la configurazione. Il progetto di compilazione utilizza un ruolo di servizio per gestire le Servizio AWS autorizzazioni. Questa operazione potrebbe richiedere un paio di minuti.

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

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

   Scegli **Next (Successivo)**.

1. **Nella pagina Passaggio 6: Aggiungi fase di distribuzione, scegli Ignora fase** **di distribuzione****, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora.** Scegli **Next (Successivo)**.

1. **Nel **Passaggio 7: Revisione**, scegli Crea pipeline.**

## Passaggio 2: modifica la fase di creazione per aggiungere la condizione e la regola
<a name="tutorials-varcheckrule-create-condition"></a>

In questo passaggio, modifichi lo stage per aggiungere una condizione On Entry per la regola di controllo della variabile.

1. Scegli la pipeline, quindi scegli **Modifica**. Scegli di aggiungere una regola di ingresso in fase di costruzione. 

   In **Rule provider**, scegli **VariableCheck**.

1. In **Variabile**, inserisci la variabile o le variabili che desideri controllare. In **Valore**, immettete il valore della stringa da confrontare con la variabile risolta. Nelle schermate di esempio seguenti, viene creata una regola per un controllo «uguale a» e un'altra regola per un controllo «contiene».  
![\[La pagina di creazione della regola per il controllo della variabile «è uguale a»\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/varcheck-tut-create-rule-equals.png)  
![\[La pagina di creazione della regola per il controllo della variabile «contiene»\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/varcheck-tut-create-rule-contains.png)

1. Scegli **Save** (Salva). 

   Seleziona **Fatto**.

## Fase 3: Esegui la pipeline e visualizza le variabili risolte
<a name="tutorials-varcheckrule-run"></a>

In questo passaggio, vengono visualizzati i valori e i risultati risolti della regola di controllo delle variabili.

1. Visualizza l'esecuzione risolta dopo che il controllo delle regole ha avuto esito positivo, come illustrato nell'esempio seguente.  
![\[La corsa riuscita\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/varcheck-tut-run-succeeded.png)

1. Visualizza le informazioni sulle variabili nella scheda **Cronologia**.   
![\[La pagina di cronologia che mostra la scheda Cronologia con le variabili è stata completata con successo\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/varcheck-tut-history.png)