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à.
# Integrazione con altri AWS servizi
CodeDeploy è integrato con i seguenti AWS servizi:
| | |
| --- |--- |
| Amazon CloudWatch | [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/) è un servizio di monitoraggio delle risorse AWS cloud e delle applicazioni su cui esegui AWS. Puoi usare Amazon CloudWatch per raccogliere e tracciare metriche, raccogliere e monitorare file di registro e impostare allarmi. CodeDeploy supporta i seguenti strumenti: CloudWatch [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) |
| Amazon EC2 Auto Scaling | CodeDeploy supporta [Amazon EC2 Auto](https://aws.amazon.com/autoscaling) Scaling. Questo AWS servizio può avviare automaticamente istanze Amazon EC2 in base a criteri specificati, ad esempio:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) Puoi scalare orizzontalmente un gruppo di istanze Amazon EC2 ogni volta che ne hai bisogno e poi utilizzarle CodeDeploy per distribuire automaticamente le revisioni delle applicazioni. Amazon EC2 Auto Scaling termina le istanze Amazon EC2 quando non sono più necessarie. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) |
| Amazon Elastic Container Service | Puoi utilizzarla CodeDeploy per distribuire un'applicazione containerizzata Amazon ECS come set di attività. CodeDeploy esegue una blue/green distribuzione installando una versione aggiornata dell'applicazione come nuovo set di attività sostitutivo. CodeDeploy reindirizza il traffico di produzione dal set di attività dell'applicazione originale al set di attività sostitutivo. Il set di attività originale viene terminato una volta completata l'implementazione. Per ulteriori informazioni su Amazon ECS, consulta [Amazon Elastic Container Service](https://aws.amazon.com/ecs/). Puoi gestire il modo in cui il traffico viene spostato verso il set di attività aggiornato durante una distribuzione scegliendo una configurazione canaria, lineare o. all-at-once Per ulteriori informazioni sulle distribuzioni di Amazon ECS, consulta [Distribuzioni su una piattaforma di calcolo Amazon](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/deployment-steps-ecs.html) ECS. |
| AWS CloudTrail | CodeDeploy è integrato con. [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/) Questo servizio acquisisce le chiamate API effettuate da o per conto del CodeDeploy tuo AWS account e invia i file di log a un bucket Amazon S3 da te specificato. CloudTrailacquisisce le chiamate API dalla CodeDeploy console, dai CodeDeploy comandi tramite o AWS CLI direttamente. CodeDeploy APIs Utilizzando le informazioni raccolte da CloudTrail, è possibile determinare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) |
| AWS Cloud9 | [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/)è un ambiente di sviluppo integrato (IDE) online basato sul cloud che puoi utilizzare per scrivere, eseguire, eseguire il debug e distribuire codice utilizzando solo un browser da una macchina connessa a Internet. AWS Cloud9 include un editor di codice, un debugger, un terminale e strumenti essenziali, come Git e AWS CLI Git. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) Per ulteriori informazioni su AWS Cloud9, consulta [Cos'è AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcom.html) e [Guida introduttiva AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/get-started.html). |
| AWS CodePipeline | [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/) è un servizio di distribuzione continua che può essere utilizzato per modellare, visualizzare e automatizzare le fasi necessarie al rilascio di software in un processo di distribuzione continua. Puoi utilizzare AWS CodePipeline per definire un tuo processo di rilascio in modo che il servizio compili, testi e distribuisca il codice ogni volta che questo viene modificato. Ad esempio, potresti disporre di tre gruppi di distribuzione per un'applicazione: Beta, Gamma e Prod. Puoi impostare una pipeline in modo che ogni volta che viene modificato il codice sorgente, gli aggiornamenti vengano distribuiti a ciascun gruppo di distribuzione singolarmente. È possibile configurare AWS CodePipeline per l'utilizzo CodeDeploy per la distribuzione: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) **È possibile creare l' CodeDeploy applicazione, la distribuzione e il gruppo di distribuzione da utilizzare in un'azione di distribuzione in una fase prima di creare la pipeline o nella procedura guidata Create Pipeline.** Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) |
| AWS Modello di applicazione serverless | AWS Serverless Application Model (AWS SAM) è un modello per definire applicazioni serverless. Si estende CloudFormation per fornire un modo semplificato di definire AWS Lambda funzioni, Amazon API Gateway APIs e tabelle Amazon DynamoDB richieste da un'applicazione serverless. Se utilizzi già AWS SAM, puoi aggiungere preferenze di distribuzione per iniziare CodeDeploy a utilizzare per gestire il modo in cui il traffico viene spostato durante la distribuzione di un'applicazione AWS Lambda. Per ulteriori informazioni, consulta il modello applicativo [AWS serverless](https://github.com/awslabs/serverless-application-model). |
| Elastic Load Balancing | CodeDeploy supporta [Elastic Load Balancing](https://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elastic-load-balancing.html), un servizio che distribuisce il traffico delle applicazioni in entrata su più istanze Amazon EC2. Per quanto riguarda CodeDeploy le implementazioni, i sistemi di bilanciamento del carico impediscono inoltre che il traffico venga indirizzato verso istanze quando non sono pronte, sono attualmente in fase di implementazione o non sono più necessarie come parte di un ambiente. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/integrations-aws.html) |
**Topics**
+ [Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md)
+ [Integrating CodeDeploy with Elastic Load Balancing](integrations-aws-elastic-load-balancing.md)
# Integrazione CodeDeploy con Amazon EC2 Auto Scaling
CodeDeploy supporta Amazon EC2 Auto Scaling AWS , un servizio che avvia automaticamente le istanze Amazon EC2 in base alle condizioni da te definite. Queste condizioni possono includere limiti superati in un intervallo di tempo specificato per l'utilizzo della CPU, le letture o le scritture del disco o il traffico di rete in entrata o in uscita. Amazon EC2 Auto Scaling interrompe le istanze quando non sono più necessarie. Per maggiori informazioni, consulta [What is Amazon EC2 Auto Scaling?](https://docs.aws.amazon.com/autoscaling/latest/userguide/WhatIsAutoScaling.html) nella *Guida per l'utente di Amazon EC2 Auto Scaling*.
Quando vengono lanciate nuove istanze Amazon EC2 come parte di un CodeDeploy gruppo Amazon EC2 Auto Scaling, puoi distribuire automaticamente le tue revisioni alle nuove istanze. Puoi anche coordinare le distribuzioni con istanze Amazon EC2 Auto Scaling registrate CodeDeploy con i sistemi di bilanciamento del carico Elastic Load Balancing. Per ulteriori informazioni, consultare [Integrazione CodeDeploy con Elastic Load Balancing](integrations-aws-elastic-load-balancing.md) e [Configura un sistema di bilanciamento del carico nelle distribuzioni Elastic Load Balancing for Amazon CodeDeploy EC2](deployment-groups-create-load-balancer.md).
**Nota**
Potresti riscontrare problemi se associ più gruppi di distribuzione a un singolo gruppo Amazon EC2 Auto Scaling. Se, ad esempio, una distribuzione ha esito negativo, l'istanza inizierà l'arresto, ma le altre distribuzioni che erano in esecuzione possono richiedere un'ora di tempo per scadere. Per ulteriori informazioni, consulta [Evita di associare più gruppi di distribuzione a un singolo gruppo Amazon EC2 Auto Scaling](troubleshooting-auto-scaling.md#troubleshooting-multiple-depgroups) [Under the hood: CodeDeploy and Amazon EC2 Auto](https://aws.amazon.com/blogs/devops/under-the-hood-aws-codedeploy-and-auto-scaling-integration/) Scaling integration.
**Topics**
+ [Distribuzione di CodeDeploy applicazioni su gruppi Amazon EC2 Auto Scaling](#integrations-aws-auto-scaling-deploy)
+ [Abilitazione delle implementazioni di terminazione durante gli eventi scale-in di Auto Scaling](#integrations-aws-auto-scaling-behaviors-hook-enable)
+ [Come funziona Amazon EC2 Auto Scaling con CodeDeploy](#integrations-aws-auto-scaling-behaviors)
+ [Utilizzo di un'AMI personalizzata con CodeDeploy Amazon EC2 Auto Scaling](#integrations-aws-auto-scaling-custom-ami)
## Distribuzione di CodeDeploy applicazioni su gruppi Amazon EC2 Auto Scaling
Per distribuire una revisione CodeDeploy dell'applicazione in un gruppo Amazon EC2 Auto Scaling:
1. Crea o individua un profilo di istanza IAM che consenta al gruppo Amazon EC2 Auto Scaling di lavorare con Amazon S3. Per ulteriori informazioni, consulta [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md).
**Nota**
Puoi anche utilizzare CodeDeploy per distribuire le revisioni dai GitHub repository ai gruppi Amazon EC2 Auto Scaling. Sebbene le istanze Amazon EC2 richiedano ancora un profilo di istanza IAM, il profilo non necessita di autorizzazioni aggiuntive per la distribuzione da un repository. GitHub
1. Crea o usa un gruppo Amazon EC2 Auto Scaling, specificando il profilo dell'istanza IAM nella configurazione o nel modello di lancio. Per ulteriori informazioni, consulta [il ruolo IAM per le applicazioni eseguite su istanze Amazon EC2](https://docs.aws.amazon.com/autoscaling/ec2/userguide/us-iam-role.html).
1. Crea o individua un ruolo di servizio che CodeDeploy consenta di creare un gruppo di distribuzione che contenga il gruppo Amazon EC2 Auto Scaling.
1. Crea un gruppo di CodeDeploy distribuzione specificando il nome del gruppo Amazon EC2 Auto Scaling, il ruolo del servizio e alcune altre opzioni. Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione per una distribuzione sul posto (console)](deployment-groups-create-in-place.md) o [Crea un gruppo di distribuzione per una distribuzione sul posto (console)](deployment-groups-create-in-place.md).
1. Usalo CodeDeploy per distribuire la tua revisione nel gruppo di distribuzione che contiene il gruppo Amazon EC2 Auto Scaling.
Per ulteriori informazioni, consulta [Tutorial: CodeDeploy Da utilizzare per distribuire un'applicazione in un gruppo di Auto Scaling](tutorials-auto-scaling-group.md).
## Abilitazione delle implementazioni di terminazione durante gli eventi scale-in di Auto Scaling
Una distribuzione con *interruzione è un tipo di CodeDeploy distribuzione* che viene attivata automaticamente quando si verifica un evento di [scalabilità in Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-lifecycle.html#as-lifecycle-scale-in). CodeDeploy esegue la distribuzione di terminazione subito prima che il servizio Auto Scaling termini l'istanza. Durante una distribuzione al termine, CodeDeploy non distribuisce nulla. Genera invece eventi del ciclo di vita, che è possibile collegare ai propri script per abilitare funzionalità di spegnimento personalizzate. Ad esempio, è possibile collegare l'evento del `ApplicationStop` ciclo di vita a uno script che chiude correttamente l'applicazione prima che l'istanza venga terminata.
Per un elenco degli eventi del ciclo di vita generati durante una distribuzione di terminazione, consulta CodeDeploy . [Disponibilità di Lifecycle Event Hook](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-availability)
Se la distribuzione di terminazione fallisce per qualsiasi motivo, CodeDeploy consentirà alla chiusura dell'istanza di procedere. Ciò significa che l'istanza verrà chiusa anche se CodeDeploy non è stato eseguito l'intero set (o nessuno) degli eventi del ciclo di vita fino al completamento.
Se non abiliti le distribuzioni di terminazione, il servizio Auto Scaling interromperà comunque le istanze Amazon EC2 quando si verifica un evento di scalabilità in, ma non genererà eventi del ciclo di vita. CodeDeploy
**Nota**
Indipendentemente dal fatto che tu abiliti o meno le implementazioni di terminazione, se il servizio Auto Scaling termina un'istanza Amazon EC2 mentre è in corso un'implementazione, potrebbe verificarsi CodeDeploy una situazione di gara tra gli eventi del ciclo di vita generati da Auto Scaling e i servizi. CodeDeploy Ad esempio, l'evento del `Terminating` ciclo di vita (generato dal servizio Auto Scaling) potrebbe sovrascrivere `ApplicationStart` l'evento (generato dalla distribuzione). CodeDeploy In questo scenario, è possibile che si verifichi un errore con la chiusura dell'istanza Amazon EC2 o con la distribuzione. CodeDeploy
**Per consentire l'esecuzione di CodeDeploy distribuzioni di terminazione**
+ Seleziona la casella di controllo **Aggiungi un termination hook ai gruppi di Auto Scaling** durante la creazione o l'aggiornamento del gruppo di distribuzione. Per istruzioni, consulta [Crea un gruppo di distribuzione per una distribuzione sul posto (console)](deployment-groups-create-in-place.md) o. [Crea un gruppo di distribuzione per una distribuzione EC2/on-premise (console) blue/green](deployment-groups-create-blue-green.md)
L'attivazione di questa casella di controllo comporta CodeDeploy l'installazione di un [hook del ciclo di vita di Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html) nei gruppi Auto Scaling specificati quando si crea o si aggiorna il gruppo di distribuzione. CodeDeploy Questo hook è chiamato termination *hook e consente le distribuzioni di terminazione*.
**Dopo l'installazione dell'hook di terminazione, si svolge un evento scale-in (terminazione) come segue:**
1. Il servizio Auto Scaling (o semplicemente Auto Scaling) determina che deve verificarsi un evento di scale-in e contatta il servizio EC2 per terminare un'istanza EC2.
1. Il servizio EC2 inizia a terminare l'istanza EC2. L'istanza passa allo `Terminating` stato e quindi allo stato. `Terminating:Wait`
1. Durante`Terminating:Wait`, Auto Scaling esegue tutti gli hook del ciclo di vita collegati al gruppo Auto Scaling, incluso l'hook di terminazione installato da. CodeDeploy
1. L'hook di terminazione invia una notifica alla coda di [Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) da cui viene effettuato il polling. CodeDeploy
1. [Dopo aver ricevuto la notifica, CodeDeploy analizza il messaggio, esegue alcune convalide ed esegue una distribuzione di terminazione.](#integrations-aws-auto-scaling-behaviors-hook-enable)
1. Mentre la distribuzione di terminazione è in esecuzione, CodeDeploy invia battiti cardiaci ogni cinque minuti ad Auto Scaling per informarlo che l'istanza è ancora in fase di elaborazione.
1. Finora, l'istanza EC2 è ancora nello `Terminating:Wait` stato (o forse nello `Warmed:Pending:Wait` stato, se hai abilitato i pool [caldi di gruppo Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/warm-pool-instance-lifecycle.html)).
1. Al termine della distribuzione, CodeDeploy indica il processo di terminazione di Auto Scaling `CONTINUE` to the EC2, indipendentemente dal fatto che l'implementazione di terminazione sia riuscita o meno.
## Come funziona Amazon EC2 Auto Scaling con CodeDeploy
Quando crei o aggiorni un gruppo di CodeDeploy distribuzione per includere un gruppo Auto Scaling, CodeDeploy accede al gruppo Auto Scaling utilizzando il ruolo di CodeDeploy servizio, quindi installa gli hook del [ciclo di vita di Auto Scaling nei gruppi Auto](https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html) Scaling.
**Nota**
Gli *hook del ciclo di vita di Auto Scaling sono diversi dagli eventi del ciclo di vita (chiamati anche hook* *degli eventi del ciclo* di *vita) generati e descritti* nella presente guida. CodeDeploy [AppSpec sezione 'hooks'](reference-appspec-file-structure-hooks.md)
Gli hook del ciclo di vita di Auto Scaling che vengono installati sono: CodeDeploy
+ **Un hook di lancio**: questo hook notifica CodeDeploy che è in corso un evento di [scalabilità orizzontale di Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-lifecycle.html#as-lifecycle-scale-out) e CodeDeploy che è necessario avviare una distribuzione di lancio.
*Durante una distribuzione di lancio,:* CodeDeploy
+ Implementa una revisione dell'applicazione nell'istanza scalabile.
+ Genera eventi del ciclo di vita per indicare lo stato di avanzamento della distribuzione. È possibile collegare questi eventi del ciclo di vita ai propri script per abilitare funzionalità di avvio personalizzate. Per ulteriori informazioni, consulta la tabella in. [Disponibilità di Lifecycle Event Hook](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-availability)
Il launch hook e la distribuzione di avvio associata sono sempre abilitati e non possono essere disattivati.
+ **Un hook di terminazione**: questo hook opzionale notifica CodeDeploy che è in corso un evento di [scale-in Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-lifecycle.html#as-lifecycle-scale-in) e CodeDeploy che è necessario avviare una distribuzione di terminazione.
Durante una *distribuzione con interruzione*, CodeDeploy genera eventi del ciclo di vita per indicare lo stato di avanzamento della chiusura dell'istanza. Per ulteriori informazioni, consulta [Abilitazione delle implementazioni di terminazione durante gli eventi scale-in di Auto Scaling](#integrations-aws-auto-scaling-behaviors-hook-enable).
**Topics**
+ [Dopo aver CodeDeploy installato i lifecycle hook, come vengono utilizzati?](#integrations-aws-auto-scaling-behaviors-hook-usage)
+ [Come vengono CodeDeploy denominati i gruppi Amazon EC2 Auto Scaling](#integrations-aws-auto-scaling-behaviors-naming)
+ [Ordine di esecuzione degli eventi hook del ciclo di vita personalizzati](#integrations-aws-auto-scaling-behaviors-hook-order)
+ [Eventi di scalabilità orizzontale durante una distribuzione](#integrations-aws-auto-scaling-behaviors-mixed-environment)
+ [Eventi di scalabilità durante una distribuzione](#integrations-aws-auto-scaling-behaviors-scale-in)
+ [Ordine degli eventi negli script AWS CloudFormation cfn-init](#integrations-aws-auto-scaling-behaviors-event-order)
### Dopo aver CodeDeploy installato i lifecycle hook, come vengono utilizzati?
Dopo aver installato gli hook del ciclo di vita di avvio e terminazione, vengono utilizzati rispettivamente durante gli eventi di scalabilità orizzontale e di CodeDeploy scalabilità in gruppo Auto Scaling.
**Un evento di scale-out (lancio) si svolge come segue:**
1. Il servizio Auto Scaling (o semplicemente Auto Scaling) determina la necessità di un evento di scalabilità orizzontale e contatta il servizio EC2 per lanciare una nuova istanza EC2.
1. Il servizio EC2 lancia una nuova istanza EC2. L'istanza passa allo `Pending` stato e quindi allo stato. `Pending:Wait`
1. Durante`Pending:Wait`, Auto Scaling esegue tutti gli hook del ciclo di vita collegati al gruppo Auto Scaling, incluso l'hook di avvio installato da. CodeDeploy
1. L'hook di avvio invia una notifica alla [coda di Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) da cui viene effettuato il polling. CodeDeploy
1. [Dopo aver ricevuto la notifica, CodeDeploy analizza il messaggio, esegue alcune convalide e avvia una distribuzione di avvio.](#launch-deployment)
1. Mentre la distribuzione di lancio è in esecuzione, CodeDeploy invia battiti cardiaci ogni cinque minuti ad Auto Scaling per informarlo che l'istanza è ancora in fase di elaborazione.
1. Finora, l'istanza EC2 è ancora nello stato. `Pending:Wait`
1. Al termine dell'implementazione, CodeDeploy indica Auto Scaling su uno dei `CONTINUE` due `ABANDON` o sul processo di avvio di EC2, a seconda che l'implementazione sia riuscita o meno.
+ Se lo CodeDeploy indica`CONTINUE`, Auto Scaling continua il processo di avvio, aspettando il completamento degli altri hook oppure inserendo l'istanza nello stato `Pending:Proceed` e quindi nello stato. `InService`
+ **Se lo CodeDeploy indica`ABANDON`, Auto Scaling termina l'istanza EC2 e riavvia la procedura di avvio se necessario per soddisfare il numero di istanze desiderato, come definito nell'impostazione Auto Scaling Desired Capacity.**
**Un evento di scale-in (terminazione) si svolge come segue:**
Per informazioni, consulta [Abilitazione delle implementazioni di terminazione durante gli eventi scale-in di Auto Scaling](#integrations-aws-auto-scaling-behaviors-hook-enable).
### Come vengono CodeDeploy denominati i gruppi Amazon EC2 Auto Scaling
Durante blue/green le distribuzioni su una piattaforma di elaborazione EC2/on-premise, hai due opzioni per aggiungere istanze all'ambiente sostitutivo (verde):
+ Utilizzare le istanze esistenti o create manualmente.
+ Utilizza le impostazioni di un gruppo Amazon EC2 Auto Scaling che specifichi per definire e creare istanze in un nuovo gruppo Amazon EC2 Auto Scaling.
Se scegli la seconda opzione, effettua il CodeDeploy provisioning di un nuovo gruppo Amazon EC2 Auto Scaling per te. Viene utilizzata la seguente convenzione per assegnare il nome al gruppo:
```
CodeDeploy_deployment_group_name_deployment_id
```
Ad esempio, se una distribuzione con ID `10` implementa un gruppo di distribuzione denominato`alpha-deployments`, viene denominato il gruppo Amazon EC2 Auto Scaling fornito. `CodeDeploy_alpha-deployments_10` Per ulteriori informazioni, consultare [Crea un gruppo di distribuzione per una distribuzione EC2/on-premise (console) blue/green](deployment-groups-create-blue-green.md) e [GreenFleetProvisioningOption](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GreenFleetProvisioningOption.html).
### Ordine di esecuzione degli eventi hook del ciclo di vita personalizzati
Puoi aggiungere i tuoi hook del ciclo di vita ai gruppi di Amazon EC2 Auto Scaling a cui effettuare le distribuzioni. CodeDeploy Tuttavia, l'ordine in cui vengono eseguiti gli eventi del ciclo di vita personalizzati non può essere predeterminato in relazione agli eventi del ciclo di vita della distribuzione predefiniti. CodeDeploy Ad esempio, se aggiungi un hook del ciclo di vita personalizzato denominato `ReadyForSoftwareInstall` a un gruppo Amazon EC2 Auto Scaling, non puoi sapere in anticipo se verrà eseguito prima del primo o dopo l'ultimo evento del ciclo di vita di distribuzione predefinito. CodeDeploy
*Per informazioni su come aggiungere hook personalizzati per il ciclo di vita a un gruppo Amazon EC2 Auto Scaling[, consulta Adding](https://docs.aws.amazon.com/autoscaling/latest/userguide/lifecycle-hooks.html#adding-lifecycle-hooks) lifecycle hook nella Amazon EC2 Auto Scaling User Guide.*
### Eventi di scalabilità orizzontale durante una distribuzione
Se si verifica un evento di scalabilità orizzontale di Auto Scaling mentre è in corso una distribuzione, le nuove istanze verranno aggiornate con la revisione dell'applicazione precedentemente distribuita, non con la revisione dell'applicazione più recente. Se la distribuzione ha esito positivo, le vecchie istanze e le nuove istanze con scalabilità orizzontale ospiteranno diverse revisioni delle applicazioni. Per aggiornare le istanze con la revisione precedente, avvia CodeDeploy automaticamente una distribuzione successiva (subito dopo la prima) per aggiornare eventuali istanze obsolete. Se desideri modificare questo comportamento predefinito in modo che le istanze EC2 obsolete rimangano nella versione precedente, consulta. [Automatic updates to outdated instances](deployment-groups-configure-advanced-options.md#auto-updates-outdated-instances)
Se desideri sospendere i processi di scalabilità orizzontale di Amazon EC2 Auto Scaling durante le distribuzioni, puoi farlo tramite un'impostazione nello script con cui viene utilizzato per il bilanciamento `common_functions.sh` del carico. CodeDeploy Se`HANDLE_PROCS=true`, i seguenti eventi di Auto Scaling vengono sospesi automaticamente durante il processo di distribuzione:
+ AZRebalance
+ AlarmNotification
+ ScheduledActions
+ ReplaceUnhealthy
**Importante**
Solo il. CodeDeployDefault OneAtATime la configurazione di distribuzione supporta questa funzionalità.
Per ulteriori informazioni sull'utilizzo per `HANDLE_PROCS=true` evitare problemi di distribuzione quando si utilizza Amazon EC2 Auto Scaling[, consulta Avviso importante AutoScaling sulla](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb#important-notice-about-handling-autoscaling-processes) gestione dei [aws-codedeploy-samples](https://github.com/awslabs/aws-codedeploy-samples)processi in on. GitHub
### Eventi di scalabilità durante una distribuzione
Se un gruppo Auto Scaling inizia a scalare mentre è in corso una CodeDeploy distribuzione su quel gruppo Auto Scaling, potrebbe verificarsi una situazione di competizione tra il processo di terminazione (inclusi gli eventi del ciclo di vita della distribuzione di terminazione) e altri eventi del ciclo di vita sull'istanza di CodeDeploy terminazione. CodeDeploy La distribuzione su quell'istanza specifica potrebbe non riuscire se l'istanza viene terminata prima del completamento di tutti gli eventi del ciclo di vita. CodeDeploy Inoltre, l' CodeDeploy implementazione complessiva potrebbe fallire o meno, a seconda di come hai impostato l'impostazione **Minimum healthy hosts** nella configurazione di distribuzione.
### Ordine degli eventi negli script AWS CloudFormation cfn-init
Se si utilizza `cfn-init` (o `cloud-init`) per eseguire gli script sulle istanze basate su Linux appena assegnate, le distribuzioni potrebbero non riuscire a meno che non si controlli scrupolosamente l'ordine degli eventi che si verificano dopo l'avvio dell'istanza.
Questo ordine deve essere:
1. L'istanza appena assegnata viene avviata.
1. Tutti gli script di bootstrap `cfn-init` vengono eseguiti fino al completamento.
1. L'agente inizia. CodeDeploy
1. La revisione più recente dell'applicazione viene distribuita all'istanza.
Se l'ordine degli eventi non è controllato con attenzione, l' CodeDeploy agente potrebbe avviare una distribuzione prima che tutti gli script siano terminati.
Per controllare l'ordine degli eventi, utilizzare una di queste best practice:
+ Installa l' CodeDeploy agente tramite uno `cfn-init` script, inserendolo dopo tutti gli altri script.
+ Includi l' CodeDeploy agente in un'AMI personalizzata e usa uno `cfn-init` script per avviarlo, inserendolo dopo tutti gli altri script.
*Per informazioni sull'utilizzo`cfn-init`, consulta [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-init.html) nella Guida per l'utente.AWS CloudFormation *
## Utilizzo di un'AMI personalizzata con CodeDeploy Amazon EC2 Auto Scaling
Sono disponibili due opzioni per specificare l'AMI di base da utilizzare quando vengono lanciate nuove istanze Amazon EC2 in un gruppo Amazon EC2 Auto Scaling:
+ È possibile specificare un'AMI personalizzata di base su cui sia già installato l' CodeDeploy agente. Poiché l'agente è già installato, questa opzione avvia nuove istanze Amazon EC2 più rapidamente rispetto all'altra opzione. Tuttavia, questa opzione offre una maggiore probabilità che le distribuzioni iniziali delle istanze Amazon EC2 abbiano esito negativo, soprattutto se l' CodeDeploy agente non è aggiornato. Se scegli questa opzione, ti consigliamo di aggiornare regolarmente l' CodeDeploy agente nella tua AMI personalizzata di base.
+ Puoi specificare un'AMI di base in cui non sia installato l' CodeDeploy agente e farlo installare ogni volta che una nuova istanza viene lanciata in un gruppo Amazon EC2 Auto Scaling. Sebbene questa opzione avvii nuove istanze Amazon EC2 più lentamente rispetto all'altra opzione, offre una maggiore probabilità che le distribuzioni iniziali delle istanze abbiano successo. Questa opzione utilizza la versione più recente dell'agente CodeDeploy.
# Integrazione CodeDeploy con Elastic Load Balancing
Durante CodeDeploy le implementazioni, un sistema di bilanciamento del carico impedisce che il traffico Internet venga indirizzato verso istanze che non sono pronte, sono attualmente in fase di implementazione o non sono più necessarie come parte di un ambiente. Il ruolo esatto svolto dal load balancer, tuttavia, dipende dal fatto che venga utilizzato in una distribuzione o in loco. blue/green
**Nota**
L'uso dei sistemi di bilanciamento del carico Elastic Load Balancing è obbligatorio nelle blue/green implementazioni e facoltativo nelle implementazioni sul posto.
## Tipi di sistema di bilanciamento del carico elastico
Elastic Load Balancing offre tre tipi di sistemi di bilanciamento del carico che possono essere utilizzati nelle CodeDeploy distribuzioni: Classic Load Balancer, Application Load Balancer e Network Load Balancer.
Classic Load Balancer
Percorsi e bilanci di carico a livello di trasporto (). TCP/SSL) or the application layer (HTTP/HTTPS Supporta un VPC.
I sistemi Classic Load Balancer non sono supportati nelle distribuzioni di Amazon ECS.
Application Load Balancer
Instrada e fornisce bilanciamento del carico a livello di applicazione (HTTP/HTTPS) e supporta l'instradamento in base al percorso. È possibile instradare le richieste alle porte su ogni istanza EC2 o istanza di container nel virtual private cloud.
I gruppi target di Application Load Balancer devono avere un tipo di destinazione per le implementazioni su istanze EC2 e `instance` per le implementazioni Fargate. `IP` [Per ulteriori informazioni, consulta Target type.](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-type)
Network Load Balancer
Percorsi e bilanci di carico a livello di trasporto (TCP/UDP Layer-4) in base alle informazioni sugli indirizzi estratte dall'intestazione del pacchetto TCP, non dal contenuto del pacchetto. Il Network Load Balancer è in grado di gestire i picchi di traffico, mantenere l'IP sorgente del client e utilizzare un IP fisso per l'intera durata del sistema di bilanciamento del carico.
Per ulteriori informazioni sui sistemi di bilanciamento del carico Elastic Load Balancing, consulta i seguenti argomenti:
+ [Cos'è l'Elastic Load Balancing?](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html)
+ [Cos'è un Classic Load Balancer?](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/introduction.html)
+ [Cos'è un Application Load Balancer?](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)
+ [Cos'è un Network Load Balancer?](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html)
## Implementazioni blu/verdi
Il reindirizzamento del traffico delle istanze dietro un sistema di bilanciamento del carico Elastic Load Balancing è fondamentale per le implementazioni. CodeDeploy blue/green
Durante una blue/green distribuzione, il load balancer consente di indirizzare il traffico verso le nuove istanze in un gruppo di distribuzione in cui è stata distribuita la revisione più recente dell'applicazione (l'ambiente sostitutivo), in base alle regole specificate, e quindi blocca il traffico proveniente dalle vecchie istanze in cui era in esecuzione la revisione precedente dell'applicazione (l'ambiente originale).
Dopo la registrazione delle istanze in un ambiente sostitutivo con uno o più sistemi di bilanciamento del carico, le istanze dell'ambiente originale vengono annullate e, se lo si desidera, terminate.
Per una blue/green distribuzione, puoi specificare uno o più gruppi target Classic Load Balancer, Application Load Balancer o Network Load Balancer nel tuo gruppo di distribuzione. È possibile utilizzare la CodeDeploy console o aggiungere AWS CLI i load balancer a un gruppo di distribuzione.
Per ulteriori informazioni sui sistemi di bilanciamento del carico nelle blue/green distribuzioni, consulta i seguenti argomenti:
+ [Configura un sistema di bilanciamento del carico nelle distribuzioni Elastic Load Balancing for Amazon CodeDeploy EC2](deployment-groups-create-load-balancer.md)
+ [Crea un'applicazione per una blue/green distribuzione (console)](applications-create-blue-green.md)
+ [Crea un gruppo di distribuzione per una distribuzione EC2/on-premise (console) blue/green](deployment-groups-create-blue-green.md)
## Distribuzioni locali
Durante una distribuzione in loco, un sistema di bilanciamento del carico impedisce che il traffico Internet venga instradato a un'istanza che è in fase di distribuzione, quindi rende l'istanza nuovamente disponibile per il traffico una volta completata la distribuzione a quell'istanza.
Se un sistema di bilanciamento del carico non viene utilizzato durante una distribuzione in loco, il traffico Internet potrebbe comunque essere indirizzato a un'istanza durante il processo di distribuzione. Di conseguenza, le applicazioni Web potrebbero risultare ai clienti non funzionanti, incomplete o non aggiornate. Quando si utilizza un sistema di bilanciamento del carico Elastic Load Balancing con una distribuzione sul posto, le istanze di un gruppo di distribuzione vengono cancellate dal load balancer, aggiornate con l'ultima revisione dell'applicazione e quindi registrate nuovamente presso il load balancer come parte dello stesso gruppo di distribuzione dopo il successo della distribuzione. CodeDeploy aspetterà fino a 1 ora prima che l'istanza diventi integra dopo il bilanciamento del carico. Se l'istanza non viene contrassegnata come integra dal load balancer durante il periodo di attesa, passa CodeDeploy all'istanza successiva o fallisce la distribuzione, in base alla configurazione di distribuzione.
Per una distribuzione sul posto, puoi specificare uno o più gruppi target Classic Load Balancer, Application Load Balancer o Network Load Balancer. È possibile specificare i load balancer come parte della configurazione del gruppo di distribuzione oppure utilizzare uno script fornito da per implementare i load balancer. CodeDeploy
### Specificate il sistema di bilanciamento del carico di distribuzione sul posto utilizzando un gruppo di distribuzione
Per aggiungere sistemi di bilanciamento del carico a un gruppo di distribuzione, si utilizza la console o. CodeDeploy AWS CLI Per informazioni su come specificare un sistema di bilanciamento del carico in un gruppo di distribuzione per distribuzioni in loco, consulta i seguenti argomenti:
+ [Crea un'applicazione per un'implementazione sul posto (console)](applications-create-in-place.md)
+ [Crea un gruppo di distribuzione per una distribuzione sul posto (console)](deployment-groups-create-in-place.md)
+ [Configura un sistema di bilanciamento del carico nelle distribuzioni Elastic Load Balancing for Amazon CodeDeploy EC2](deployment-groups-create-load-balancer.md)
### Specificare il sistema di bilanciamento del carico di distribuzione sul posto utilizzando uno script
Utilizza la procedura descritta di seguito per usare script per il ciclo di vita delle distribuzioni per configurare un sistema di bilanciamento del carico per distribuzioni in loco.
**Nota**
È necessario utilizzare il. CodeDeployDefault OneAtATime configurazione di distribuzione solo quando si utilizza uno script per configurare un sistema di bilanciamento del carico per una distribuzione sul posto. Le esecuzioni simultanee non sono supportate e il. CodeDeployDefault OneAtATime l'impostazione garantisce l'esecuzione seriale degli script. Per ulteriori dettagli sulle configurazioni della distribuzione, consulta [Utilizzo delle configurazioni di distribuzione in CodeDeploy](deployment-configurations.md).
Nel repository CodeDeploy Samples su GitHub, forniamo istruzioni ed esempi che puoi adattare per utilizzare i sistemi di bilanciamento del carico CodeDeploy Elastic Load Balancing. Questi repository includono tre script di esempio: `register_with_elb.sh``deregister_from_elb.sh`, e `common_functions.sh` —che forniscono tutto il codice necessario per iniziare. È sufficiente modificare i segnaposto in questi tre script e fare riferimento agli script dal file `appspec.yml`.
Per configurare distribuzioni sul posto con istanze Amazon CodeDeploy EC2 registrate con sistemi di bilanciamento del carico Elastic Load Balancing, procedi come segue:
1. Scarica gli esempi per il tipo di sistema di bilanciamento del carico che desideri utilizzare per una distribuzione in loco:
+ [Classic Load Balancer](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb)
+ [Application Load Balancer [o Network Load](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2) Balancer (lo stesso script può essere usato per entrambi i tipi)](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2)
1. Assicurati che su ciascuna delle tue istanze Amazon EC2 di destinazione sia installata. AWS CLI
1. Assicurati che ciascuna delle tue istanze Amazon EC2 di destinazione abbia un profilo di istanza IAM associato almeno alle autorizzazioni elasticloadbalancing: \$1 e autoscaling: \$1.
1. Includi nella directory del codice sorgente dell'applicazione gli script degli eventi del ciclo di vita della distribuzione (`register_with_elb.sh`, `deregister_from_elb.sh` e `common_functions.sh`).
1. Nella revisione `appspec.yml` per l'applicazione, fornisci le istruzioni per eseguire lo script durante l'evento e lo script durante CodeDeploy l'evento. `register_with_elb.sh` **ApplicationStart`deregister_from_elb.sh`**ApplicationStop****
1. Se l'istanza fa parte di un gruppo Amazon EC2 Auto Scaling, puoi saltare questo passaggio.
Nello script `common_functions.sh`:
+ Se utilizzi [Classic Load Balancer](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb), specifica i nomi dei sistemi di bilanciamento del carico Elastic Load Balancing `ELB_LIST=""` in e apporta le modifiche necessarie alle altre impostazioni di distribuzione nel file.
+ Se utilizzi [Application Load Balancer [o Network Load](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2)](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2) Balancer, specifica i nomi dei gruppi target di Elastic Load Balancing `TARGET_GROUP_LIST=""` in e apporta le modifiche necessarie alle altre impostazioni di distribuzione nel file.
1. Raggruppa il codice sorgente dell'applicazione, `appspec.yml` e gli script degli eventi del ciclo di vita della distribuzione in una revisione dell'applicazione, quindi carica quest'ultima. Implementa la revisione nelle istanze Amazon EC2. Durante la distribuzione, gli script degli eventi del ciclo di vita della distribuzione annulleranno la registrazione dell'istanza Amazon EC2 con il sistema di bilanciamento del carico, attenderanno che la connessione si esaurisca e quindi registreranno nuovamente l'istanza Amazon EC2 con il sistema di bilanciamento del carico al termine della distribuzione.