Tutorial: creazione di una semplice pipeline (bucket S3)

Per creare un bucket S3

1. Accedi alla console all'indirizzo. AWS Management Console 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, 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.

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 di Windows Server utilizzando CodeDeploy, scarica l'applicazione di esempio qui: _Windows.zip. SampleApp

      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 YAMLformato -utilizzato da per CodeDeploy gestire una distribuzione. Per ulteriori informazioni sul AppSpec file, vedere CodeDeploy AppSpec File reference nella Guida per l'AWS CodeDeploy utente.

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

        • scriptsCartella (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.

   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. Apri la IAM console 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à affidabile, seleziona Servizio AWS. In Scegli un caso d'uso, seleziona EC2, quindi scegli Avanti: Autorizzazioni.

5. Cerca e seleziona il criterio denominato 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 EC2 console Amazon all'indirizzo https://console.aws.amazon.com/ec2/.

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

4. In Immagini dell'applicazione e del sistema operativo (Amazon Machine Image), scegli l'opzione Windows. (Questo AMI è descritto come Microsoft Windows Server 2019 Base ed è etichettato come «Idoneo per il piano gratuito» e può essere trovato in Quick Start.)

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

6. 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 connetterti SSH alle tue istanze, crea o usa una key pair.

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

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

9. In Riepilogo, in Numero di istanze, inserisci.. 2

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. Dopo l'avvio, lo stato dell'istanza diventa e riceve un DNS nome pubblico. running (Se la DNS colonna Pubblico non è visualizzata, scegli l'icona Mostra/Nascondi, quindi seleziona Pubblico DNS).

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. Apri la IAM console 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 CodeDeploytra le opzioni elencate. Scegli Next (Successivo). La policy gestita AWSCodeDeployRole è già collegata al ruolo.

5. Scegli Next (Successivo).

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

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 la fiducia e le autorizzazioni descritte in Creare un ruolo di servizio per. CodeDeploy Per ottenere il ruolo di servizioARN, vedi Get the Service Role ARN (console).

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

5. In Configurazione dell'ambiente, scegli Amazon EC2 Instances. Scegliere Name (Nome) nel campo Key (Chiave) e nel campo Value (Valore), immettere MyCodePipelineDemo.

   Importante

   Qui devi scegliere lo stesso valore per la chiave Name che hai assegnato alle EC2 istanze quando le hai create. 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 di Windows è già configurata con l'SSMagente e verrà ora aggiornata con l' CodeDeploy agente.

7. In Impostazioni di distribuzione, scegliCodeDeployDefault.OneAtaTime.

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

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 AWS Management Console 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. In Step 1: Choose pipeline settings (Fase 1: scelta delle impostazioni della pipeline), in Pipeline name (Nome pipeline), immettere 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.

4. 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. Per informazioni sui prezzi di CodePipeline, consulta la sezione Prezzi.

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

   • Scegli Ruolo di servizio esistente per utilizzare un ruolo di servizio già creato inIAM. In Role name (Nome ruolo), scegli il ruolo del servizio dall'elenco.

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

7. In Step 2: Add source stage (Fase 2: aggiunta della fase di origine), in Source provider (Provider di origine), scegli Amazon S3. In Bucket, immettere il nome del bucket S3 creato in Passaggio 1: crea un bucket sorgente 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 Next (Successivo).

8. In Step 3: Add build stage (Fase 3: aggiunta della fase di compilazione), scegli Skip build stage (Ignora fase di compilazione) e quindi accetta il messaggio di avviso scegliendo Skip (Ignora). Scegli Next (Successivo).

9. Nel passaggio 4: 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.

10. In Step 5: Review (Fase 5: revisione), esaminare le informazioni e quindi scegliere Create pipeline (Crea pipeline).

11. 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 EC2 istanze Amazon della 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). Verrà aperta la console. CodeDeploy

3. Nella scheda Deployment group (Gruppo di distribuzione), in Deployment lifecycle events (Eventi del ciclo di vita di distribuzione), scegliere un ID dell'istanza. Viene visualizzata la console di EC2.

4. Nella scheda Descrizione, in Pubblico DNS, copia l'indirizzo e incollalo nella barra degli indirizzi del tuo 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 creare un secondo gruppo di distribuzione in CodeDeploy

1. Apri la CodeDeploy console in 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 di CodeDeploy servizio che hai usato per la distribuzione iniziale (non il ruolo di CodePipeline servizio).

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

7. In Configurazione dell'ambiente, scegli Amazon EC2 Instances. 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 AWS Management Console e apri la CodePipeline console all'indirizzo http://console.aws.amazon. com/codesuite/codepipeline/home.

2. In Nome, scegli il nome della pipeline che hai creato, 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 Modifica azione, 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. Seleziona 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 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.

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

12. Nell'operazione Deploy-Second-Deployment (Distribuisci-seconda-distribuzione), scegliere Details (Dettagli). Verrai reindirizzato alla pagina per la CodeDeploy distribuzione. In questo caso, l'errore è il risultato della distribuzione del primo gruppo di istanze su tutte le EC2 istanze, 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 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 reindirizzarli JSON direttamente in un file con il get-pipeline comando seguente:

   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 l'JSONaggiunta 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
           }
       ]
   }

5. Se state lavorando con la struttura della pipeline recuperata utilizzando il get-pipeline comando, dovete rimuovere le righe dal file. metadata 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. Eseguite il update-pipeline comando, specificando il JSON file di pipeline, in modo simile 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 MyFirstPipelinedall'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.

9. 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 su tutte le EC2 istanze, 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 disabilitare e abilitare le transizioni tra le fasi di una pipeline CodePipeline

1. Apri la CodePipeline console e scegli MyFirstPipelinedall'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 set diverso di EC2 istanze in cui viene distribuita l'applicazione. Per ulteriori informazioni su come eseguire questa operazione, consulta Modifica delle impostazioni del gruppo di distribuzione. Se crei più EC2 istanze, potresti incorrere in costi aggiuntivi.

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

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 .