Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: CodeDeploy Da utilizzare per distribuire un'applicazione in un gruppo di Auto Scaling
In questo tutorial, utilizzerai CodeDeploy per distribuire una revisione dell'applicazione in un gruppo Auto Scaling. Amazon EC2 Auto Scaling avvia le istanze Amazon EC2 utilizzando condizioni predefinite, quindi termina tali istanze quando non sono più necessarie. Amazon EC2 Auto Scaling CodeDeploy può contribuire alla scalabilità garantendo che disponga sempre del numero corretto di istanze Amazon EC2 disponibili per gestire il carico per le distribuzioni. Per informazioni sull' CodeDeployintegrazione di Amazon EC2 Auto Scaling con, consulta. [Integrazione CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md)
**Topics**
+ [Prerequisiti](tutorials-auto-scaling-group-prerequisites.md)
+ [Fase 1: Creare e configurare il gruppo Auto Scaling](tutorials-auto-scaling-group-create-auto-scaling-group.md)
+ [Fase 2: Distribuire l'applicazione nel gruppo Auto Scaling](tutorials-auto-scaling-group-create-deployment.md)
+ [Passaggio 3: verifica i risultati](tutorials-auto-scaling-group-verify.md)
+ [Fase 4: Aumentare il numero di istanze Amazon EC2 nel gruppo Auto Scaling](tutorials-auto-scaling-group-scale-up.md)
+ [Passaggio 5: Controlla nuovamente i risultati](tutorials-auto-scaling-group-reverify.md)
+ [Fase 6: pulizia](tutorials-auto-scaling-group-clean-up.md)
# Prerequisiti
Per seguire questo tutorial:
+ Completa tutti i passaggi[Guida introduttiva con CodeDeploy](getting-started-codedeploy.md), incluse l'impostazione e la configurazione e la AWS CLI creazione di un profilo di istanza IAM (**CodeDeployDemo-EC2-Instance-Profile**) e di un ruolo di servizio (). **CodeDeployDemo** Un *ruolo di servizio* è un tipo speciale di ruolo IAM che concede l'autorizzazione di servizio ad agire per tuo conto.
+ Se crei il tuo gruppo Auto Scaling con un modello di avvio, devi aggiungere le seguenti autorizzazioni:
+ `ec2:RunInstances`
+ `ec2:CreateTags`
+ `iam:PassRole`
Per ulteriori informazioni[Fase 2: Creare un ruolo di servizio](getting-started-create-service-role.md), consulta [Creazione di un modello di lancio per un gruppo Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html) e [Supporto dei modelli di avvio](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-launch-template-permissions.html) nella Guida per l'utente di *Amazon EC2* Auto Scaling.
+ Crea e usa una revisione compatibile con un'istanza di Ubuntu Server e. CodeDeploy Per la tua revisione, puoi eseguire una delle seguenti operazioni:
+ Creare e utilizzare la revisione di esempio in [Passaggio 2: creare una revisione di esempio dell'applicazione](tutorials-on-premises-instance-2-create-sample-revision.md) nel tutorial [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
+ Per creare una tua revisione, consulta[Utilizzo delle revisioni delle applicazioni per CodeDeploy](application-revisions.md).
+ Crea un gruppo di sicurezza denominato **CodeDeployDemo-AS-SG** con la seguente regola **in entrata**:
+ Tipo: HTTP
+ Fonte: Anywhere
Ciò è necessario per visualizzare l'applicazione e verificare il successo dell'implementazione. Per informazioni su come creare un gruppo di sicurezza, consulta [Creazione di un gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) nella guida per l'*utente di Amazon EC2*.
# Fase 1: Creare e configurare il gruppo Auto Scaling
In questo passaggio, creerai un gruppo di Auto Scaling che contiene una singola istanza Amazon Amazon EC2 di Amazon Linux, RHEL o Windows Server. In una fase successiva, indicherai ad Amazon EC2 Auto Scaling di aggiungere un'altra istanza Amazon EC2 CodeDeploy e di distribuirvi la tua revisione.
**Topics**
+ [Per creare e configurare il gruppo Auto Scaling (CLI)](#tutorials-auto-scaling-group-create-auto-scaling-group-cli)
+ [Per creare e configurare il gruppo Auto Scaling (console)](#tutorials-auto-scaling-group-create-auto-scaling-group-console)
## Per creare e configurare il gruppo Auto Scaling (CLI)
1. Chiama il **create-launch-template** comando per creare un modello di lancio di Amazon EC2.
Prima di chiamare questo comando, è necessario l'ID di un AMI che funzioni per questo tutorial, rappresentato dal segnaposto*image-id*. È inoltre necessario il nome di una coppia di chiavi di istanza Amazon EC2 per abilitare l'accesso all'istanza Amazon EC2, rappresentata dal segnaposto. *key-name*
Per ottenere l'ID di un'AMI da usare con questo tutorial:
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. **Nel pannello di navigazione, in Istanze, scegli **Istanze**, quindi scegli **Launch Instance**.**
1. Nella scheda **Quick Start** della pagina **Scegli un'immagine di Amazon Machine**, annota l'ID dell'AMI accanto all'**AMI Amazon Linux 2**, **Red Hat Enterprise Linux 7.1**, **Ubuntu Server 14.04 LTS** o **Microsoft Windows Server** 2012 R2.
**Nota**
Se si dispone di una versione personalizzata di un'AMI compatibile con CodeDeploy, sceglierla qui invece di cercarla usando la scheda **Quick Start (Avvio rapido)**. Per informazioni sull'utilizzo di un'AMI personalizzata con CodeDeploy Amazon EC2 Auto [Utilizzo di un'AMI personalizzata con CodeDeploy Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md#integrations-aws-auto-scaling-custom-ami) Scaling, consulta.
Per la coppia di chiavi dell'istanza Amazon EC2, usa il nome della coppia di chiavi dell'istanza Amazon EC2.
Chiamare il comando **create-launch-template**.
Su macchine Linux, macOS o Unix locali:
```
aws ec2 create-launch-template \
--launch-template-name CodeDeployDemo-AS-Launch-Template \
--launch-template-data file://config.json
```
Il contenuto del file: `config.json`
```
{
"InstanceType":"t1.micro",
"ImageId":"image-id",
"IamInstanceProfile":{
"Name":"CodeDeployDemo-EC2-Instance-Profile"
},
"KeyName":"key-name"
}
```
Nei computer Windows locali:
```
aws ec2 create-launch-template --launch-template-name CodeDeployDemo-AS-Launch-Template --launch-template-data file://config.json
```
Il contenuto del `config.json` file:
```
{
"InstanceType":"t1.micro",
"ImageId":"image-id",
"IamInstanceProfile":{
"Name":"CodeDeployDemo-EC2-Instance-Profile"
},
"KeyName":"key-name"
}
```
Questi comandi, insieme al `config.json` file, creano un modello di avvio di Amazon EC2 denominato CodeDeployDemo-AS-Launch-Template per il gruppo Auto Scaling che verrà creato in un passaggio successivo in base al tipo di istanza Amazon EC2 t1.micro. In base all'input fornito per e `ImageId` `IamInstanceProfile``KeyName`, il modello di lancio specifica anche l'ID AMI, il nome del profilo dell'istanza associato al ruolo IAM da passare alle istanze al momento del lancio e la coppia di chiavi Amazon EC2 da utilizzare per la connessione alle istanze.
1. Chiama il **create-auto-scaling-group** comando per creare un gruppo Auto Scaling. Avrai bisogno del nome di una delle zone di disponibilità in una delle regioni elencate in [Regione e degli endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Riferimenti generali di AWS*, rappresentati dal segnaposto. *availability-zone*
**Nota**
Per visualizzare l'elenco delle zone di disponibilità di una regione, chiamare:
```
aws ec2 describe-availability-zones --region region-name
```
Ad esempio, per visualizzare un elenco di zone di disponibilità nella regione Stati Uniti occidentali (Oregon), chiama:
```
aws ec2 describe-availability-zones --region us-west-2
```
Per l'elenco degli identificatori dei nomi di regione, consultare [Nomi dei bucket del Resource Kit per regione](resource-kit.md#resource-kit-bucket-names).
Su macchine Linux, macOS o Unix locali:
```
aws autoscaling create-auto-scaling-group \
--auto-scaling-group-name CodeDeployDemo-AS-Group \
--launch-template CodeDeployDemo-AS-Launch-Template,Version='$Latest' \
--min-size 1 \
--max-size 1 \
--desired-capacity 1 \
--availability-zones availability-zone \
--tags Key=Name,Value=CodeDeployDemo,PropagateAtLaunch=true
```
Nei computer Windows locali:
```
aws autoscaling create-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --launch-template LaunchTemplateName=CodeDeployDemo-AS-Launch-Template,Version="$Latest" --min-size 1 --max-size 1 --desired-capacity 1 --availability-zones availability-zone --tags Key=Name,Value=CodeDeployDemo,PropagateAtLaunch=true
```
Questi comandi creano un gruppo Auto Scaling denominato in **CodeDeployDemo-AS-Group** base al modello di lancio di Amazon EC2 denominato. **CodeDeployDemo-AS-Launch-Template** Questo gruppo di Auto Scaling ha una sola istanza Amazon EC2 e viene creato nella zona di disponibilità specificata. Ogni istanza in questo gruppo Auto Scaling avrà il tag. `Name=CodeDeployDemo` Il tag verrà utilizzato per l'installazione successiva dell' CodeDeploy agente.
1. Chiamare il comando **describe-auto-scaling-groups** per **CodeDeployDemo-AS-Group**:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].[HealthStatus, LifecycleState]" --output text
```
Non procedere finché i valori restituiti non mostrano `Healthy` e `InService`.
1. L'agente deve essere installato sulle istanze del gruppo Auto Scaling per poter essere utilizzate nelle CodeDeploy distribuzioni. CodeDeploy Installa l' CodeDeploy agente chiamando il **create-association** comando from AWS Systems Manager con i tag aggiunti quando è stato creato il gruppo Auto Scaling.
```
aws ssm create-association \
--name AWS-ConfigureAWSPackage \
--targets Key=tag:Name,Values=CodeDeployDemo \
--parameters action=Install, name=AWSCodeDeployAgent \
--schedule-expression "cron(0 2 ? * SUN *)"
```
Questo comando crea un'associazione in Systems Manager State Manager che installerà l' CodeDeploy agente su tutte le istanze del gruppo Auto Scaling e quindi tenterà di aggiornarlo alle 2:00 ogni domenica mattina. Per ulteriori informazioni sull' CodeDeploy agente, vedere [Lavorare con](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html) l'agente. CodeDeploy Per ulteriori informazioni su Systems Manager, vedere [What is AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
## Per creare e configurare il gruppo Auto Scaling (console)
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nella barra di navigazione globale, assicurati che sia selezionata una delle regioni elencate in [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS* Le risorse di Amazon EC2 Auto Scaling sono legate alla regione specificata CodeDeploy e sono supportate solo in alcune regioni.
1. **Nella barra di navigazione, in **Istanze**, scegli Launch Templates.**
1. Scegli **Crea modello di avvio**.
1. Nella finestra di dialogo **Avvia nome e descrizione del modello**, per **Avvia nome modello**, inserisci**CodeDeployDemo-AS-Launch-Template**. Lascia i valori predefiniti per gli altri campi.
1. Nella finestra di dialogo **Amazon machine image (AMI)**, fai clic sul menu a discesa sotto **AMI**, scegli un AMI che funzioni con questo tutorial:
1. Nella scheda **Quick Start** del menu a discesa **AMI**, scegli una delle seguenti opzioni: **Amazon Linux 2 AMI**, **Red Hat Enterprise Linux 7.1**, **Ubuntu Server 14.04 LTS** o **Microsoft Windows** Server 2012 R2.
**Nota**
Se si dispone di una versione personalizzata di un'AMI compatibile con CodeDeploy, sceglierla qui invece di cercarla usando la scheda **Quick Start (Avvio rapido)**. Per informazioni sull'utilizzo di un'AMI personalizzata con CodeDeploy Amazon EC2 Auto [Utilizzo di un'AMI personalizzata con CodeDeploy Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md#integrations-aws-auto-scaling-custom-ami) Scaling, consulta.
1. **In **Tipo di istanza**, seleziona il menu a discesa e scegli t1.micro.** Puoi utilizzare la barra di ricerca per trovarlo più rapidamente.
1. Nella finestra di dialogo **Key pair (login)**, seleziona **Scegli una coppia di chiavi esistente**. Nell'elenco a discesa **Seleziona una coppia di chiavi**, scegli la coppia di chiavi di istanza Amazon EC2 che hai creato o utilizzato nei passaggi precedenti.
1. Nella finestra di dialogo **Impostazioni di rete**, scegli **Virtual Public Cloud (VPC**).
Nel menu a discesa **Gruppi di sicurezza**, scegli il gruppo di sicurezza che hai creato nella [sezione dei prerequisiti del tutorial](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-auto-scaling-group-prerequisites.html) (). **CodeDeployDemo-AS-SG**
1. Espandi la finestra di dialogo **Dettagli avanzati**. Nel menu a discesa del **profilo dell'istanza IAM**, seleziona il ruolo IAM che hai creato in precedenza (**CodeDeployDemo-EC2-Instance-Profile**) nel **profilo dell'istanza IAM**.
Lascia il resto delle impostazioni predefinite.
1. Scegli **Crea modello di avvio**.
1. Nella finestra di dialogo **Passaggi successivi**, scegliete **Crea gruppo Auto Scaling.**
1. Nella pagina **Scegli il modello di avvio o la configurazione**, per il **nome del gruppo Auto Scaling, digitare**. **CodeDeployDemo-AS-Group**
1. Nella finestra di dialogo **Avvia modello**, il modello di avvio (**CodeDeployDemo-AS-Launch-Template**) deve essere compilato; in caso contrario, selezionalo dal menu a discesa. **Lascia le impostazioni predefinite e scegli Avanti.**
1. Nella **pagina Scegli le opzioni di avvio dell'istanza**, nella sezione **Rete**, per **VPC**, scegli il VPC predefinito. Quindi, per le **zone di disponibilità e le sottoreti**, scegli una sottorete predefinita. È necessario creare un VPC se non è possibile scegliere l'impostazione predefinita. Per ulteriori informazioni, consulta la sezione [Guida introduttiva ad Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html).
1. Nella sezione **Instance type requirements** (Requisiti del tipo di istanza), utilizza l'impostazione di default per semplificare questo passaggio. (Non sovrascrivere il modello di avvio.) Per questo tutorial, avvierai solo le istanze on demand utilizzando il tipo di istanza specificato nel modello di avvio.
1. Scegli **Next** (Avanti) per accedere alla pagina **Configure advanced options** (Configura opzioni avanzate).
1. Mantieni i valori predefiniti e scegli **Avanti**.
1. Nella pagina **Configura la dimensione del gruppo e le politiche di ridimensionamento**, mantieni i valori predefiniti di **dimensione del gruppo** pari a 1. Scegli **Next (Successivo)**.
1. **Salta il passaggio per la configurazione delle notifiche e scegli Avanti.**
1. Nella pagina **Aggiungi tag**, aggiungi un tag da utilizzare per l'installazione successiva dell' CodeDeploy agente. Seleziona **Aggiungi tag**.
1. In **Key (Chiave)**, immettere **Name**.
1. In **Valore**, immetti **CodeDeployDemo**.
Scegli **Next (Successivo)**.
1. Controlla le informazioni sul gruppo Auto Scaling nella pagina **Revisione**, quindi scegli **Crea gruppo Auto Scaling**.
1. Nella barra di navigazione, con **Auto Scaling Groups** selezionato, scegliete**CodeDeployDemo-AS-Group**, quindi scegliete la scheda **Gestione istanze**. Non procedere finché non **InService**viene visualizzato il valore di nella colonna **Lifecycle** e il valore di **Healthy** nella colonna **Health Status**.
1. Installa l' CodeDeploy agente seguendo la procedura descritta in [Installare l' CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install.html) e utilizzando i tag di `Name=CodeDeployDemo` istanza.
# Fase 2: Distribuire l'applicazione nel gruppo Auto Scaling
In questo passaggio, distribuirai la revisione sulla singola istanza Amazon EC2 nel gruppo Auto Scaling.
**Topics**
+ [Per creare la distribuzione (CLI)](#tutorials-auto-scaling-group-create-deployment-cli)
+ [Per creare la distribuzione (console)](#tutorials-auto-scaling-group-create-deployment-console)
## Per creare la distribuzione (CLI)
1. Chiamare il comando **create-application** per creare un'applicazione denominata **SimpleDemoApp**:
```
aws deploy create-application --application-name SimpleDemoApp
```
1. È necessario avere già creato un ruolo del servizio seguendo le istruzioni in [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md). Il ruolo di servizio ti consentirà CodeDeploy di accedere alle tue istanze Amazon EC2 per espandere (leggere) i relativi tag. È necessario l'ARN del ruolo del servizio. Per ottenere l'ARN del ruolo del servizio, seguire le istruzioni contenute in [Ottieni il ruolo di servizio ARN (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Ora che avete un ruolo di servizio ARN, chiamate il **create-deployment-group** comando per creare un gruppo di distribuzione denominato**SimpleDemoDG**, associato all'applicazione denominata**SimpleDemoApp**, utilizzando il gruppo Auto Scaling denominato e la configurazione **CodeDeployDefault.OneAtATime** di distribuzione **CodeDeployDemo-AS-Group** denominata, con il ruolo di servizio specificato ARN.
**Nota**
Il [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando fornisce supporto per la creazione di trigger che comportano l'invio di notifiche Amazon SNS agli abbonati all'argomento su eventi specifici nelle distribuzioni e nelle istanze. Il comando supporta anche opzioni per il rollback automatico delle distribuzioni e l'impostazione di allarmi per interrompere le distribuzioni quando vengono raggiunte le soglie di monitoraggio negli allarmi Amazon. CloudWatch I comandi per queste azioni non sono inclusi in questo tutorial.
Su macchine Linux, macOS o Unix locali:
```
aws deploy create-deployment-group \
--application-name SimpleDemoApp \
--auto-scaling-groups CodeDeployDemo-AS-Group \
--deployment-group-name SimpleDemoDG \
--deployment-config-name CodeDeployDefault.OneAtATime \
--service-role-arn service-role-arn
```
Nei computer Windows locali:
```
aws deploy create-deployment-group --application-name SimpleDemoApp --auto-scaling-groups CodeDeployDemo-AS-Group --deployment-group-name SimpleDemoDG --deployment-config-name CodeDeployDefault.OneAtATime --service-role-arn service-role-arn
```
1. Chiamare il comando **create-deployment** per creare una distribuzione associata all'applicazione denominata **SimpleDemoApp**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime**, il gruppo di distribuzione denominato **SimpleDemoDG** utilizzando la revisione nel percorso specificato.
**Per Amazon Linux e RHEL, istanze Amazon EC2, chiamate da macchine Linux, macOS o Unix locali**
```
aws deploy create-deployment \
--application-name SimpleDemoApp \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name SimpleDemoDG \
--s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Linux.zip
```
*bucket-name*è il nome del bucket Amazon S3 che contiene i file CodeDeploy Resource Kit per la tua regione. Ad esempio, per la regione Stati Uniti orientali (Ohio), sostituisci con. *bucket-name* `aws-codedeploy-us-east-2` Per un elenco dei nomi dei bucket, vedi. [Nomi dei bucket del Resource Kit per regione](resource-kit.md#resource-kit-bucket-names)
**Per Amazon Linux e RHEL, istanze Amazon EC2, chiamate da macchine Windows locali**
```
aws deploy create-deployment --application-name SimpleDemoApp --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name SimpleDemoDG --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Linux.zip
```
*bucket-name*è il nome del bucket Amazon S3 che contiene i file CodeDeploy Resource Kit per la tua regione. Ad esempio, per la regione Stati Uniti orientali (Ohio), sostituisci con. *bucket-name* `aws-codedeploy-us-east-2` Per un elenco dei nomi dei bucket, vedi. [Nomi dei bucket del Resource Kit per regione](resource-kit.md#resource-kit-bucket-names)
**Per istanze Windows Server Amazon EC2, chiamate da macchine Linux, macOS o Unix locali**
```
aws deploy create-deployment \
--application-name SimpleDemoApp \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name SimpleDemoDG \
--s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Windows.zip
```
*bucket-name*è il nome del bucket Amazon S3 che contiene i file CodeDeploy Resource Kit per la tua regione. Ad esempio, per la regione Stati Uniti orientali (Ohio), sostituisci con. *bucket-name* `aws-codedeploy-us-east-2` Per un elenco dei nomi dei bucket, vedi. [Nomi dei bucket del Resource Kit per regione](resource-kit.md#resource-kit-bucket-names)
**Per le istanze Amazon EC2 di Windows Server, chiamate da macchine Windows locali**
```
aws deploy create-deployment --application-name SimpleDemoApp --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name SimpleDemoDG --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Windows.zip
```
*bucket-name*è il nome del bucket Amazon S3 che contiene i file CodeDeploy Resource Kit per la tua regione. Ad esempio, per la regione Stati Uniti orientali (Ohio), sostituisci con. *bucket-name* `aws-codedeploy-us-east-2` Per un elenco dei nomi dei bucket, vedi. [Nomi dei bucket del Resource Kit per regione](resource-kit.md#resource-kit-bucket-names)
**Nota**
Attualmente, CodeDeploy non fornisce una revisione di esempio da distribuire su istanze Amazon EC2 di Ubuntu Server. Per creare una tua revisione, consulta [Utilizzo delle revisioni delle applicazioni per CodeDeploy](application-revisions.md).
1. Chiamare il comando **get-deployment** per verificare che la distribuzione sia stata completata.
Prima di chiamare questo comando, è necessario l'ID della distribuzione che dovrebbe essere stato restituito dalla chiamata al comando **create-deployment**. Per ottenere nuovamente l'ID della distribuzione, chiamare il comando **list-deployments** per l'applicazione **SimpleDemoApp** e il gruppo di distribuzione con nome **SimpleDemoDG**:
```
aws deploy list-deployments --application-name SimpleDemoApp --deployment-group-name SimpleDemoDG --query "deployments" --output text
```
Ora chiamare il comando **get-deployment** usando l'ID della distribuzione:
```
aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.status" --output text
```
Non continuare finché il valore restituito non è `Succeeded`.
## Per creare la distribuzione (console)
1. È necessario avere già creato un ruolo del servizio seguendo le istruzioni in [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md). Il ruolo di servizio consentirà di accedere CodeDeploy alle istanze per espandere (leggere) i relativi tag. Prima di utilizzare la CodeDeploy console per distribuire la revisione dell'applicazione, è necessario il ruolo di servizio ARN. Per ottenere l'ARN del ruolo del servizio, seguire le istruzioni contenute in [Ottieni il ruolo di servizio ARN (console)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Ora che hai il ruolo di servizio ARN, puoi utilizzare la CodeDeploy console per distribuire la revisione dell'applicazione.
[Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.
1. Scegli **Crea applicazione**.
1. Selezionare **Custom application (Applicazione personalizzata)**.
1. In **Application name (Nome applicazione)**, immettere **SimpleDemoApp**.
1. In **Compute platform (Piattaforma di calcolo)**, scegliere **EC2/On-premises**.
1. Scegli **Crea applicazione**.
1. Nella scheda **Deployment groups (Gruppi di distribuzione)**, scegliere **Create deployment group (Crea gruppo di distribuzione)**.
1. In **Deployment group name (Nome del gruppo di distribuzione)**, immettere **SimpleDemoDG**.
1. In **Service Role (Ruolo del servizio)**, scegliere il nome del ruolo del servizio.
1. In **Deployment type (Tipo di distribuzione)**, scegliere **In-place (Locale)**.
1. In **Configurazione ambiente** seleziona **Gruppi Auto Scaling**, quindi scegli. **CodeDeployDemo-AS-Group**
1. **In **Configurazione di distribuzione**, scegliCodeDeployDefault. OneAtATime**.
1. Deselezionare **Enable load balancing (Abilita bilanciamento del carico)**.
1. Scegliere **Create deployment group (Crea gruppo di distribuzione)**.
1. Nella pagina del gruppo di distribuzione, scegliere **Create deployment (Crea distribuzione)**.
1. In **Tipo di revisione**, scegli **La mia applicazione è archiviata in Amazon** S3.
1. In **Revision location (Posizione revisione)**, inserire il percorso dell'applicazione di esempio per il proprio sistema operativo e regione.
**Per Amazon Linux e RHEL, istanze Amazon EC2**
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/tutorials-auto-scaling-group-create-deployment.html)
**Per istanze Windows Server Amazon EC2**
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/tutorials-auto-scaling-group-create-deployment.html)
**Per le istanze di Ubuntu Server Amazon EC2**
Digita la posizione della revisione dell'applicazione personalizzata archiviata in Amazon S3.
1. Lasciare vuoto il campo **Deployment description (Descrizione distribuzione)**.
1. Espandere **Advanced (Avanzate)**.
1. Scegli **Create deployment (Crea distribuzione)**.
**Nota**
Se è visualizzato **Failed (Non riuscito)** al posto di **Succeeded (Riuscito)**, si potrebbero provare le tecniche descritte in [Monitora e risolvi i problemi della distribuzione](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) (usando il nome dell'applicazione **SimpleDemoApp** e il nome del gruppo di distribuzione **SimpleDemoDG**).
# Passaggio 3: verifica i risultati
In questo passaggio, controllerai che la **SimpleDemoApp** revisione sia CodeDeploy stata installata sulla singola istanza Amazon EC2 nel gruppo Auto Scaling.
**Topics**
+ [Per controllare i risultati (CLI)](#tutorials-auto-scaling-group-verify-cli)
+ [Per controllare i risultati (console)](#tutorials-auto-scaling-group-verify-console)
## Per controllare i risultati (CLI)
Innanzitutto, è necessario il DNS pubblico dell'istanza Amazon EC2.
Usa il AWS CLI per ottenere il DNS pubblico dell'istanza Amazon EC2 nel gruppo Auto Scaling chiamando il comando. **describe-instances**
Prima di chiamare questo comando, è necessario l'ID dell'istanza Amazon EC2. Per ottenere l'ID, chiamare **describe-auto-scaling-groups** per **CodeDeployDemo-AS-Group** come effettuato prima:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].InstanceId" --output text
```
Ora chiamare il comando **describe-instances**:
```
aws ec2 describe-instances --instance-id instance-id --query "Reservations[0].Instances[0].PublicDnsName" --output text
```
Il valore restituito è il DNS pubblico dell'istanza Amazon EC2.
Utilizzando un browser Web, mostra la SimpleDemoApp revisione distribuita su quell'istanza Amazon EC2, utilizzando un URL come il seguente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Se vedi la pagina delle congratulazioni, significa che hai implementato CodeDeploy con successo una revisione su una singola istanza Amazon EC2 in un gruppo di Auto Scaling\$1
Successivamente, aggiungerai un'istanza Amazon EC2 al gruppo Auto Scaling. Dopo che Amazon EC2 Auto Scaling avrà aggiunto l'istanza Amazon EC2, distribuirà la revisione sulla nuova CodeDeploy istanza.
## Per controllare i risultati (console)
Innanzitutto, è necessario il DNS pubblico dell'istanza Amazon EC2.
Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
Nel pannello di navigazione di Amazon EC2, in Auto **Scaling, scegli Auto** **Scaling** Groups, quindi scegli la voce. **CodeDeployDemo-AS-Group**
Nella scheda **Istanze**, scegli l'ID dell'istanza Amazon EC2 nell'elenco.
Nella pagina **Instances (Istanze)** nella scheda **Description (Descrizione)** annotare il valore **Public DNS (DNS pubblico)**. Dovrebbe essere simile a quanto segue: **ec2-01-234-567-890.compute-1.amazonaws.com**.
Utilizzando un browser Web, mostra la SimpleDemoApp revisione distribuita su quell'istanza Amazon EC2, utilizzando un URL come il seguente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Se vedi la pagina delle congratulazioni, significa che hai implementato CodeDeploy con successo una revisione su una singola istanza Amazon EC2 in un gruppo di Auto Scaling\$1
Successivamente, aggiungi un'istanza Amazon EC2 al gruppo Auto Scaling. Dopo che Amazon EC2 Auto Scaling avrà aggiunto l'istanza Amazon EC2, distribuirà la revisione nella nuova CodeDeploy istanza Amazon EC2.
# Fase 4: Aumentare il numero di istanze Amazon EC2 nel gruppo Auto Scaling
In questo passaggio, istruisci il gruppo Auto Scaling a creare un'istanza Amazon EC2 aggiuntiva. Dopo che Amazon EC2 Auto Scaling ha creato l' CodeDeploy istanza, distribuisce la revisione su di essa.
**Topics**
+ [Per ridimensionare il numero di istanze Amazon EC2 nel gruppo Auto Scaling (CLI)](#tutorials-auto-scaling-group-scale-up-cli)
+ [Per ridimensionare il numero di istanze Amazon EC2 nel gruppo di distribuzione (console)](#tutorials-auto-scaling-group-scale-up-console)
## Per ridimensionare il numero di istanze Amazon EC2 nel gruppo Auto Scaling (CLI)
1. Chiama il **update-auto-scaling-group** comando per aumentare da una a due le istanze Amazon EC2 nel gruppo Auto Scaling denominato**CodeDeployDemo-AS-Group**.
Su macchine Linux, macOS o Unix locali:
```
aws autoscaling update-auto-scaling-group \
--auto-scaling-group-name CodeDeployDemo-AS-Group \
--min-size 2 \
--max-size 2 \
--desired-capacity 2
```
Nei computer Windows locali:
```
aws autoscaling update-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --min-size 2 --max-size 2 --desired-capacity 2
```
1. Assicurati che il gruppo Auto Scaling disponga ora di due istanze Amazon EC2. Chiamare il comando **describe-auto-scaling-groups** per **CodeDeployDemo-AS-Group**:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].[HealthStatus, LifecycleState]" --output text
```
Non procedere finché entrambi i valori restituiti non mostrano `Healthy` e `InService`.
## Per ridimensionare il numero di istanze Amazon EC2 nel gruppo di distribuzione (console)
1. Nella barra di navigazione di Amazon EC2, in Auto **Scaling, scegli Auto** **Scaling Groups, quindi scegli**. **CodeDeployDemo-AS-Group**
1. Seleziona **Azioni**, quindi scegli **Modifica**.
1. Nella scheda **Details (Dettagli)** nelle caselle **Desired (Desiderato)**, **Min (Minimo)** e **Max (Massimo)**, digitare **2** e scegliere** Save (Salva)**.
1. Selezionare la scheda **Instances (Istanze)**. La nuova istanza Amazon EC2 dovrebbe apparire nell'elenco. Se l'istanza non viene visualizzata, potrebbe essere necessario scegliere più volte il pulsante **Refresh (Aggiorna)**. Non procedere finché non **InService**viene visualizzato il valore di nella colonna **Lifecycle** e il valore di **Healthy** nella colonna **Health Status**.
# Passaggio 5: Controlla nuovamente i risultati
In questo passaggio, controllerai se è stata CodeDeploy installata la SimpleDemoApp revisione sulla nuova istanza nel gruppo Auto Scaling.
**Topics**
+ [Per verificare i risultati della distribuzione automatica (CLI)](#tutorials-auto-scaling-group-reverify-cli)
+ [Per verificare i risultati della distribuzione automatica (console)](#tutorials-auto-scaling-group-reverify-console)
## Per verificare i risultati della distribuzione automatica (CLI)
1. Prima di chiamare il comando **get-deployment**, è necessario l'ID dell'istanza della distribuzione automatica. Per ottenere l'ID, chiamare il comando **list-deployments** per l'applicazione denominata **SimpleDemoApp** e il gruppo di distribuzione con nome **SimpleDemoDG**:
```
aws deploy list-deployments --application-name SimpleDemoApp --deployment-group-name SimpleDemoDG --query "deployments" --output text
```
Dovrebbero esserci due distribuzioni. IDs Utilizzare quello che ancora non è stato utilizzato in una chiamata al comando **get-deployment**:
```
aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.[status, creator]" --output text
```
Oltre allo stato della distribuzione, dovresti vederlo `autoScaling` nell'output del comando. (`autoScaling`significa che Amazon EC2 Auto Scaling ha creato la distribuzione.)
Non procedere finché lo stato della distribuzione non mostra `Succeeded`.
1. Prima di chiamare il **describe-instances** comando, è necessario l'ID della nuova istanza Amazon EC2. Per ottenere l'ID, effettuare un'altra chiamata al comando **describe-auto-scaling-groups** per **CodeDeployDemo-AS-Group**:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].InstanceId" --output text
```
Ora effettuare una chiamata al comando **describe-instances**:
```
aws ec2 describe-instances --instance-id instance-id --query "Reservations[0].Instances[0].PublicDnsName" --output text
```
Nell'output del **describe-instances** comando, annota il DNS pubblico per la nuova istanza Amazon EC2.
1. Utilizzando un browser Web, mostra la `SimpleDemoApp` revisione distribuita su quell'istanza Amazon EC2, utilizzando un URL come il seguente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Se viene visualizzata la pagina delle congratulazioni, significa che CodeDeploy in passato hai distribuito una revisione su un'istanza Amazon EC2 scalata in un gruppo Auto Scaling\$1
## Per verificare i risultati della distribuzione automatica (console)
1. [Accedi e apri la console all'indirizzo Console di gestione AWS /codedeploy. CodeDeploy https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy**, quindi scegli **Deployments**.
1. Scegli l'ID di distribuzione della distribuzione creata da Amazon EC2 Auto Scaling.
.
1. Nella pagina **Deployment (Distribuzione)** vengono visualizzate le informazioni sulla distribuzione. Normalmente, dovresti creare una distribuzione da solo, ma Amazon EC2 Auto Scaling ne ha creata una per tuo conto per distribuire la tua revisione nella nuova istanza Amazon EC2.
1. Quando **Succeeded (Riuscito)** viene visualizzato nella parte superiore della pagina, verificare i risultati dell'istanza. In primo luogo, è necessario ottenere il DNS dell'istanza:
1. Nel pannello di navigazione di Amazon EC2, in Auto **Scaling, scegli Auto** **Scaling** Groups, quindi scegli la voce. **CodeDeployDemo-AS-Group**
1. Nella scheda **Istanze**, scegli l'ID della nuova istanza Amazon EC2.
1. Nella pagina **Instances (Istanze)** nella scheda **Description (Descrizione)** annotare il valore **Public DNS (DNS pubblico)**. Dovrebbe essere simile a quanto segue: **ec2-01-234-567-890.compute-1.amazonaws.com**.
Mostrare la revisione `SimpleDemoApp` distribuita all'istanza utilizzando un URL, come il seguente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Se viene visualizzata la pagina delle congratulazioni, significa che CodeDeploy in passato hai distribuito una revisione su un'istanza Amazon EC2 scalata in un gruppo Auto Scaling\$1
# Fase 6: pulizia
In questo passaggio, eliminerai il gruppo Auto Scaling per evitare addebiti continui per le risorse utilizzate durante questo tutorial. Facoltativamente, è possibile eliminare i record dei componenti di configurazione CodeDeploy e distribuzione di Auto Scaling.
**Topics**
+ [Per cancellare le risorse (CLI)](#tutorials-auto-scaling-group-clean-up-cli)
+ [Per cancellare le risorse (console)](#tutorials-auto-scaling-group-clean-up-console)
## Per cancellare le risorse (CLI)
1. Eliminare il gruppo Auto Scaling chiamando il **delete-auto-scaling-group** comando against. **CodeDeployDemo-AS-Group** Ciò terminerà anche le istanze Amazon EC2.
```
aws autoscaling delete-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --force-delete
```
1. Facoltativamente, elimina il modello di avvio di Auto Scaling chiamando **delete-launch-template** il comando sulla configurazione di avvio denominata: **CodeDeployDemo-AS-Launch-Template**
```
aws ec2 delete-launch-template --launch-template-name CodeDeployDemo-AS-Launch-Template
```
1. Facoltativamente, elimina l'applicazione da CodeDeploy chiamando il **delete-application** comando sull'applicazione denominata. **SimpleDemoApp** Così facendo, saranno eliminati tutti i record associati alla revisione, al gruppo di distribuzione e alla distribuzione.
```
aws deploy delete-application --application-name SimpleDemoApp
```
1. Per eliminare l'associazione Systems Manager State Manager, chiamare il **delete-association** comando.
```
aws ssm delete-association --assocation-id association-id
```
È possibile ottenerla *association-id* chiamando il **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
## Per cancellare le risorse (console)
Per eliminare il gruppo Auto Scaling, che termina anche le istanze Amazon EC2:
1.
Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Nel pannello di navigazione di Amazon EC2, in Auto **Scaling, scegli Auto** **Scaling** Groups, quindi scegli la voce. **CodeDeployDemo-AS-Group**
1. Selezionare **Actions (Azioni)**, **Delete (Elimina)** e **Yes, Delete (Sì, elimina)**.
(Facoltativo) Per eliminare il modello di lancio:
1. Nella barra di navigazione, in **Auto Scaling**, scegli **Avvia configurazioni, quindi** scegli. **CodeDeployDemo-AS-Launch-Template**
1. Selezionare **Actions (Azioni)**, **Delete launch configuration (Elimina configurazione di avvio)** e **Yes, Delete (Sì, elimina)**.
1. Facoltativamente, elimina l'applicazione da. CodeDeploy Così facendo, saranno eliminati tutti i record associati alla revisione, al gruppo di distribuzione e alla distribuzione. Apri la CodeDeploy console in [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
1. [Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.
1. Nell'elenco delle applicazioni, scegliere **SimpleDemoApp**.
1. Nella pagina **Application details (Dettagli applicazione)**, scegliere **Delete application (Elimina applicazione)**.
1. Quando richiesto, digitare **Delete**, quindi scegliere **Delete (Elimina)**.
Per eliminare l'associazione Systems Manager State Manager:
1. Aprire la AWS Systems Manager console in https://console.aws.amazon.com /systems-manager.
1. Nel riquadro di navigazione, seleziona **State Manager**.
1. Scegli l'associazione creata e seleziona **Elimina**.