Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: creazione di una semplice pipeline (bucket S3)
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
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
**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
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
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
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
**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
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)
È 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)
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
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
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).