Tutorial: creazione di una semplice pipeline (bucket S3)

Per creare un bucket S3

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

2. Seleziona Crea bucket.

3. 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, utilizzane uno tuo, 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.

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

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

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

7. 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 Linux.zip

      • Se desideri eseguire la distribuzione su istanze Windows Server utilizzando CodeDeploy, scarica l'applicazione di esempio qui: _. SampleApp Windows.zip

      L'applicazione di esempio contiene i seguenti file per la distribuzione con: CodeDeploy

      • appspec.yml— Il file delle specifiche dell'applicazione (AppSpecfile) è un file in formato YAML utilizzato da CodeDeploy per gestire una distribuzione. Per ulteriori informazioni sul AppSpec file, vedere CodeDeploy AppSpec Riferimento ai file nella Guida per l'utente. AWS CodeDeploy

      • index.html— Il file di indice contiene la home page dell'applicazione di esempio distribuita.

      • LICENSE.txt— Il file di licenza contiene le informazioni sulla licenza per l'applicazione di esempio.

      • File per script: l'applicazione di esempio utilizza gli script per scrivere file di testo in una posizione dell'istanza. Viene scritto un file per ciascuno dei diversi eventi del ciclo di vita della CodeDeploy distribuzione come segue:

        • scriptscartella (solo esempio per Linux): la cartella contiene i seguenti script di shell per installare le dipendenze e avviare e arrestare l'applicazione di esempio per la distribuzione automatica:,, e. install_dependencies 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 precedenti distribuzioni di questo esempio e creare una posizione sull'istanza in cui scrivere i nuovi file.

   2. Scarica il file compresso. Non decomprimere il file.

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

   1. Scegli Carica.

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

   3. Scegli Carica.

Per creare un ruolo dell'istanza

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

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

3. Scegliere Crea ruolo.

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

5. Cerca e seleziona la policy denominata AmazonEC2RoleforAWSCodeDeploy.

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

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

   Scegliere Crea ruolo.

Per avviare istanze

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

2. Nella barra di navigazione laterale, scegli Istanze e seleziona Avvia istanze nella parte superiore della pagina.

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

4. 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 al livello gratuito» e può essere trovata in Quick Start.)

5. In Tipo di istanza, scegli il t2.micro tipo idoneo al livello gratuito come configurazione hardware per la tua istanza.

6. In Coppia di chiavi (accesso), scegli una coppia di chiavi o creane una.

   Puoi anche scegliere Procedi senza una coppia di chiavi.

   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.

7. In Impostazioni di rete, procedi come segue.

   In IP Auto-assign 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 origine, scegli Il mio IP.

   • Scegli Aggiungi gruppo di sicurezza, scegli HTTP, quindi in Tipo di origine, scegli Il mio IP.

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

9. In Riepilogo, in Numero di istanze, inserisci2.

10. Scegliere Launch Instance (Avvia istanza).

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

12. È 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 DNS pubblico non è visualizzata, scegli l'Show/Hideicona, quindi seleziona DNS pubblico.)

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

Per creare un ruolo CodeDeploy di servizio

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

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

3. Scegliere Crea ruolo.

4. In Seleziona entità attendibile, scegli Servizio AWS. In Use case (Caso d'uso), scegli CodeDeploy. Scegli CodeDeploy tra le opzioni elencate. Scegli Avanti. La policy gestita AWSCodeDeployRole è già collegata al ruolo.

5. Scegli Avanti.

6. 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 all'indirizzo https://console.aws.amazon.com/codedeploy.

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

3. Scegli Crea applicazione.

4. In Application name (Nome applicazione), immettere MyDemoApplication.

5. In Compute Platform, scegli EC2/On-premises.

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

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

3. 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 l'attendibilità e le autorizzazioni descritte in Creare un ruolo di servizio per. CodeDeploy Per ottenere l'ARN del ruolo di servizio, consulta Ottenere l'ARN del ruolo di servizio (console).

4. In Tipo di distribuzione, scegli. In-place

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

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

7. In Impostazioni di distribuzione, scegli. CodeDeployDefault.OneAtaTime

8. In Load Balancer, assicurati che la casella 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. Dopo aver deselezionato la casella di controllo, le opzioni di bilanciamento del carico non vengono visualizzate.

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

10. Scegliere Create deployment group (Crea gruppo di distribuzione).

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.

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

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

4. Nel passaggio 2: scegli le impostazioni della pipeline, in Nome della pipeline, inserisci. 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.

5. CodePipeline fornisce pipeline di tipo V1 e V2, che si differenziano per caratteristiche e prezzo. Il tipo V2 è l’unico tipo che puoi scegliere nella console. Per ulteriori informazioni, consulta tipi di pipeline. Per informazioni sui prezzi di CodePipeline, vedi Prezzi. https://aws.amazon.com/codepipeline/pricing/

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

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

8. Nella fase 3: Aggiungi la fase di origine, in Source provider, 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. 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 Avanti.

9. Nella fase 4: Aggiungi fase di compilazione, scegli Ignora fase di compilazione, quindi accetta il messaggio di avviso scegliendo nuovamente Ignora. Scegli Avanti.

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

    Scegli Avanti.

11. Nel passaggio 6: Aggiungi la fase di distribuzione, in Deploy provider, scegli. CodeDeploy Il campo Regione per impostazione predefinita è 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.

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

13. La pipeline inizia l'esecuzione. Puoi visualizzare i messaggi di avanzamento, successo e fallimento mentre l' CodePipeline esempio distribuisce una pagina Web in ciascuna delle istanze Amazon EC2 nella distribuzione. CodeDeploy

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.

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

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

4. 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 relativa all'applicazione di esempio caricata nel bucket S3.

Per creare un secondo gruppo di distribuzione in CodeDeploy

1. Apri la CodeDeploy console all'indirizzo. https://console.aws.amazon.com/codedeploy

2. Scegliere Applications (Applicazioni) e selezionare MyDemoApplication nell'elenco di applicazioni.

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

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

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

6. In Tipo di distribuzione, scegli. In-place

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

8. In Deployment configuration (Configurazione della distribuzione), scegliere CodeDeployDefault.OneAtaTime.

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

10. Scegliere Create deployment group (Crea gruppo di distribuzione).

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

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

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

4. Nella pagina Edit (Modifica), scegli + Add stage (Aggiungi fase) per aggiungere una fase subito dopo la fase Deploy (Distribuzione).

   

5. In Aggiungi fase, in Nome fase, inserisciProduction. Selezionare Add stage (Aggiungi fase).

6. Nella nuova fase, scegliere + Add action group (Aggiungi gruppo di operazioni).

7. In Azione Modifica, in Nome azione, inserisciDeploy-Second-Deployment. In Action provider, in Deploy, scegli CodeDeploy.

8. 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. Selezionare Salva.

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

10. 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 AWS CLI rieseguire la pipeline, da un terminale sulla macchina Linux, macOS o Unix locale o da un prompt dei comandi sulla macchina 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.

11. Tornate alla CodePipeline console e nell'elenco delle pipeline, scegliete 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 è riuscita nelle prime due fasi, proprio come prima, ma la fase di produzione mostra che l'azione non è riuscita. Deploy-Second-Deployment

12. Nell'Deploy-Second-Deploymentazione, scegli 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.

Per creare una terza fase per la pipeline

1. Apri una sessione di 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
       }
   }    

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

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

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

   L'esempio seguente mostra il JSON aggiunto al file pipeline.json dopo la fase Deploy. 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
           }
       ]
   }

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

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

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

8. 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. Sebbene l'implementazione abbia esito positivo nelle prime due fasi, proprio come in precedenza, la fase di produzione mostra che l'Deploy-Second-Deploymentazione non è riuscita.

9. Nell'Deploy-Second-Deploymentazione, scegli 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.

Per disattivare e abilitare le transizioni tra le fasi di una pipeline CodePipeline

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

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

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

   

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

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

6. 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 desideri che questa terza fase abbia esito positivo, modifica il gruppo di CodePipelineProductionFleet distribuzione prima di abilitare la transizione e specifica un diverso set 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. Se si creano più istanze EC2, è possibile che vengano addebitati costi aggiuntivi.

Per eliminare le risorse utilizzate in questo tutorial

1. Per ripulire CodePipeline le tue risorse, segui le istruzioni in Eliminare una pipeline in. AWS CodePipeline

2. Per ripulire le CodeDeploy risorse, segui le istruzioni in Per pulire le risorse (console).

3. Per eliminare il bucket S3, segui le istruzioni in Eliminazione o svuotamento di un bucket S3. 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.