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

# CodeDeploy tutorial
<a name="tutorials"></a>

Questa sezione include alcuni tutorial per imparare a utilizzare CodeDeploy.

Le procedure di questi tutorial forniscono suggerimenti sulla posizione in cui archiviare i file (ad esempio, c:\$1temp) e i nomi da assegnare a bucket, sottocartelle o file (ad esempio, rispettivamente amzn-s3-demo-bucket e - -trust.json) HelloWorldApp, ma non è necessario utilizzarle. CodeDeployDemo EC2 Assicurati di sostituire nomi e percorsi dei file durante l'esecuzione delle procedure.

**Topics**
+ [Tutorial: Esegui WordPress la distribuzione su un'istanza Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux e Linux, macOS o Unix)](tutorials-wordpress.md)
+ [Tutorial: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)](tutorials-windows.md)
+ [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md)
+ [Tutorial: CodeDeploy Da utilizzare per distribuire un'applicazione in un gruppo di Auto Scaling](tutorials-auto-scaling-group.md)
+ [Tutorial: utilizzare CodeDeploy per distribuire un'applicazione da GitHub](tutorials-github.md)
+ [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md)
+ [Tutorial: distribuisci un servizio Amazon ECS con un test di convalida](tutorial-ecs-deployment-with-hooks.md)
+ [Tutorial: implementa una funzione Lambda aggiornata CodeDeploy con e AWS il modello di applicazione Serverless](tutorial-lambda-sam.md)

# Tutorial: Esegui WordPress la distribuzione su un'istanza Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux e Linux, macOS o Unix)
<a name="tutorials-wordpress"></a>

In questo tutorial, WordPress distribuisci uno strumento di blogging open source e un sistema di gestione dei contenuti basato su PHP e MySQL su una singola istanza Amazon EC2 che esegue Amazon Linux o Red Hat Enterprise Linux (RHEL).

Non hai trovato ciò che cerchi?
+ Per fare pratica con la distribuzione su un'istanza Amazon EC2 che esegue invece Windows Server, consulta. [Tutorial: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)](tutorials-windows.md)
+ Per fare pratica con la distribuzione su un'istanza locale anziché su un'istanza Amazon EC2, consulta. [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md)

I passaggi di questo tutorial sono presentati dal punto di vista di una macchina di sviluppo locale che esegue Linux, macOS o Unix. Sebbene sia possibile completare buona parte della procedura su un computer locale che esegue Windows, occorrerà adattare le fasi che includono comandi quali **chmod** e **wget**, applicazioni come sed e percorsi di directory quali `/tmp`.

Prima di avviare questo tutorial, è necessario completare i prerequisiti in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md). Questi includono la configurazione di un utente, l'installazione o l'aggiornamento e la AWS CLI creazione di un profilo di istanza IAM e di un ruolo di servizio.

**Topics**
+ [Fase 1: Avvio e configurazione di un'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2](tutorials-wordpress-launch-instance.md)
+ [Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2](tutorials-wordpress-configure-content.md)
+ [Fase 3: carica l' WordPress applicazione su Amazon S3](tutorials-wordpress-upload-application.md)
+ [Fase 4: Implementazione dell'applicazione WordPress](tutorials-wordpress-deploy-application.md)
+ [Fase 5: Aggiornare e ridistribuire l'applicazione WordPress](tutorials-wordpress-update-and-redeploy-application.md)
+ [Passaggio 6: Pulisci WordPress l'applicazione e le risorse correlate](tutorials-wordpress-clean-up.md)

# Fase 1: Avvio e configurazione di un'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2
<a name="tutorials-wordpress-launch-instance"></a>

Per distribuire l' WordPress applicazione CodeDeploy, avrai bisogno di un'istanza Amazon EC2 che esegua Amazon Linux o Red Hat Enterprise Linux (RHEL). L'istanza Amazon EC2 richiede una nuova regola di sicurezza in entrata che consenta le connessioni HTTP. Questa regola è necessaria per visualizzare la WordPress pagina in un browser dopo che è stata distribuita correttamente.

Segui le istruzioni in [Crea un'istanza Amazon EC2 per CodeDeploy](instances-ec2-create.md). Quando arrivi alla parte di queste istruzioni sull'assegnazione di un tag di istanza Amazon EC2 all'istanza, assicurati di specificare la chiave del tag e il valore **Name** del tag di. **CodeDeployDemo** (Se viene specificata una chiave o un valore del tag, le istruzioni in [Fase 4: Implementazione dell'applicazione WordPress](tutorials-wordpress-deploy-application.md) possono portare a risultati inaspettati).

Dopo aver seguito le istruzioni per avviare l'istanza Amazon EC2, torna a questa pagina e passa alla sezione successiva. Non continuare con [Crea un'applicazione con CodeDeploy](applications-create.md) il passaggio successivo.

## Connect alla tua istanza Amazon Linux o RHEL Amazon EC2
<a name="tutorials-wordpress-launch-instance-connect"></a>

Dopo il lancio della tua nuova istanza Amazon EC2, segui queste istruzioni per esercitarti a connetterti ad essa.

1. Usa il **ssh** comando (o un emulatore di terminale compatibile con SSH come [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)) per connetterti alla tua istanza Amazon Linux o RHEL Amazon EC2. Avrai bisogno dell'indirizzo DNS pubblico dell'istanza e della chiave privata per la coppia di chiavi utilizzata all'avvio dell'istanza Amazon EC2. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html).

   Ad esempio, se l'indirizzo DNS pubblico è **ec2-01-234-567-890.compute-1.amazonaws.com** e la coppia di chiavi dell'istanza Amazon EC2 per l'accesso SSH è **codedeploydemo.pem** denominata, devi digitare:

   ```
   ssh -i /path/to/codedeploydemo.pem ec2-user@ec2-01-234-567-890.compute-1.amazonaws.com
   ```

   Sostituisci `/path/to/codedeploydemo.pem` con il percorso del `.pem` file e l'indirizzo DNS di esempio con l'indirizzo della tua istanza Amazon Linux o RHEL Amazon EC2.
**Nota**  
Se si riceve un errore riguardo al fatto che le autorizzazioni della chiave del file sono troppo aperte, sarà necessario limitare le autorizzazioni per dare accesso solo all'utente attuale (tu). Ad esempio, con il **chmod** comando su Linux, macOS o Unix, digitare:

   ```
   chmod 400 /path/to/codedeploydemo.pem
   ```

1. Dopo aver effettuato l'accesso, vedrai il banner AMI per l'istanza Amazon EC2. Per Amazon Linux, dovrebbe avere il seguente aspetto:

   ```
          __|  __|_  )
          _|  (     /   Amazon Linux AMI
         ___|\___|___|
   ```

1. Ora puoi disconnetterti dall'istanza Amazon EC2 in esecuzione.
**avvertimento**  
Non interrompere o terminare l'istanza Amazon EC2. In caso contrario, CodeDeploy non sarà possibile eseguire la distribuzione su di essa.

## Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon Linux o RHEL Amazon EC2
<a name="tutorials-wordpress-launch-instance-add-inbound-rule"></a>

Il passaggio successivo conferma che l'istanza Amazon EC2 ha una porta HTTP aperta in modo da poter visualizzare la home page dell' WordPress applicazione distribuita in un browser. 

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. Scegli **Istanze**, quindi scegli la tua istanza. 

1. Nella scheda **Descrizione**, in **Gruppi di sicurezza**, scegli **Visualizza regole in entrata**. 

   Dovresti vedere un elenco di regole nel tuo gruppo di sicurezza come il seguente:

   ```
   Security Groups associated with i-1234567890abcdef0
    Ports     Protocol     Source     launch-wizard-N
    22        tcp          0.0.0.0/0          ✔
   ```

1.  In **Gruppi di sicurezza**, scegli il gruppo di sicurezza per la tua istanza Amazon EC2. Potrebbe essere denominato **launch-wizard-*N***. Il nome ***N*** è un numero assegnato al proprio gruppo di sicurezza quando è stata creata l'istanza. 

    Seleziona la scheda **Inbound (In entrata)**. Se il gruppo di sicurezza per la tua istanza è configurato correttamente, dovresti vedere una regola con i seguenti valori: 
   + **Type (Tipo)**: HTTP
   + **Protocollo**: TCP
   + **Port Range** (Intervallo porte): 80
   + **Fonte**: 0.0.0.0/0

1.  Se non vedi una regola con questi valori, usa le procedure in [Aggiungere regole a un gruppo di sicurezza per aggiungerle a una](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) nuova regola di sicurezza. 

# Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2
<a name="tutorials-wordpress-configure-content"></a>

È ora possibile configurare l'applicazione dei contenuti di origine in modo da avere materiale da distribuire all'istanza.

**Topics**
+ [Ottieni il codice sorgente](#tutorials-wordpress-configure-content-download-code)
+ [Crea script per eseguire la tua applicazione](#tutorials-wordpress-configure-content-create-scripts)
+ [Aggiungere un file di specifiche dell'applicazione](#tutorials-wordpress-configure-content-add-appspec-file)

## Ottieni il codice sorgente
<a name="tutorials-wordpress-configure-content-download-code"></a>

In questo tutorial, distribuisci la piattaforma di pubblicazione WordPress dei contenuti dalla tua macchina di sviluppo all'istanza Amazon EC2 di destinazione. Per ottenere il codice WordPress sorgente, puoi utilizzare chiamate da riga di comando integrate. In alternativa, si può usare Git se è installato nel computer di sviluppo.

Per questi passaggi, supponiamo che tu abbia scaricato una copia del codice WordPress sorgente `/tmp` nella directory del tuo computer di sviluppo. È possibile scegliere una directory qualsiasi, ma ci si deve ricordare di sostituire la posizione per `/tmp` nel punto specificato in queste fasi.

Scegli una delle due opzioni seguenti per copiare i file WordPress sorgente sulla tua macchina di sviluppo. La prima opzione utilizza le chiamate della riga di comando integrata. La seconda usa Git.

**Topics**
+ [Per ottenere una copia del codice WordPress sorgente (chiamate da riga di comando integrate)](#tutorials-wordpress-configure-content-download-code-command-line)
+ [Per ottenere una copia del codice WordPress sorgente (Git)](#tutorials-wordpress-configure-content-download-code-git)

### Per ottenere una copia del codice WordPress sorgente (chiamate da riga di comando integrate)
<a name="tutorials-wordpress-configure-content-download-code-command-line"></a>

1. Chiamate il **wget** comando per scaricare una copia del codice WordPress sorgente, come file.zip, nella directory corrente:

   ```
   wget https://github.com/WordPress/WordPress/archive/master.zip
   ```

1. Chiamare i comandi **unzip**, **mkdir**, **cp** e **rm** per:
   + Decomprimere il file .zip `master` nella directory (cartella) `/tmp/WordPress_Temp`.
   + Copiare i contenuti estratti dallo zip nella cartella di destinazione `/tmp/WordPress`.
   + Eliminare la cartella temporanea `/tmp/WordPress_Temp` e il file `master`.

   Eseguire uno alla volta i comandi:

   ```
   unzip master -d /tmp/WordPress_Temp
   ```

   ```
   mkdir -p /tmp/WordPress
   ```

   ```
   cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
   ```

   ```
   rm -rf /tmp/WordPress_Temp
   ```

   ```
   rm -f master
   ```

   Questo ti lascia con un set pulito di file di codice WordPress sorgente nella `/tmp/WordPress` cartella.

### Per ottenere una copia del codice WordPress sorgente (Git)
<a name="tutorials-wordpress-configure-content-download-code-git"></a>

1. Scaricare e installare [Git](http://git-scm.com) sul computer di sviluppo.

1. Nella cartella `/tmp/WordPress`, chiamare il comando **git init**. 

1. Chiamate il **git clone** comando per clonare l' WordPressarchivio pubblico, creandone una copia nella cartella di `/tmp/WordPress` destinazione:

   ```
   git clone https://github.com/WordPress/WordPress.git /tmp/WordPress
   ```

   Questo ti lascia con un set pulito di file di codice WordPress sorgente nella `/tmp/WordPress` cartella.

## Crea script per eseguire la tua applicazione
<a name="tutorials-wordpress-configure-content-create-scripts"></a>

Quindi, crea una cartella e degli script nella directory. CodeDeploy utilizza questi script per configurare e distribuire la revisione dell'applicazione sull'istanza Amazon EC2 di destinazione. È possibile usare qualsiasi editor di testo per creare gli script.

1. Crea una directory di script nella tua copia del codice sorgente: WordPress 

   ```
   mkdir -p /tmp/WordPress/scripts
   ```

1. Creare un file `install_dependencies.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo script `install_dependencies.sh` installa Apache, MySQL e PHP. Aggiunge inoltre il supporto MySQL a PHP.

   ```
   #!/bin/bash
   sudo amazon-linux-extras install php7.4
   sudo yum install -y httpd mariadb-server php
   ```

1. Creare un file `start_server.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo script `start_server.sh` avvia Apache e MySQL.

   ```
   #!/bin/bash
   systemctl start mariadb.service
   systemctl start httpd.service
   systemctl start php-fpm.service
   ```

1. Creare un file `stop_server.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo script `stop_server.sh` arresta Apache e MySQL.

   ```
   #!/bin/bash
   isExistApp="pgrep httpd"
   if [[ -n $isExistApp ]]; then
   systemctl stop httpd.service
   fi
   isExistApp=pgrep mysqld
   if [[ -n $isExistApp ]]; then
   systemctl stop mariadb.service
   fi
   isExistApp=pgrep php-fpm
   if [[ -n $isExistApp ]]; then
   systemctl stop php-fpm.service
   
   fi
   ```

1. Creare un file `create_test_db.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo `create_test_db.sh` script utilizza MySQL per creare **test** un database WordPress da utilizzare.

   ```
   #!/bin/bash
   mysql -uroot <<CREATE_TEST_DB
   CREATE DATABASE IF NOT EXISTS test;
   CREATE_TEST_DB
   ```

1. Infine creare uno script `change_permissions.sh` in `/tmp/WordPress/scripts`. Questo viene utilizzato per modificare le autorizzazioni per la cartella in Apache.
**Importante**  
 Questo script ha aggiornato le autorizzazioni nella cartella `/tmp/WordPress` in modo che tutti possano scriverci. Questo è necessario per WordPress poter scrivere nel suo database durante. [Fase 5: Aggiornare e ridistribuire l'applicazione WordPress](tutorials-wordpress-update-and-redeploy-application.md) Dopo aver configurato l' WordPress applicazione, esegui il comando seguente per aggiornare le autorizzazioni a un'impostazione più sicura:  

   ```
   chmod -R 755 /var/www/html/WordPress
   ```

   ```
   #!/bin/bash
   chmod -R 777 /var/www/html/WordPress
   ```

1. Assegnare autorizzazioni eseguibili a tutti gli script. Sulla riga di comando, digitare:

   ```
   chmod +x /tmp/WordPress/scripts/*
   ```

## Aggiungere un file di specifiche dell'applicazione
<a name="tutorials-wordpress-configure-content-add-appspec-file"></a>

Quindi, aggiungete un file di specifiche dell'applicazione (AppSpec file), un file in formato [YAML](http://www.yaml.org) utilizzato da per: CodeDeploy 
+ Mappa i file di origine nella revisione dell'applicazione alle relative destinazioni sull'istanza Amazon EC2 di destinazione.
+ Specificare autorizzazioni personalizzate per i file distribuiti.
+ Specificare gli script da eseguire sull'istanza Amazon EC2 di destinazione durante la distribuzione.

Il AppSpec file deve avere un nome. `appspec.yml` Deve essere inserito nella directory root del codice sorgente dell'applicazione. In questo tutorial, la directory root è `/tmp/WordPress`.

Con un editor di testo, creare un file denominato `appspec.yml`. Aggiungere le seguenti righe al file:

```
version: 0.0
os: linux
files:
  - source: /
    destination: /var/www/html/WordPress
hooks:
  BeforeInstall:
    - location: scripts/install_dependencies.sh
      timeout: 300
      runas: root
  AfterInstall:
    - location: scripts/change_permissions.sh
      timeout: 300
      runas: root
  ApplicationStart:
    - location: scripts/start_server.sh
    - location: scripts/create_test_db.sh
      timeout: 300
      runas: root
  ApplicationStop:
    - location: scripts/stop_server.sh
      timeout: 300
      runas: root
```

CodeDeploy utilizza questo AppSpec file per copiare tutti i file nella `/tmp/WordPress` cartella sulla macchina di sviluppo nella `/var/www/html/WordPress` cartella sull'istanza Amazon EC2 di destinazione. Durante la distribuzione, CodeDeploy esegue gli script specificati come `root` nella `/var/www/html/WordPress/scripts` cartella sull'istanza Amazon EC2 di destinazione in occasione di eventi specifici durante il ciclo di vita della distribuzione, ad esempio e. **BeforeInstall** **AfterInstall** Se l'esecuzione di uno di questi script impiega più di 300 secondi (5 minuti), CodeDeploy interrompe la distribuzione e contrassegna la distribuzione come fallita.

Per ulteriori informazioni su queste impostazioni, consulta i [CodeDeploy AppSpec riferimento al file](reference-appspec-file.md).

**Importante**  
Le ubicazioni e i numeri di spazi tra ciascuna delle voci in questo file sono importanti. Se la spaziatura non è corretta, CodeDeploy genera un errore di cui potrebbe essere difficile eseguire il debug. Per ulteriori informazioni, consulta [AppSpec Spaziatura tra i file](reference-appspec-file.md#reference-appspec-file-spacing).

# Fase 3: carica l' WordPress applicazione su Amazon S3
<a name="tutorials-wordpress-upload-application"></a>

Ora preparerai e caricherai i tuoi contenuti di origine in una posizione da cui CodeDeploy distribuirli. Le seguenti istruzioni mostrano come effettuare il provisioning di un bucket Amazon S3, preparare i file di revisione dell'applicazione per il bucket, raggruppare i file della revisione e quindi inserire la revisione nel bucket.

**Nota**  
Sebbene non sia trattato in questo tutorial, puoi CodeDeploy utilizzarlo per distribuire applicazioni dai repository alle istanze. GitHub Per ulteriori informazioni, consulta [Integrazione con CodeDeploy GitHub](integrations-partners-github.md).

**Topics**
+ [Esegui il provisioning di un bucket Amazon S3](#tutorials-wordpress-upload-application-create-s3-bucket)
+ [Prepara i file dell'applicazione per il bucket](#tutorials-wordpress-upload-application-prepare-application-files)
+ [Raggruppate i file dell'applicazione in un unico file di archivio e inviate il file di archivio](#tutorials-wordpress-upload-application-bundle-and-push-archive)

## Esegui il provisioning di un bucket Amazon S3
<a name="tutorials-wordpress-upload-application-create-s3-bucket"></a>

Crea un contenitore o un *bucket* di storage in Amazon S3 o usa un bucket esistente. Assicurati di poter caricare la revisione nel bucket e che le istanze Amazon EC2 utilizzate nelle distribuzioni possano scaricare la revisione dal bucket.

Puoi usare la AWS CLI console Amazon S3 o Amazon S3 per creare un APIs bucket Amazon S3. Dopo aver creato il bucket, assicurati di concedere le autorizzazioni di accesso al bucket e al tuo account. AWS 

**Nota**  
I nomi dei bucket devono essere univoci in Amazon S3 per AWS tutti gli account. Se non si è in grado di utilizzare **amzn-s3-demo-bucket**, provare un altro nome del bucket, ad esempio **amzn-s3-demo-bucket** seguito da un trattino e le iniziali o altri identificatori univoci. Assicurarsi quindi di sostituire il nome del bucket per **amzn-s3-demo-bucket** ovunque sia presente in questo tutorial.  
Il bucket Amazon S3 deve essere creato nella stessa AWS regione in cui vengono lanciate le istanze Amazon EC2 di destinazione. Ad esempio, se crei il bucket nella regione Stati Uniti orientali (Virginia settentrionale), le istanze Amazon EC2 di destinazione devono essere avviate nella regione Stati Uniti orientali (Virginia settentrionale).

**Topics**
+ [Per creare un bucket Amazon S3 (CLI)](#tutorials-wordpress-upload-application-create-s3-bucket-cli)
+ [Per creare un bucket Amazon S3 (console)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Concedi le autorizzazioni al bucket e all'account Amazon S3 AWS](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)

### Per creare un bucket Amazon S3 (CLI)
<a name="tutorials-wordpress-upload-application-create-s3-bucket-cli"></a>

Chiama il **mb** comando per creare un bucket Amazon S3 denominato: **amzn-s3-demo-bucket**

```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```

### Per creare un bucket Amazon S3 (console)
<a name="tutorials-wordpress-upload-application-create-s3-bucket-console"></a>

1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nella console Amazon S3, scegli **Crea** bucket.

1. Nella casella **Nome bucket**, digitare un nome per il bucket.

1. Nell'elenco **Regione** selezionare la regione di destinazione, quindi selezionare **Crea**.

### Concedi le autorizzazioni al bucket e all'account Amazon S3 AWS
<a name="tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions"></a>

È necessario disporre delle autorizzazioni per il caricamento nel bucket Amazon S3. Puoi specificare queste autorizzazioni tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente `111122223333` all' AWS account di caricare file in qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:PutObject"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "111122223333"
                ]
            }
        }
    ]
}
```

[Per visualizzare l'ID del tuo AWS account, consulta Finding Your account ID. AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId)

Ora è il momento giusto per verificare che il bucket Amazon S3 consenta le richieste di download da ogni istanza Amazon EC2 partecipante. Puoi specificarlo tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente a qualsiasi istanza Amazon EC2 con un profilo di istanza IAM allegato contenente l'ARN di scaricare file `arn:aws:iam::444455556666:role/CodeDeployDemo` da qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "arn:aws:iam::444455556666:role/CodeDeployDemo"
                ]
            }
        }
    ]
}
```

 Per informazioni su come generare e allegare una bucket policy di Amazon S3, consulta Esempi di policy [Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).

Per informazioni su come creare e allegare una policy IAM, consulta [Working](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console) with policies.

## Prepara i file dell'applicazione per il bucket
<a name="tutorials-wordpress-upload-application-prepare-application-files"></a>

Assicurati che i file WordPress dell'applicazione, il AppSpec file e gli script siano organizzati sulla tua macchina di sviluppo in modo simile al seguente:

```
/tmp/
  |--WordPress/
      |-- appspec.yml  
      |-- scripts/
      |    |-- change_permissions.sh
      |    |-- create_test_db.sh
      |    |-- install_dependencies.sh
      |    |-- start_server.sh
      |    |-- stop_server.sh
      |-- wp-admin/
      |    |-- (various files...)
      |-- wp-content/
      |    |-- (various files...)
      |-- wp-includes/
      |    |-- (various files...)
      |-- index.php
      |-- license.txt
      |-- readme.html
      |-- (various files ending with .php...)
```

## Raggruppate i file dell'applicazione in un unico file di archivio e inviate il file di archivio
<a name="tutorials-wordpress-upload-application-bundle-and-push-archive"></a>

Raggruppa i file WordPress dell'applicazione e il AppSpec file in un file di archivio (noto come *revisione* dell'applicazione).

**Nota**  
Potrebbero essere addebitati dei costi per lo storage degli oggetti in un bucket e per il trasferimento delle revisioni dell'applicazione dentro e fuori un bucket. Per ulteriori informazioni, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/). 

1. Sul computer di sviluppo, passare alla cartella in cui sono archiviati i file: 

   ```
   cd /tmp/WordPress
   ```
**Nota**  
Se non si passa a questa cartella, il raggruppamento dei file verrà avviato nella cartella corrente. Ad esempio, se la cartella corrente è `/tmp` invece di `/tmp/WordPress`, il raggruppamento verrà quindi avviato con i file e le sottocartelle presenti nella cartella `tmp`, che può includere più di una sottocartella `WordPress`.

1. Chiamare il comando **create-application** per registrare una nuova applicazione denominata **WordPress\$1App**

   ```
   aws deploy create-application --application-name WordPress_App
   ```

1. Richiama il comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) per raggruppare i file, caricare le revisioni su Amazon S3 e registrare le informazioni CodeDeploy sulla revisione caricata, il tutto in un'unica operazione. 

   ```
   aws deploy push \
     --application-name WordPress_App \
     --s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
     --ignore-hidden-files
   ```

   Questo comando raggruppa i file dalla directory corrente (esclusi i file nascosti) in un unico file di archivio denominato**WordPressApp.zip**, carica la revisione nel **amzn-s3-demo-bucket** bucket e registra le informazioni sulla revisione caricata. CodeDeploy 

# Fase 4: Implementazione dell'applicazione WordPress
<a name="tutorials-wordpress-deploy-application"></a>

Ora distribuisci la revisione dell' WordPress applicazione di esempio che hai caricato su Amazon S3. Puoi utilizzare la console AWS CLI o la CodeDeploy console per distribuire la revisione e monitorare l'avanzamento della distribuzione. Una volta distribuita la revisione dell'applicazione, si possono controllare i risultati.

**Topics**
+ [Implementa la revisione dell'applicazione con CodeDeploy](#tutorials-wordpress-deploy-application-create-deployment)
+ [Monitora e risolvi i problemi della distribuzione](#tutorials-wordpress-deploy-application-monitor)
+ [Verifica la tua implementazione](#tutorials-wordpress-deploy-application-verify-deployment)

## Implementa la revisione dell'applicazione con CodeDeploy
<a name="tutorials-wordpress-deploy-application-create-deployment"></a>

Usa la console AWS CLI o la console per distribuire la revisione dell'applicazione.

**Topics**
+ [Per distribuire la revisione dell'applicazione (CLI)](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Per distribuire la revisione dell'applicazione (console)](#tutorials-wordpress-deploy-application-create-deployment-console)

### Per distribuire la revisione dell'applicazione (CLI)
<a name="tutorials-wordpress-deploy-application-create-deployment-cli"></a>

1. La distribuzione richiede un gruppo di distribuzione. Tuttavia, prima di creare il gruppo di distribuzione, è necessario un ARN del ruolo del servizio. Un ruolo di servizio è un ruolo IAM che concede al servizio l'autorizzazione ad agire per tuo conto. In questo caso, il ruolo di servizio consente di CodeDeploy accedere alle istanze Amazon EC2 per espandere (leggere) i relativi tag di istanza Amazon EC2.

   Per creare un ruolo del servizio occorre avere già eseguito le istruzioni in [Creare un ruolo di servizio (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli). Per ottenere l'ARN del ruolo del servizio, consulta [Ottieni il ruolo di servizio ARN (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).

1. Ora che hai il ruolo di servizio ARN, chiama il **create-deployment-group** comando per creare un gruppo di distribuzione denominato**WordPress\$1DepGroup**, associato all'applicazione denominata**WordPress\$1App**, utilizzando il tag Amazon EC2 denominato e la configurazione di distribuzione **CodeDeployDemo** denominata: **CodeDeployDefault.OneAtATime**

   ```
   aws deploy create-deployment-group \
     --application-name WordPress_App \
     --deployment-group-name WordPress_DepGroup \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE \
     --service-role-arn serviceRoleARN
   ```

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

1. Prima di creare una distribuzione, l' CodeDeploy agente deve essere installato sulle istanze del gruppo di distribuzione. È possibile installare l'agente dalla riga di comando con AWS Systems Manager tramite il seguente comando:

   ```
   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 e quindi tenterà di aggiornarlo alle 2:00 ogni domenica mattina. Per ulteriori informazioni sull' CodeDeploy agente, vedere [Lavorare con l' CodeDeploy agente.](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html) 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).

1. Chiamare ora il comando **create-deployment** per creare una distribuzione associata all'applicazione denominata **WordPress\$1App**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime** e il gruppo di distribuzione denominato **WordPress\$1DepGroup** utilizzando la revisione dell'applicazione denominata **WordPressApp.zip** nel bucket denominato **amzn-s3-demo-bucket**:

   ```
   aws deploy create-deployment \
     --application-name WordPress_App \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --deployment-group-name WordPress_DepGroup \
     --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
   ```

### Per distribuire la revisione dell'applicazione (console)
<a name="tutorials-wordpress-deploy-application-create-deployment-console"></a>

1. Prima di utilizzare la CodeDeploy console per distribuire la revisione dell'applicazione, è necessario un ARN per il ruolo di servizio. Un ruolo di servizio è un ruolo IAM che autorizza il servizio ad agire per conto dell'utente. In questo caso, il ruolo di servizio consente di CodeDeploy accedere alle istanze Amazon EC2 per espandere (leggere) i relativi tag di istanza Amazon EC2.

   Per creare un ruolo del servizio occorre avere già eseguito le istruzioni in [Crea un ruolo di servizio (console)](getting-started-create-service-role.md#getting-started-create-service-role-console). Per ottenere l'ARN del ruolo del servizio, consulta [Ottieni il ruolo di servizio ARN (console)](getting-started-create-service-role.md#getting-started-get-service-role-console).

1. Ora che hai l'ARN, usa 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. Nell'elenco delle applicazioni, scegli **WordPress\$1App**.

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 **WordPress\$1DepGroup**.

1. In **Deployment type (Tipo di distribuzione)** scegliere **In-place deployment (Distribuzione in loco)**.

1. Nella **configurazione dell'ambiente**, seleziona le **istanze Amazon EC2**.

1. Nella **configurazione dell'agente con AWS Systems Manager**, mantieni le impostazioni predefinite.

1. In **Key (Chiave)**, immettere **Name**.

1. In **Valore**, immetti **CodeDeployDemo**.
**Nota**  
Dopo aver digitato**CodeDeployDemo**, dovrebbe apparire un **1** in **Istanze corrispondenti** per confermare che è CodeDeploy stata trovata un'istanza Amazon EC2 corrispondente.

1. **In **Configurazione di distribuzione, scegli**. CodeDeployDefault OneAtATime**.

1. In **Service role ARN (ARN ruolo di servizio)**, scegliere l'ARN del ruolo di servizio, quindi scegliere **Create deployment group (Crea gruppo di distribuzione)**.

1. Scegli **Create deployment (Crea distribuzione)**.

1. In **Deployment group (Gruppo di distribuzione)** scegliere **WordPress\$1DepGroup**.

1. Accanto a **Tipo di repository**, seleziona **La mia applicazione è archiviata in Amazon** S3. In **Luogo di revisione**, inserisci la posizione della revisione dell' WordPress applicazione di esempio che hai precedentemente caricato su Amazon S3. Per ottenere la posizione:

   1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

   1. Nell'elenco dei bucket, scegli **amzn-s3-demo-bucket (o il nome del bucket** in cui hai caricato la revisione dell'applicazione). 

   1. Nell'elenco degli **WordPressAppoggetti**, scegliete .zip.

   1. Nella scheda **Panoramica** copiare negli Appunti il valore del campo **Link**.

      Potrebbe essere simile al seguente:

      **https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**

   1. Torna alla CodeDeploy console e, nella **posizione Revisione**, incolla il valore del campo **Link**.

1. Se nell'elenco **File type (Tipo di file)** vene visualizzato un messaggio che informa che non è stato possibile trovare il tipo di file, scegliere **.zip**.

1. (Facoltativo) digitare un commento nella casella **Deployment description (Descrizione distribuzione)**. 

1. **Espandi le sostituzioni del gruppo di distribuzione** **e, in **Configurazione di distribuzione**, scegli. CodeDeployDefault OneAtATime**.

1. Selezionare **Start deployment (Avvia distribuzione)**. Nella pagina **Deployments (Distribuzioni)** vengono visualizzate le informazioni relative alla nuova distribuzione creata.

## Monitora e risolvi i problemi della distribuzione
<a name="tutorials-wordpress-deploy-application-monitor"></a>

Usa la console AWS CLI o la console per monitorare e risolvere i problemi della distribuzione.

**Topics**
+ [Per monitorare e risolvere problemi relativi alla distribuzione (CLI)](#tutorials-wordpress-deploy-application-monitor-cli)
+ [Per monitorare e risolvere problemi relativi alla distribuzione (console)](#tutorials-wordpress-deploy-application-monitor-console)

### Per monitorare e risolvere problemi relativi alla distribuzione (CLI)
<a name="tutorials-wordpress-deploy-application-monitor-cli"></a>

1. Ottenere l'ID della distribuzione chiamando il comando **list-deployments** rispetto all'applicazione denominata **WordPress\$1App** e il gruppo di distribuzione denominato **WordPress\$1DepGroup**:

   ```
   aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_DepGroup --query 'deployments' --output text
   ```

1. Chiamare il comando **get-deployment** con l'ID di distribuzione:

   ```
   aws deploy get-deployment --deployment-id deploymentID --query 'deploymentInfo.status' --output text
   ```

1. Il comando restituisce lo stato complessivo della distribuzione. In caso di esito positivo, il valore è `Succeeded`.

   Se lo stato complessivo è `Failed`, è possibile chiamare comandi quali [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) e [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) per risolvere i problemi. Per ulteriori opzioni di risoluzione dei problemi, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

### Per monitorare e risolvere problemi relativi alla distribuzione (console)
<a name="tutorials-wordpress-deploy-application-monitor-console"></a>

**Nella pagina **Distribuzioni** della CodeDeploy console, puoi monitorare lo stato della distribuzione nella colonna Stato.**

Per ottenere ulteriori informazioni sulla distribuzione, in particolare se il valore della colonna **Status (Stato)** è diverso da **Succeeded (Riuscito)**:

1. Nella scheda **Deployments (Distribuzioni)** scegliere il nome della distribuzione. Se una distribuzione non riesce, viene visualizzato un messaggio che descrive il motivo dell'errore.

1. In **Instance activity (Attività istanza)** vengono visualizzate altre informazioni sulla distribuzione. Dopo un errore di distribuzione, potresti essere in grado di determinare su quali istanze Amazon EC2 e in quale fase l'implementazione non è riuscita.

1. Se si vuole procedere alla risoluzione del problema, è possibile avvalersi di una tecnica come quella descritta in [Visualizza i dettagli dell'istanza con CodeDeploy](instances-view-details.md). Puoi anche analizzare i file di log di distribuzione su un'istanza Amazon EC2. Per ulteriori informazioni, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

## Verifica la tua implementazione
<a name="tutorials-wordpress-deploy-application-verify-deployment"></a>

Una volta completata la distribuzione, verifica che l' WordPress installazione funzioni. Utilizza l'indirizzo DNS pubblico dell'istanza Amazon EC2, seguito `/WordPress` da, per visualizzare il tuo sito in un browser Web. **(Per ottenere il valore DNS pubblico, nella console Amazon EC2, scegli l'istanza Amazon EC2 e, nella scheda Descrizione, cerca **il** valore di Public DNS.)**

Ad esempio, se l'indirizzo DNS pubblico della tua istanza Amazon EC2 **ec2-01-234-567-890.compute-1.amazonaws.com** è, utilizzerai il seguente URL:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress
```

Quando visualizzi il sito nel tuo browser, dovresti vedere una pagina di WordPress benvenuto simile alla seguente:

![\[WordPress pagina di benvenuto\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)


 Se alla tua istanza Amazon EC2 non è stata aggiunta una regola di ingresso HTTP al relativo gruppo di sicurezza, la pagina di WordPress benvenuto non viene visualizzata. Se vedi un messaggio che indica che il server remoto non risponde, assicurati che il gruppo di sicurezza per la tua istanza Amazon EC2 abbia la regola in entrata. Per ulteriori informazioni, consulta [Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon Linux o RHEL Amazon EC2Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon EC2 di Windows Server](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule). 

# Fase 5: Aggiornare e ridistribuire l'applicazione WordPress
<a name="tutorials-wordpress-update-and-redeploy-application"></a>

Ora che hai distribuito correttamente la revisione dell'applicazione, aggiorna il WordPress codice sulla macchina di sviluppo e CodeDeploy usalo per ridistribuire il sito. Successivamente, dovresti vedere le modifiche al codice sull'istanza Amazon EC2.

**Topics**
+ [Configura il sito WordPress](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Modifica il sito](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Ridistribuisci il sito](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)

## Configura il sito WordPress
<a name="tutorials-wordpress-update-and-redeploy-application-configure-and-install"></a>

Per vedere gli effetti della modifica del codice, completa la configurazione del WordPress sito in modo da avere un'installazione completamente funzionante.

1. Digitare l'URL del sito nel browser Web. L'URL è l'indirizzo DNS pubblico dell'istanza Amazon EC2 più `/WordPress` un'estensione. Per questo WordPress sito di esempio (e ad esempio l'indirizzo DNS pubblico dell'istanza Amazon EC2), l'URL è. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**

1. Se non hai ancora configurato il sito, viene visualizzata la pagina di benvenuto WordPress predefinita. Selezionare **Let's go\$1 (Iniziamo\$1)**.

1. Per utilizzare l'impostazione predefinita del database MySQL, nella pagina di configurazione del database digitare i seguenti valori:
   + **Database Name (Nome del database)**: **test**
   + **User Name**: **root**
   + **Password**: lasciare vuoto.
   + **Database Host**: **localhost**
   + **Table Prefix**: **wp\$1**

   Selezionare **Submit (Invia)** per configurare il database.

1. Continuare la configurazione del sito. Nella pagina di **benvenuto**, inserisci i valori che desideri e scegli **Installa WordPress**. Al termine dell'installazione, è possibile accedere al pannello di controllo.

**Importante**  
 Durante la distribuzione dell' WordPress applicazione, **change\$1permissions.sh** lo script ha aggiornato le autorizzazioni della `/tmp/WordPress` cartella in modo che chiunque possa scrivervi. In questa fase è possibile eseguire il comando seguente per limitare le autorizzazioni in modo che solo il proprietario possa scrivere nella cartella:  

```
chmod -R 755 /var/www/html/WordPress
```

## Modifica il sito
<a name="tutorials-wordpress-update-and-redeploy-application-modify-code"></a>

Per modificare il WordPress sito, vai alla cartella dell'applicazione sulla tua macchina di sviluppo:

```
cd /tmp/WordPress
```

Per modificare alcuni dei colori del sito, nel file `wp-content/themes/twentyfifteen/style.css` utilizzare un editor di testo o **sed** per modificare `#fff` in `#768331`. 

In Linux o altri sistemi con GNU **sed**, utilizzare:

```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```

In macOS, Unix o altri sistemi con BSD **sed**, utilizzare:

```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```

## Ridistribuisci il sito
<a name="tutorials-wordpress-update-and-redeploy-application-deploy-updates"></a>

Ora che hai modificato il codice del sito, usa Amazon S3 e ridistribuisci CodeDeploy il sito.

Raggruppa e carica le modifiche su Amazon S3, come descritto in. [Raggruppate i file dell'applicazione in un unico file di archivio e inviate il file di archivio](tutorials-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive) (Nel seguire queste istruzioni, ricordare che non è necessario creare un'applicazione). Assegnare alla nuova revisione la stessa chiave di prima (**WordPressApp.zip**). Caricalo nello stesso bucket Amazon S3 che hai creato in precedenza (ad esempio,). **amzn-s3-demo-bucket**

Usa AWS CLI, la CodeDeploy console o il CodeDeploy APIs per ridistribuire il sito.

**Topics**
+ [Per ridistribuire il sito (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Per ridistribuire il sito (console)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)

### Per ridistribuire il sito (CLI)
<a name="tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli"></a>

Chiamare il comando **create-deployment** per creare una distribuzione basata sulla revisione appena caricata. Utilizzare l'applicazione denominata **WordPress\$1App**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime**, il gruppo di distribuzione denominato **WordPress\$1DepGroup** e la revisione denominata **WordPressApp.zip** nel bucket denominato **amzn-s3-demo-bucket**:

```
 aws deploy create-deployment \
  --application-name WordPress_App \
  --deployment-config-name CodeDeployDefault.OneAtATime \
  --deployment-group-name WordPress_DepGroup \  
  --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```

È possibile controllare lo stato della distribuzione, come descritto in [Monitora e risolvi i problemi della distribuzione](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).

Dopo CodeDeploy aver ridistribuito il sito, visita nuovamente il sito nel browser Web per verificare che i colori siano stati modificati. (Potrebbe essere necessario aggiornare il browser). Se i colori sono stati modificati, la modifica e la ridistribuzione del sito sono riuscite.

### Per ridistribuire il sito (console)
<a name="tutorials-wordpress-update-and-redeploy-application-deploy-updates-console"></a>

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)

1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.

1. Nell'elenco delle applicazioni, scegli **WordPress\$1App**.

1. Nella scheda **Deployment groups (Gruppi di distribuzione)**, scegliere **WordPress\$1DepGroup**.

1. Scegli **Create deployment (Crea distribuzione)**. 

1. Nella pagina **Create deployment (Crea distribuzione)**:

   1. In **Deployment group (Gruppo di distribuzione)**, scegliere **WordPress\$1DepGroup**.

   1. **Nell'area **Tipo di archivio**, scegli **La mia applicazione è archiviata in Amazon** S3, quindi copia il link Amazon S3 della tua revisione nella casella Posizione di revisione.** Per individuare il valore del link: 

      1. In una scheda del browser separata:

         Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

          Naviga e apri **amzn-s3-demo-bucket**, quindi scegli la tua revisione,. **WordPressApp.zip** 

      1.  Se il riquadro **Proprietà** non è visibile nella console Amazon S3, scegli il pulsante **Proprietà**. 

      1.  Nel riquadro **Proprietà**, copia il valore del campo **Link** nella casella **Posizione di revisione** della CodeDeploy console. 

   1. Se viene visualizzato un messaggio che informa che non è stato possibile individuare il tipo di file, scegliere **.zip**. 

   1. Lasciare vuota la casella **Deployment description (Descrizione distribuzione)**.

   1. **Espandi le sostituzioni del gruppo di distribuzione** **e da **Configurazione di distribuzione**, scegli. CodeDeployDefault OneAtATime**.

   1. Selezionare **Start deployment (Avvia distribuzione)**. Nella pagina **Deployments (Distribuzioni)** vengono visualizzate le informazioni relative alla nuova distribuzione creata.

   1. È possibile controllare lo stato della distribuzione, come descritto in [Monitora e risolvi i problemi della distribuzione](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).

      Dopo CodeDeploy aver ridistribuito il sito, visita nuovamente il sito nel tuo browser web per verificare che i colori siano stati cambiati. (Potrebbe essere necessario aggiornare il browser). Se i colori sono stati modificati, la modifica e la ridistribuzione del sito sono riuscite.

# Passaggio 6: Pulisci WordPress l'applicazione e le risorse correlate
<a name="tutorials-wordpress-clean-up"></a>

Ora hai effettuato con successo un aggiornamento del WordPress codice e ridistribuito il sito. Per evitare addebiti continuativi per risorse create per questo tutorial, devi eliminare:
+ Qualsiasi CloudFormation stack (o termina qualsiasi istanza Amazon EC2, se le hai create all'esterno). CloudFormation
+ Qualsiasi bucket Amazon S3.
+ L'applicazione `WordPress_App` in CodeDeploy.
+ L'associazione AWS Systems Manager State Manager dell' CodeDeploy agente.

Puoi usare Amazon S3 CloudFormation, Amazon EC2 CodeDeploy e le console oppure eseguire AWS APIs la pulizia. AWS CLI

**Topics**
+ [Per cancellare le risorse (CLI)](#tutorials-wordpress-clean-up-cli)
+ [Per cancellare le risorse (console)](#tutorials-wordpress-clean-up-console)
+ [Fasi successive](#tutorials-wordpress-clean-up-whats-next)

## Per cancellare le risorse (CLI)
<a name="tutorials-wordpress-clean-up-cli"></a>

1. Se hai usato il nostro CloudFormation modello per questo tutorial, chiama il **delete-stack** comando sullo stack denominato. **CodeDeployDemoStack** Ciò interromperà tutte le istanze Amazon EC2 associate ed eliminerà tutti i ruoli IAM associati allo stack creato:

   ```
   aws cloudformation delete-stack --stack-name CodeDeployDemoStack
   ```

1. Per eliminare il bucket Amazon S3, chiama il **rm** comando con lo **--recursive** switch accanto al bucket denominato. **amzn-s3-demo-bucket** Il bucket e tutti gli oggetti in esso contenuti saranno quindi eliminati:

   ```
   aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
   ```

1. Per eliminare l'applicazione `WordPress_App`, chiamare il comando **delete-application**. In questo modo verranno inoltre eliminati tutti i record del gruppo di distribuzione associato e i record di distribuzione per l'applicazione:

   ```
   aws deploy delete-application --application-name WordPress_App
   ```

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

Se non hai utilizzato lo CloudFormation stack per questo tutorial, chiama il **terminate-instances** comando per terminare tutte le istanze Amazon EC2 che hai creato manualmente. Fornisci l'ID dell'istanza Amazon EC2 da terminare:

```
aws ec2 terminate-instances --instance-ids instanceId
```

## Per cancellare le risorse (console)
<a name="tutorials-wordpress-clean-up-console"></a>

Se hai utilizzato il nostro CloudFormation modello per questo tutorial, elimina lo stack associato CloudFormation .

1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Nella casella **Filtro**, digita il nome dello CloudFormation stack creato in precedenza (ad esempio,). **CodeDeployDemoStack**

1. Selezionare la casella accanto al nome dello stack. Nel menu **Actions (Operazioni)**, scegli **Delete Stack (Elimina stack)**.

   CloudFormation elimina lo stack, termina tutte le istanze Amazon EC2 associate ed elimina tutti i ruoli IAM associati.

Per terminare le istanze Amazon EC2 che hai creato al di fuori di uno stack: CloudFormation 

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. Nell'elenco **INSTANCES**, scegliere **Instances (Istanze)**.

1. Nella casella di ricerca, digita il nome dell'istanza Amazon EC2 che desideri terminare (ad esempio,**CodeDeployDemo**), quindi premi Invio.

1. Scegli il nome dell'istanza Amazon EC2.

1. Nel menu **Actions (Operazioni)**, passare a **Instance State (Stato istanza)**, quindi selezionare **Terminate (Termina)**. Quando richiesto, scegliere **Yes, Terminate (Sì, termina)**. 

Ripeti queste fasi per ogni istanza.

Per eliminare il bucket Amazon S3:

1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nell'elenco dei bucket, cerca e scegli il nome del bucket Amazon S3 che hai creato in precedenza (ad esempio,). **amzn-s3-demo-bucket**

1. Per eliminare un bucket, occorre innanzitutto rimuoverne i contenuti. Selezionare tutti i file nel bucket, ad esempio **WordPressApp.zip**. Dal menu **Actions (Operazioni)**, scegliere **Delete (Elimina)**. Quando viene richiesto di confermare l'eliminazione, scegliere **OK (OK)**. 

1. Una volta svuotato, il bucket può essere eliminato. Nell'elenco dei bucket, selezionare la riga del bucket d'interesse (non il suo nome). Selezionare **Delete bucket (Elimina bucket)** e, quando viene richiesto di confermare, selezionare **OK (OK)**. 

Per eliminare l'applicazione da: `WordPress_App` CodeDeploy

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**  
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)

1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.

1. Nell'elenco delle applicazioni, scegli **WordPress\$1App**.

1. Nella pagina **Application details (Dettagli applicazione)**, scegliere **Delete application (Elimina applicazione)**.

1. Quando richiesto, digitare il nome dell'applicazione per confermare che si desidera eliminarla, 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**.

## Fasi successive
<a name="tutorials-wordpress-clean-up-whats-next"></a>

Se sei arrivato qui, complimenti. Hai completato una distribuzione CodeDeploy e quindi aggiornato e ridistribuito il codice del sito. 

# Tutorial: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)
<a name="tutorials-windows"></a>

In questo tutorial, distribuisci una singola pagina Web su una singola istanza Amazon EC2 di Windows Server che esegue Internet Information Services (IIS) come server Web. Questa pagina Web mostra un semplice messaggio «Hello, World\$1» messaggio.

Non hai trovato ciò che cerchi?
+ Per fare pratica con la distribuzione su un'istanza Amazon EC2 di Amazon Linux o Red Hat Enterprise Linux (RHEL), consulta. [Tutorial: Esegui WordPress la distribuzione su un'istanza Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux e Linux, macOS o Unix)](tutorials-wordpress.md)
+ Per esercitarti nella distribuzione su un'istanza locale, invece, consulta [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).

Le fasi di questo tutorial presuppongono l'utilizzo di Windows. Sebbene sia possibile completare la maggior parte di questi passaggi su un computer locale che esegue Linux, macOS o Unix, è necessario adattare quelli che coprono i percorsi di directory basati su Windows, come. `c:\temp` Inoltre, se desideri connetterti all'istanza Amazon EC2, hai bisogno di un'applicazione client in grado di connettersi tramite Remote Desktop Protocol (RDP) all'istanza Amazon EC2 che esegue Windows Server. (Windows include, per impostazione predefinita, un'applicazione client di connessione tramite RDP.)

Prima di iniziare questo tutorial, devi completare i prerequisiti di, tra cui la configurazione dell'utente[Guida introduttiva con CodeDeploy](getting-started-codedeploy.md), l'installazione o l'aggiornamento e la creazione di un profilo di istanza IAM e di un ruolo di servizio. AWS CLI

**Topics**
+ [Fase 1: Avvio di un'istanza Amazon EC2 per Windows Server](tutorials-windows-launch-instance.md)
+ [Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon EC2 di Windows Server](tutorials-windows-configure-content.md)
+ [Passaggio 3: Carica il tuo «ciao, mondo\$1» applicazione per Amazon S3](tutorials-windows-upload-application.md)
+ [Fase 4: Implementa la tua applicazione Hello World](tutorials-windows-deploy-application.md)
+ [Passaggio 5: aggiorna e ridistribuisci il tuo «ciao, mondo\$1» applicazione](tutorials-windows-update-and-redeploy-application.md)
+ [Passaggio 6: ripulisci il tuo «ciao mondo\$1» applicazione e risorse correlate](tutorials-windows-clean-up.md)

# Fase 1: Avvio di un'istanza Amazon EC2 per Windows Server
<a name="tutorials-windows-launch-instance"></a>

Per distribuire l'applicazione Hello World con CodeDeploy, è necessaria un'istanza Amazon EC2 con Windows Server.

Segui le istruzioni in [Crea un'istanza Amazon EC2 per CodeDeploy](instances-ec2-create.md). Quando sei pronto per assegnare un tag di istanza Amazon EC2 all'istanza, assicurati di specificare la chiave del tag e il valore **Name** del tag di. **CodeDeployDemo** Se viene specificata una chiave o un valore del tag, le istruzioni in [Fase 4: Implementa la tua applicazione Hello World](tutorials-windows-deploy-application.md) possono portare a risultati inaspettati.

Dopo aver avviato l'istanza Amazon EC2, torna a questa pagina e passa alla sezione successiva. Non continuare su [Crea un'applicazione con CodeDeploy](applications-create.md) come fase successiva.

## Connect alla tua istanza Amazon EC2
<a name="tutorials-windows-launch-instance-connect"></a>

Dopo l'avvio dell'istanza Amazon EC2, segui queste istruzioni per esercitarti a connetterti ad essa. 

**Nota**  
In queste istruzioni, supponiamo che siano in esecuzione Windows e l'applicazione client Windows Desktop Connection. Per informazioni, consulta [Connessione all'istanza Windows tramite RDP](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/connecting_to_windows_instance.html). Potrebbe essere necessario adeguare queste istruzioni agli altri sistemi operativi o alle applicazioni client di connessione tramite RDP.

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 riquadro di navigazione, in **Istanze** scegli **Istanze**. 

1. Naviga e scegli la tua istanza di Windows Server nell'elenco.

1. Scegli **Connetti**.

1. Scegli **Richiedi la password** e seleziona **Scegli file**.

1. **Cerca e scegli il file della coppia di chiavi dell'istanza Amazon EC2 associato all'istanza Amazon EC2 di Windows Server, quindi scegli Apri.**

1. Selezionare **Decrypt Password (Decifra password)**. Annotare la password che viene visualizzata. Servirà nella fase 10.

1. Selezionare **Download Remote Desktop File (Scarica file per il desktop remoto)** e aprire il file.

1. Continuare nel caso in cui venga richiesta la connessione anche se il publisher della connessione remota non può essere identificato.

1. Digitare la password annotata durante la fase 7, quindi continuare. Se l'applicazione client della connessione tramite RDP richiede un nome utente, digitare **Administrator**.

1. Continuare nel caso in cui venga richiesta la connessione anche se l'identità del computer remoto non può essere verificata. 

1. Dopo la connessione, viene visualizzato il desktop dell'istanza Amazon EC2 che esegue Windows Server.

1. Ora puoi disconnetterti dall'istanza Amazon EC2.
**avvertimento**  
Non arrestare o terminare l'istanza. In caso contrario, non CodeDeploy è possibile eseguire la distribuzione su di essa.

## Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon EC2 di Windows Server
<a name="tutorials-windows-launch-instance-add-inbound-rule"></a>

Il passaggio successivo conferma che la tua istanza Amazon EC2 ha una porta HTTP aperta in modo da poter vedere la pagina Web distribuita sulla tua istanza Amazon EC2 Windows Server in un browser. 

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. Scegli **Istanze**, quindi scegli la tua istanza. 

1. Nella scheda **Descrizione**, in **Gruppi di sicurezza**, scegli **Visualizza regole in entrata**. 

   Dovresti vedere un elenco di regole nel tuo gruppo di sicurezza come il seguente:

   ```
   Security Groups associated with i-1234567890abcdef0
    Ports     Protocol     Source     launch-wizard-N
    22        tcp          0.0.0.0/0          ✔
   ```

1.  In **Gruppi di sicurezza**, scegli il gruppo di sicurezza per la tua istanza Amazon EC2. Potrebbe essere denominato **launch-wizard-*N***. Il nome ***N*** è un numero assegnato al proprio gruppo di sicurezza quando è stata creata l'istanza. 

    Seleziona la scheda **Inbound (In entrata)**. Se il gruppo di sicurezza per la tua istanza è configurato correttamente, dovresti vedere una regola con i seguenti valori: 
   + **Type (Tipo)**: HTTP
   + **Protocollo**: TCP
   + **Port Range** (Intervallo porte): 80
   + **Fonte**: 0.0.0.0/0

1.  Se non vedi una regola con questi valori, usa le procedure in [Aggiungere regole a un gruppo di sicurezza per aggiungerle a una](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) nuova regola di sicurezza. 

# Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon EC2 di Windows Server
<a name="tutorials-windows-configure-content"></a>

Ora è il momento di configurare il contenuto sorgente della tua applicazione in modo da avere qualcosa da distribuire sull'istanza Amazon EC2. Per questo tutorial, distribuirai una singola pagina Web sull'istanza Amazon EC2 che esegue Windows Server, che eseguirà Internet Information Services (IIS) come server Web. Questa pagina Web mostrerà un semplice messaggio «Hello, World\$1» messaggio.

**Topics**
+ [Crea la pagina web](#tutorials-windows-configure-content-download-code)
+ [Crea uno script per eseguire l'applicazione](#tutorials-windows-configure-content-create-scripts)
+ [Aggiungi un file con le specifiche dell'applicazione](#tutorials-windows-configure-content-add-appspec-file)

## Crea la pagina web
<a name="tutorials-windows-configure-content-download-code"></a>

1. Creare una sottodirectory (sottocartella) denominata `HelloWorldApp` nella propria cartella `c:\temp` e quindi passare a questa cartella.

   ```
   mkdir c:\temp\HelloWorldApp
   cd c:\temp\HelloWorldApp
   ```
**Nota**  
Non è necessario utilizzare la posizione `c:\temp` o il nome della sottocartella di `HelloWorldApp`. Se si utilizza una posizione o un nome della sottocartella diverso, assicurarsi di usarlo durante tutto il tutorial.

1. Utilizzare un editor di testo per creare un file all'interno della cartella. Assegnare un nome al file `index.html`.

   ```
   notepad index.html
   ```

1. Aggiungere il codice HTML seguente al file, quindi salvare il file.

   ```
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
   <html>
   <head>
     <title>Hello, World!</title>
     <style>
       body {
         color: #ffffff;
         background-color: #0188cc;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Hello, World!</h1></div>
     <div align="center"><h2>You have successfully deployed an application using CodeDeploy</h2></div>
     <div align="center">
       <p>What to do next? Take a look through the <a href="https://aws.amazon.com/codedeploy">CodeDeploy Documentation</a>.</p>
     </div>
   </body>
   </html>
   ```

## Crea uno script per eseguire l'applicazione
<a name="tutorials-windows-configure-content-create-scripts"></a>

Successivamente, creerai uno script che CodeDeploy verrà utilizzato per configurare il server Web sull'istanza Amazon EC2 di destinazione.

1. Nella stessa sottocartella in cui viene salvato il file `index.html`, utilizzare un editor di testo per creare un altro file. Assegnare un nome al file `before-install.bat`.

   ```
   notepad before-install.bat
   ```

1. Aggiungere lo script batch seguente al file, quindi salvare il file.

   ```
   REM Install Internet Information Server (IIS).
   c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Import-Module -Name ServerManager
   c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Install-WindowsFeature Web-Server
   ```

## Aggiungi un file con le specifiche dell'applicazione
<a name="tutorials-windows-configure-content-add-appspec-file"></a>

Successivamente, aggiungerete un file di specifiche dell'applicazione (AppSpec file) oltre alla pagina Web e al file di script batch. Il AppSpec file è un file in formato [YAML](http://www.yaml.org) utilizzato da: CodeDeploy 
+ Mappare i file sorgente nella revisione dell'applicazione nelle loro destinazioni sull'istanza.
+ Specificare gli script da eseguire sull'istanza durante la distribuzione.

Il AppSpec file deve avere un nome. `appspec.yml` Deve essere inserito nella cartella root del codice sorgente dell'applicazione.

1. Nella stessa sottocartella in cui vengono salvati i file `index.html` e `before-install.bat`, utilizzare un editor di testo per creare un altro file. Assegnare un nome al file `appspec.yml`.

   ```
   notepad appspec.yml
   ```

1. Aggiungere il codice YAML seguente al file, quindi salvare il file.

   ```
   version: 0.0
   os: windows
   files:
     - source: \index.html
       destination: c:\inetpub\wwwroot
   hooks:
     BeforeInstall:
       - location: \before-install.bat
         timeout: 900
   ```

CodeDeploy utilizzerà questo AppSpec file per copiare il `index.html` file nella cartella principale del codice sorgente dell'applicazione nella `c:\inetpub\wwwroot` cartella sull'istanza Amazon EC2 di destinazione. Durante la distribuzione, CodeDeploy eseguirà lo script `before-install.bat` batch sull'istanza Amazon EC2 di destinazione durante l'evento del ciclo di vita della **BeforeInstall** distribuzione. Se l'esecuzione di questo script impiega più di 900 secondi (15 minuti), CodeDeploy interromperà la distribuzione e contrassegnerà la distribuzione sull'istanza Amazon EC2 come fallita.

Per ulteriori informazioni su queste impostazioni, consulta i [CodeDeploy AppSpec riferimento al file](reference-appspec-file.md).

**Importante**  
Le ubicazioni e i numeri di spazi tra ciascuna delle voci in questo file sono importanti. Se la spaziatura non è corretta, CodeDeploy verrà generato un errore di cui potrebbe essere difficile eseguire il debug. Per ulteriori informazioni, consulta [AppSpec Spaziatura tra i file](reference-appspec-file.md#reference-appspec-file-spacing).

# Passaggio 3: Carica il tuo «ciao, mondo\$1» applicazione per Amazon S3
<a name="tutorials-windows-upload-application"></a>

Ora preparerai e caricherai i tuoi contenuti di origine in una posizione da cui CodeDeploy distribuirli. Le seguenti istruzioni mostrano come effettuare il provisioning di un bucket Amazon S3, preparare i file di revisione dell'applicazione per il bucket, raggruppare i file della revisione e quindi inserire la revisione nel bucket.

**Nota**  
Sebbene non sia trattato in questo tutorial, puoi CodeDeploy utilizzarlo per distribuire applicazioni dai repository alle istanze. GitHub Per ulteriori informazioni, consulta [Integrazione con CodeDeploy GitHub](integrations-partners-github.md).

**Topics**
+ [Esegui il provisioning di un bucket Amazon S3](#tutorials-windows-upload-application-create-s3-bucket)
+ [Prepara i file dell'applicazione per il bucket](#tutorials-windows-upload-application-prepare-application-files)
+ [Raggruppa i file dell'applicazione in un unico file di archivio e invia il file di archivio](#tutorials-windows-upload-application-bundle-and-push-archive)

## Esegui il provisioning di un bucket Amazon S3
<a name="tutorials-windows-upload-application-create-s3-bucket"></a>

Crea un contenitore o un *bucket* di storage in Amazon S3 o usa un bucket esistente. Assicurati di poter caricare la revisione nel bucket e che le istanze Amazon EC2 utilizzate nelle distribuzioni possano scaricare la revisione dal bucket.

Puoi usare la AWS CLI console Amazon S3 o Amazon S3 per creare un APIs bucket Amazon S3. Dopo la creazione del bucket, il bucket e l'utente CodeDeploy devono avere l'accesso alle autorizzazioni.

**Nota**  
I nomi dei bucket devono essere univoci in Amazon S3 per AWS tutti gli account. Se non si è in grado di utilizzare **amzn-s3-demo-bucket**, provare un altro nome del bucket, ad esempio **amzn-s3-demo-bucket** seguito da un trattino e le iniziali o altri identificatori univoci. Assicurarsi quindi di sostituire il nome del bucket per **amzn-s3-demo-bucket** ovunque sia presente in questo tutorial.  
Il bucket Amazon S3 deve essere creato nella stessa AWS regione in cui vengono lanciate le istanze Amazon EC2 di destinazione. Ad esempio, se crei il bucket nella regione Stati Uniti orientali (Virginia settentrionale), le istanze Amazon EC2 di destinazione devono essere avviate nella regione Stati Uniti orientali (Virginia settentrionale).

**Topics**
+ [Per creare un bucket Amazon S3 (CLI)](#tutorials-windows-upload-application-create-s3-bucket-cli)
+ [Per creare un bucket Amazon S3 (console)](#tutorials-windows-upload-application-create-s3-bucket-console)
+ [Concedi le autorizzazioni al bucket Amazon S3 e al tuo account AWS](#tutorials-windows-upload-application-create-s3-bucket-grant-permission)

### Per creare un bucket Amazon S3 (CLI)
<a name="tutorials-windows-upload-application-create-s3-bucket-cli"></a>

Chiama il **mb** comando per creare un bucket Amazon S3 denominato: **amzn-s3-demo-bucket**

```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```

### Per creare un bucket Amazon S3 (console)
<a name="tutorials-windows-upload-application-create-s3-bucket-console"></a>

1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nella console Amazon S3, scegli **Crea** bucket.

1. Nella casella **Nome bucket**, digitare un nome per il bucket.

1. Nell'elenco **Regione** selezionare la regione di destinazione, quindi selezionare **Crea**.

### Concedi le autorizzazioni al bucket Amazon S3 e al tuo account AWS
<a name="tutorials-windows-upload-application-create-s3-bucket-grant-permission"></a>

È necessario disporre delle autorizzazioni per il caricamento nel bucket Amazon S3. Puoi specificare queste autorizzazioni tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente `111122223333` all' AWS account di caricare file in qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:PutObject"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "111122223333"
                ]
            }
        }
    ]
}
```

[Per visualizzare l'ID del tuo AWS account, consulta Finding Your account ID. AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId)

Ora è il momento giusto per verificare che il bucket Amazon S3 consenta le richieste di download da ogni istanza Amazon EC2 partecipante. Puoi specificarlo tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente a qualsiasi istanza Amazon EC2 con un profilo di istanza IAM allegato contenente l'ARN di scaricare file `arn:aws:iam::444455556666:role/CodeDeployDemo` da qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "arn:aws:iam::444455556666:role/CodeDeployDemo"
                ]
            }
        }
    ]
}
```

Per informazioni su come generare e allegare una bucket policy di Amazon S3, consulta Esempi di policy [Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).

L'utente CodeDeploy amministrativo in cui hai creato [Fase 1: Configurazione](getting-started-setting-up.md) deve inoltre disporre dell'autorizzazione per caricare la revisione nel bucket Amazon S3. Un modo per specificarlo è tramite una policy IAM, che aggiungi al set di autorizzazioni dell'utente, o a un ruolo IAM (che consenti all'utente di assumere). La seguente policy IAM consente all'utente di caricare le revisioni in qualsiasi punto del bucket Amazon S3 denominato: `amzn-s3-demo-bucket`

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	   
  "Statement":[
    {
      "Effect":"Allow",
      "Action":["s3:PutObject"],
      "Resource":"arn:aws:s3:::amzn-s3-demo-bucket/*"
    }
  ]
}
```

------

*Per informazioni su come creare una policy IAM, consulta [Creating IAM policies nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) User Guide.* Per informazioni sull'aggiunta di una policy a un set di autorizzazioni, consulta [Create a permission set](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) nella *Guida per l'AWS IAM Identity Center utente*.

## Prepara i file dell'applicazione per il bucket
<a name="tutorials-windows-upload-application-prepare-application-files"></a>

Assicurati che la pagina web, il AppSpec file e lo script siano organizzati sulla tua macchina di sviluppo in questo modo:

```
c:\
  |-- temp\
        |--HelloWorldApp\
             |-- appspec.yml
             |-- before-install.bat
             |-- index.html
```

## Raggruppa i file dell'applicazione in un unico file di archivio e invia il file di archivio
<a name="tutorials-windows-upload-application-bundle-and-push-archive"></a>

Raggruppare i file presenti in un file di archivio (noti come *revisione* dell'applicazione).

**Nota**  
Potrebbero essere addebitati dei costi per lo storage degli oggetti in un bucket e per il trasferimento delle revisioni dell'applicazione dentro e fuori un bucket. Per ulteriori informazioni, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/). 

1. Sul computer di sviluppo, passare alla cartella in cui sono archiviati i file: 

   ```
   cd c:\temp\HelloWorldApp
   ```
**Nota**  
Se non si passa a questa cartella, il raggruppamento dei file verrà avviato nella cartella corrente. Ad esempio, se la cartella corrente è `c:\temp` invece di `c:\temp\HelloWorldApp`, il raggruppamento verrà avviato con i file e le sottocartelle presenti nella cartella `c:\temp`, che può includere più di una sottocartella `HelloWorldApp`.

1. Chiamate il **create-application** comando per registrare una nuova applicazione denominata **HelloWorld\$1App** con CodeDeploy:

   ```
   aws deploy create-application --application-name HelloWorld_App
   ```

1. Richiama il comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) per raggruppare i file, caricare le revisioni su Amazon S3 e registrare le informazioni CodeDeploy sulla revisione caricata, il tutto in un'unica operazione. 

   ```
   aws deploy push --application-name HelloWorld_App --s3-location s3://amzn-s3-demo-bucket/HelloWorld_App.zip --ignore-hidden-files
   ```

   Questo comando raggruppa i file dalla directory corrente (esclusi i file nascosti) in un unico file di archivio denominato`HelloWorld_App.zip`, carica la revisione nel **amzn-s3-demo-bucket** bucket e registra le informazioni sulla revisione caricata. CodeDeploy 

# Fase 4: Implementa la tua applicazione Hello World
<a name="tutorials-windows-deploy-application"></a>

Ora distribuisci la revisione di esempio dell'applicazione Hello World che hai caricato su Amazon S3. Utilizzi la console AWS CLI o la CodeDeploy console per distribuire la revisione e monitorare l'avanzamento della distribuzione. Una volta distribuita la revisione dell'applicazione, si possono controllare i risultati.

**Topics**
+ [Implementa la revisione dell'applicazione con CodeDeploy](#tutorials-windows-deploy-application-create-deployment)
+ [Monitora e risolvi i problemi della distribuzione](#tutorials-windows-deploy-application-monitor)
+ [Verifica la tua implementazione](#tutorials-windows-deploy-application-verify)

## Implementa la revisione dell'applicazione con CodeDeploy
<a name="tutorials-windows-deploy-application-create-deployment"></a>

 Puoi distribuire la tua applicazione utilizzando la CLI o la console. 

**Topics**
+ [Per distribuire la revisione dell'applicazione (CLI)](#tutorials-windows-deploy-application-create-deployment-cli)
+ [Per distribuire la revisione dell'applicazione (console)](#tutorials-windows-deploy-application-create-deployment-console)

### Per distribuire la revisione dell'applicazione (CLI)
<a name="tutorials-windows-deploy-application-create-deployment-cli"></a>

1. La distribuzione richiede innanzitutto un gruppo di distribuzione. Tuttavia, prima di creare il gruppo di distribuzione, è necessario un ARN del ruolo del servizio. Un ruolo di servizio è un ruolo IAM che concede al servizio l'autorizzazione ad agire per tuo conto. In questo caso, il ruolo di servizio consente di CodeDeploy accedere alle istanze Amazon EC2 per espandere (leggere) i relativi tag di istanza Amazon EC2.

   Per creare un ruolo del servizio occorre avere già eseguito le istruzioni in [Creare un ruolo di servizio (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli). Per ottenere l'ARN del ruolo del servizio, consulta [Ottieni il ruolo di servizio ARN (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).

1. Ora che hai l'ARN, chiama il **create-deployment-group** comando per creare un gruppo di distribuzione denominato**HelloWorld\$1DepGroup**, associato all'applicazione denominata**HelloWorld\$1App**, utilizzando il tag di istanza Amazon EC2 denominato e la configurazione **CodeDeployDefault.OneAtATime** di distribuzione **CodeDeployDemo** denominata, con il ruolo di servizio ARN:

   ```
   aws deploy create-deployment-group --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --deployment-config-name CodeDeployDefault.OneAtATime --ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE --service-role-arn serviceRoleARN
   ```
**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.

1. Prima di creare una distribuzione, l' CodeDeploy agente deve essere installato sulle istanze del gruppo di distribuzione. È possibile installare l'agente dalla riga di comando con AWS Systems Manager tramite il seguente comando:

   ```
   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 e quindi tenterà di aggiornarlo alle 2:00 ogni domenica mattina. Per ulteriori informazioni sull' CodeDeploy agente, vedere [Lavorare con l' CodeDeploy agente.](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html) 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).

1. Chiamare ora il comando **create-deployment** per creare una distribuzione associata all'applicazione denominata **HelloWorld\$1App**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime** e il gruppo di distribuzione denominato **HelloWorld\$1DepGroup** utilizzando la revisione dell'applicazione denominata **HelloWorld\$1App.zip** nel bucket denominato **amzn-s3-demo-bucket**:

   ```
   aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
   ```

### Per distribuire la revisione dell'applicazione (console)
<a name="tutorials-windows-deploy-application-create-deployment-console"></a>

1. Prima di utilizzare la CodeDeploy console per distribuire la revisione dell'applicazione, è necessario un ARN per il ruolo di servizio. Un ruolo di servizio è un ruolo IAM che autorizza il servizio ad agire per conto dell'utente. In questo caso, il ruolo di servizio consente di CodeDeploy accedere alle istanze Amazon EC2 per espandere (leggere) i relativi tag di istanza Amazon EC2.

   Per creare un ruolo del servizio occorre avere già eseguito le istruzioni in [Crea un ruolo di servizio (console)](getting-started-create-service-role.md#getting-started-create-service-role-console). Per ottenere l'ARN del ruolo del servizio, consulta [Ottieni il ruolo di servizio ARN (console)](getting-started-create-service-role.md#getting-started-get-service-role-console).

1. Ora che hai l'ARN, puoi usare 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 **HelloWorld\$1App**.

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 **HelloWorld\$1DepGroup**.

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. Nella **configurazione dell'ambiente**, seleziona le **istanze Amazon EC2**.

1. Nella **configurazione dell'agente con AWS Systems Manager**, mantieni le impostazioni predefinite.

1. In **Key (Chiave)**, immettere **Name**.

1. In **Valore**, immetti **CodeDeployDemo**.

1. **In **Configurazione di distribuzione, scegli**. CodeDeployDefault OneAtATime**.

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

1. Scegliere **Create deployment group (Crea gruppo di distribuzione)**.

1. Scegli **Create deployment (Crea distribuzione)**.

1. Nel **gruppo Deployment**, scegli **HelloWorld\$1 DepGroup**

1. In **Tipo di revisione**, scegli **La mia applicazione è archiviata in Amazon** S3, quindi **in Posizione di revisione, inserisci la posizione della revisione** dell'applicazione Hello World di esempio che hai precedentemente caricato su Amazon S3. Per ottenere la posizione:

   1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

   1. Nell'elenco dei bucket, scegli **amzn-s3-demo-bucket (o il nome del bucket** in cui hai caricato la revisione dell'applicazione). 

   1. Nell'elenco degli **HelloWorldoggetti**, scegliete \$1App.zip.

   1. Nella scheda **Panoramica**, scegliere **Copia percorso**.

   1. Tornate alla CodeDeploy console e, in **Posizione di revisione**, incollate il valore del campo **Link**.

1. In **Tipo file di revisione**, selezionare **.zip**. 

1. (Facoltativo) Inserire un commento in **Deployment description (Descrizione distribuzione)**.

1. Scegli **Create deployment (Crea distribuzione)**. Nella pagina **Deployments (Distribuzioni)** vengono visualizzate le informazioni relative alla nuova distribuzione creata.

## Monitora e risolvi i problemi della distribuzione
<a name="tutorials-windows-deploy-application-monitor"></a>

Usa la console AWS CLI o la console per monitorare e risolvere i problemi della distribuzione.

**Topics**
+ [Per monitorare e risolvere problemi relativi alla distribuzione (CLI)](#tutorials-windows-deploy-application-monitor-cli)
+ [Per monitorare e risolvere problemi relativi alla distribuzione (console)](#tutorials-windows-deploy-application-monitor-console)

### Per monitorare e risolvere problemi relativi alla distribuzione (CLI)
<a name="tutorials-windows-deploy-application-monitor-cli"></a>

1. Ottenere l'ID della distribuzione chiamando il comando **list-deployments** rispetto all'applicazione denominata **HelloWorld\$1App** e il gruppo di distribuzione denominato **HelloWorld\$1DepGroup**:

   ```
   aws deploy list-deployments --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --query "deployments" --output text
   ```

1. Chiamare il comando **get-deployment** con l'ID di distribuzione:

   ```
   aws deploy get-deployment --deployment-id deploymentID --query "deploymentInfo.status" --output text
   ```

1. Il comando restituisce lo stato complessivo della distribuzione. In caso di esito positivo, il valore è `Succeeded`.

   Se lo stato complessivo è `Failed`, è possibile chiamare comandi quali [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) e [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) per risolvere i problemi. Per ulteriori opzioni di risoluzione dei problemi, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

### Per monitorare e risolvere problemi relativi alla distribuzione (console)
<a name="tutorials-windows-deploy-application-monitor-console"></a>

**Nella pagina **Distribuzioni** della CodeDeploy console, puoi monitorare lo stato della distribuzione nella colonna Stato.**

Per ottenere ulteriori informazioni sulla distribuzione, in particolare se il valore della colonna **Status (Stato)** è diverso da **Succeeded (Riuscito)**:

1. Nella tabella **Deployments (Distribuzioni)**, scegliere il proprio ID di distribuzione. In caso di esito negativo di una distribuzione, nella pagina dei dettagli delle distribuzione viene visualizzato un messaggio che descrive la causa dell'errore.

1. . Vengono visualizzate ulteriori informazioni sulle istanze della distribuzione. Dopo un errore di distribuzione, potresti essere in grado di determinare su quali istanze Amazon EC2 e in quale fase l'implementazione non è riuscita.

1. Se si desidera migliorare la procedura di risoluzione dei problemi, è possibile utilizzare una tecnica come [Visualizza i dettagli dell'istanza con CodeDeploy](instances-view-details.md). Puoi anche analizzare i file di log di distribuzione su un'istanza Amazon EC2. Per ulteriori informazioni, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

## Verifica la tua implementazione
<a name="tutorials-windows-deploy-application-verify"></a>

Se la distribuzione ha esito positivo, verifica il funzionamento dell'installazione. Utilizza l'indirizzo DNS pubblico dell'istanza Amazon EC2 per visualizzare la pagina Web in un browser Web. **(Per ottenere il valore DNS pubblico, nella console Amazon EC2, scegli l'istanza Amazon EC2 e, nella scheda Descrizione, cerca **il** valore in Public DNS.)**

Ad esempio, se l'indirizzo DNS pubblico della tua istanza Amazon EC2 **ec2-01-234-567-890.compute-1.amazonaws.com** è, utilizzerai il seguente URL:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```

In caso di esito positivo, viene visualizzata una pagina Web di Hello, World\$1.

# Passaggio 5: aggiorna e ridistribuisci il tuo «ciao, mondo\$1» applicazione
<a name="tutorials-windows-update-and-redeploy-application"></a>

Ora che hai distribuito correttamente la revisione dell'applicazione, sulla macchina di sviluppo, aggiorna il codice della pagina web e poi usalo CodeDeploy per ridistribuire il sito. Dopo la ridistribuzione, dovresti essere in grado di vedere le modifiche sull'istanza Amazon EC2.

**Topics**
+ [Modifica la pagina web](#tutorials-windows-update-and-redeploy-application-modify-code)
+ [Ridistribuire il sito](#tutorials-windows-update-and-redeploy-application-deploy-updates)

## Modifica la pagina web
<a name="tutorials-windows-update-and-redeploy-application-modify-code"></a>

1. Passa alla sottocartella `c:\temp\HelloWorldApp` e utilizza un editor di testo per modificare il file `index.html`:

   ```
   cd c:\temp\HelloWorldApp
   notepad index.html
   ```

1. Rivedi il contenuto del file `index.html` per modificare il colore di sfondo e parte del testo sulla pagina Web, quindi salva il file:

   ```
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
   <html>
   <head>
     <title>Hello Again, World!</title>
     <style>
       body {
         color: #ffffff;
         background-color: #66cc00;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Hello Again, World!</h1></div>
     <div align="center"><h2>You have successfully deployed a revision of an application using CodeDeploy</h2></div>
     <div align="center">
       <p>What to do next? Take a look through the <a href="https://aws.amazon.com/codedeploy">CodeDeploy Documentation</a>.</p>
     </div>
   </body>
   </html>
   ```

## Ridistribuire il sito
<a name="tutorials-windows-update-and-redeploy-application-deploy-updates"></a>

Ora che hai modificato il codice, usa Amazon S3 e ridistribuisci CodeDeploy la pagina web.

Raggruppa e carica le modifiche su Amazon S3 come descritto in. [Raggruppa i file dell'applicazione in un unico file di archivio e invia il file di archivio](tutorials-windows-upload-application.md#tutorials-windows-upload-application-bundle-and-push-archive) (Mentre segui queste istruzioni, non è necessario creare una nuova applicazione.) Assegna alla revisione la stessa chiave come in precedenza (**HelloWorld\$1App.zip**). Caricalo nello stesso bucket Amazon S3 che hai creato in precedenza (ad esempio,). **amzn-s3-demo-bucket**

Usa la console AWS CLI o la CodeDeploy console per ridistribuire il sito.

**Topics**
+ [Per ridistribuire il sito (CLI)](#tutorials-windows-update-and-redeploy-application-deploy-updates-cli)
+ [Per ridistribuire il sito (console)](#tutorials-windows-update-and-redeploy-application-deploy-updates-console)

### Per ridistribuire il sito (CLI)
<a name="tutorials-windows-update-and-redeploy-application-deploy-updates-cli"></a>

Chiama il comando **create-deployment** per creare una distribuzione basata sulla revisione caricata, di nuovo utilizzando l'applicazione denominata **HelloWorld\$1App**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime**, il gruppo di distribuzione denominato **HelloWorld\$1DepGroup** e la revisione denominata **HelloWorld\$1App.zip** nel bucket denominato **amzn-s3-demo-bucket**:

```
 aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
```

Puoi controllare lo stato della nuova distribuzione, come descritto in [Monitora e risolvi i problemi della distribuzione](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor).

Una CodeDeploy volta ridistribuito il sito, visita nuovamente il sito nel browser Web per verificare che il colore di sfondo e il testo della pagina Web siano stati modificati. (Potrebbe essere necessario aggiornare il browser.) Se il colore di sfondo e il testo sono stati modificati, complimenti. Hai modificato e ridistribuito il sito.

### Per ridistribuire il sito (console)
<a name="tutorials-windows-update-and-redeploy-application-deploy-updates-console"></a>

1. [Accedi Console di gestione AWS e apri la console all'indirizzo /codedeploy. CodeDeploy https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**  
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)

1. Nel riquadro di navigazione , scegliere **Applications (Applicazioni)**.

1. Nell'elenco **Applicazioni**, scegli **HelloWorld\$1App**.

1. Nella scheda **Deployments (Distribuzioni)**, scegliere **Create deployment (Crea distribuzione)**.

   1. Nell'elenco dei **gruppi di distribuzione**, scegli **HelloWorld\$1 DepGroup**.

   1.  In **Luogo di revisione**, inserisci il link Amazon S3 per la revisione.

      Per individuare il valore del link:

      1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

         Cerca e apri **amzn-s3-demo-bucket**, quindi scegli la tua revisione nella console Amazon S3. **HelloWorld\$1App.zip**

      1. Se il riquadro **Proprietà** non è visibile nella console Amazon S3, scegli il pulsante **Proprietà**.

      1. Nel riquadro **Properties (Proprietà)**, copiare il valore del campo **Link (Collegamento)**.

      1. Torna alla CodeDeploy console, quindi incolla il link nella posizione di **revisione**.

   1. In **Revision file type (Tipo di file della revisione)**, se viene visualizzato un messaggio che afferma che non è possibile rilevare il tipo di file, scegliere **.zip**.

   1. Lasciare vuoto il campo **Deployment description (Descrizione distribuzione)**.

   1. **Espandi le sostituzioni del gruppo di** **distribuzione Nell'elenco di **configurazione della distribuzione**, scegli. CodeDeployDefault OneAtATime**, quindi scegli **Crea** distribuzione. 

      È possibile controllare lo stato della distribuzione come descritto in [Monitora e risolvi i problemi della distribuzione](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor).

      Una CodeDeploy volta ridistribuito il sito, visita nuovamente il sito nel browser Web per verificare che il colore di sfondo e il testo della pagina Web siano stati modificati. (Potrebbe essere necessario aggiornare il browser.) Se il colore di sfondo e il testo sono stati modificati, complimenti. Hai modificato e ridistribuito il sito.

# Passaggio 6: ripulisci il tuo «ciao mondo\$1» applicazione e risorse correlate
<a name="tutorials-windows-clean-up"></a>

Ora hai effettuato con successo un aggiornamento a «Hello, World\$1» codificare e ridistribuire il sito. Per evitare addebiti continuativi per risorse create per completare questo tutorial, devi eliminare:
+ Qualsiasi CloudFormation stack (o termina qualsiasi istanza Amazon EC2, se le hai create all'esterno). CloudFormation
+ Qualsiasi bucket Amazon S3.
+ L'applicazione `HelloWorld_App` in CodeDeploy.
+ L'associazione AWS Systems Manager State Manager dell' CodeDeploy agente.

Puoi usare Amazon S3 CloudFormation, Amazon EC2 CodeDeploy e le console oppure eseguire AWS APIs la pulizia. AWS CLI

**Topics**
+ [Come procedere all'eliminazione delle risorse (CLI)](#tutorials-windows-clean-up-cli)
+ [Per cancellare le risorse (console)](#tutorials-windows-clean-up-console)
+ [Fasi successive](#tutorials-windows-clean-up-whats-next)

## Come procedere all'eliminazione delle risorse (CLI)
<a name="tutorials-windows-clean-up-cli"></a>

1. Se hai usato lo CloudFormation stack per questo tutorial, elimina lo stack chiamando il comando sullo stack denominato. **delete-stack** **CodeDeployDemoStack** Ciò interrompe tutte le istanze Amazon EC2 associate ed elimina tutti i ruoli IAM associati originariamente creati dallo stack.

   ```
   aws cloudformation delete-stack --stack-name CodeDeployDemoStack
   ```

1. Per eliminare il bucket Amazon S3, chiama il **rm** comando con lo **--recursive** switch accanto al bucket denominato. **amzn-s3-demo-bucket** Il bucket e tutti gli oggetti in esso contenuti saranno quindi eliminati.

   ```
   aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
   ```

1. Per eliminare l'`HelloWorld_App`applicazione da CodeDeploy, chiama il comando. **delete-application** Così facendo, saranno eliminati tutti i record del gruppo di distribuzione associato e i record di distribuzione dell'applicazione.

   ```
   aws deploy delete-application --application-name HelloWorld_App
   ```

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

1. Se non hai utilizzato lo CloudFormation stack per questo tutorial, chiama il **terminate-instances** comando per terminare le istanze Amazon EC2 che hai creato manualmente. Fornisci l'ID dell'istanza Amazon EC2 da terminare.

   ```
   aws ec2 terminate-instances --instance-ids instanceId
   ```

## Per cancellare le risorse (console)
<a name="tutorials-windows-clean-up-console"></a>

Se hai utilizzato il nostro CloudFormation modello per questo tutorial, elimina lo stack associato CloudFormation .

1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Nella casella di ricerca, digita il nome dello CloudFormation stack (ad esempio,). **CodeDeployDemoStack**

1. Seleziona la casella posta accanto al nome dello stack.

1. Nel menu **Actions (Operazioni)**, scegli **Delete Stack (Elimina stack)**. Ciò elimina lo stack, termina tutte le istanze Amazon EC2 associate ed elimina tutti i ruoli IAM associati.

Per terminare le istanze Amazon EC2 che hai creato al di fuori di uno stack: CloudFormation 

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. Nell'area **Instances (Istanze)**, scegliere proprio **Instances (Istanze)**.

1. **Nella casella di ricerca, digita il nome dell'istanza Amazon EC2 che desideri terminare, quindi premi Invio.**

1. Scegli l'istanza Amazon EC2.

1. Selezionare **Actions (Operazioni)**, passare a **Instance State (Stato istanza)**, quindi selezionare **Terminate (Termina)**. Quando richiesto, scegliere **Yes, Terminate (Sì, termina)**. Ripeti questi passaggi per eventuali istanze Amazon EC2 aggiuntive.

Per eliminare il bucket Amazon S3:

1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nell'elenco dei bucket, cerca e scegli il nome del bucket Amazon S3 (ad esempio,). **amzn-s3-demo-bucket**

1. Per eliminare un bucket, occorre innanzitutto rimuoverne i contenuti. Selezionare tutti i file nel bucket, ad esempio **HelloWorld\$1App.zip**. Dal menu **Actions (Operazioni)**, scegliere **Delete (Elimina)**. Quando viene richiesto di confermare l'eliminazione, scegliere **OK (OK)**. 

1. Una volta svuotato, il bucket può essere eliminato. Nell'elenco dei bucket, selezionare la riga del bucket d'interesse (non il suo nome). Selezionare **Delete bucket (Elimina bucket)** e, quando viene richiesto di confermare, selezionare **OK (OK)**. 

Per eliminare l'applicazione da: `HelloWorld_App` CodeDeploy

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](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 **`HelloWorld_App`**.

1. Scegli **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**.

## Fasi successive
<a name="tutorials-windows-clean-up-whats-next"></a>

Se sei arrivato qui, hai completato con successo una distribuzione con. CodeDeploy Complimenti\$1

# Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)
<a name="tutorials-on-premises-instance"></a>

Questo tutorial ti aiuta ad acquisire esperienza CodeDeploy guidandoti nella distribuzione di una revisione di un'applicazione di esempio su una singola istanza locale, ovvero un dispositivo fisico che non è un'istanza Amazon EC2, che esegue Windows Server, Ubuntu Server o Red Hat Enterprise Linux (RHEL). Per informazioni sulle istanze locali e su come funzionano, consulta. CodeDeploy [Utilizzo di istanze locali per CodeDeploy](instances-on-premises.md)

Non hai trovato ciò che cerchi?
+ Per fare pratica con la distribuzione su un'istanza Amazon EC2 che esegue Amazon Linux o RHEL, consulta. [Tutorial: Esegui WordPress la distribuzione su un'istanza Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux e Linux, macOS o Unix)](tutorials-wordpress.md)
+ Per fare pratica con la distribuzione su un'istanza Amazon EC2 che esegue Windows Server, consulta. [Tutorial: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)](tutorials-windows.md)

**Topics**
+ [Prerequisiti](tutorials-on-premises-instance-prerequisites.md)
+ [Fase 1: Configurare l'istanza locale](tutorials-on-premises-instance-1-configure-instance.md)
+ [Passaggio 2: creare una revisione di esempio dell'applicazione](tutorials-on-premises-instance-2-create-sample-revision.md)
+ [Fase 3: raggruppa e carica la revisione dell'applicazione su Amazon S3](tutorials-on-premises-instance-3-bundle-sample-revision.md)
+ [Fase 4: Implementa la revisione dell'applicazione](tutorials-on-premises-instance-4-deploy-sample-revision.md)
+ [Passaggio 5: verifica la distribuzione](tutorials-on-premises-instance-5-verify-deployment.md)
+ [Fase 6: eliminare le risorse](tutorials-on-premises-instance-6-clean-up-resources.md)

# Prerequisiti
<a name="tutorials-on-premises-instance-prerequisites"></a>

Prima di iniziare questo tutorial, devi completare i prerequisiti di cui sopra[Guida introduttiva con CodeDeploy](getting-started-codedeploy.md), che includono la configurazione di un utente, l'installazione o l'aggiornamento di e la creazione di un ruolo di servizio AWS CLI. Non è necessario creare un profilo di istanza IAM come descritto nei prerequisiti. Le istanze locali non utilizzano profili di istanza IAM.

Il dispositivo fisico da configurare come istanza locale deve eseguire uno dei sistemi operativi elencati in [Sistemi operativi supportati dall'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).

# Fase 1: Configurare l'istanza locale
<a name="tutorials-on-premises-instance-1-configure-instance"></a>

Per poter procedere alla distribuzione, occorre innanzitutto configurare l'istanza locale. Segui le istruzioni riportate in [Utilizzo di istanze locali per CodeDeploy](instances-on-premises.md), poi torna a questa pagina.

## Installa l'agente CodeDeploy
<a name="tutorials-on-premises-instance-1-configure-instance-agent"></a>

Dopo aver configurato l'istanza locale, segui i passaggi per le istanze locali in [Installare l' CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install.html) e torna a questa pagina.

# Passaggio 2: creare una revisione di esempio dell'applicazione
<a name="tutorials-on-premises-instance-2-create-sample-revision"></a>

Questa fase prevede la creazione di una revisione di applicazione esemplificativa da distribuire sull'istanza locale. 

Poiché è difficile sapere quali software e funzionalità sono già installati, o quali sono autorizzati dalle politiche dell'organizzazione, sull'istanza locale, la revisione di esempio dell'applicazione che offriamo qui utilizza semplicemente script batch (per Windows Server) o script di shell (per Ubuntu Server e RHEL) per scrivere file di testo in una posizione sull'istanza locale. Viene scritto un file per ciascuno dei diversi eventi del ciclo di vita della CodeDeploy distribuzione, tra cui **Install **AfterInstall****, **ApplicationStart**, e **ValidateService**. Durante l'evento del ciclo di vita della **BeforeInstall**distribuzione, verrà eseguito uno script per rimuovere i vecchi file scritti durante le distribuzioni precedenti di questo esempio e creare una posizione sull'istanza locale in cui scrivere i nuovi file. 

**Nota**  
La distribuzione di questa revisione di applicazione esemplificativa potrebbe non riuscire in presenza di una delle condizioni seguenti:  
L'utente che avvia l' CodeDeploy agente sull'istanza locale non dispone dell'autorizzazione per eseguire script.
L'utente non dispone dell'autorizzazione per creare o eliminare cartelle nelle posizioni elencate negli script.
L'utente non è autorizzato a creare file di testo nelle posizioni elencate negli script.

**Nota**  
Se hai configurato un'istanza di Windows Server e desideri distribuire un campione diverso, potresti voler utilizzare quello illustrato [Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon EC2 di Windows Server](tutorials-windows-configure-content.md) nel [Tutorial: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)](tutorials-windows.md) tutorial.  
Se hai configurato un'istanza RHEL e desideri distribuire un esempio diverso, potresti voler utilizzare quello illustrato [Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2](tutorials-wordpress-configure-content.md) nel tutorial. [Tutorial: Esegui WordPress la distribuzione su un'istanza Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux e Linux, macOS o Unix)](tutorials-wordpress.md)  
Al momento, non esiste un esempio alternativo per Ubuntu Server.

1. Nel computer di sviluppo, crea innanzitutto una sottodirectory (sottocartella) denominata `CodeDeployDemo-OnPrem` che archivi i file della revisione di applicazione esemplificativa, poi accedi a tale sottocartella. Per questo esempio, supponiamo che utilizzerai la `c:\temp` cartella come cartella principale per Windows Server o la `/tmp` cartella come cartella principale per Ubuntu Server e RHEL. È possibile utilizzare una cartella diversa, prestando attenzione a sostituirla alla nostra coerentemente nel corso dell'intero tutorial: 

   Per Windows:

   ```
   mkdir c:\temp\CodeDeployDemo-OnPrem
   cd c:\temp\CodeDeployDemo-OnPrem
   ```

   Per Linux, macOS o Unix:

   ```
   mkdir /tmp/CodeDeployDemo-OnPrem
   cd /tmp/CodeDeployDemo-OnPrem
   ```

1. Nella radice della sottocartella `CodeDeployDemo-OnPrem`, utilizza un editor di testo per creare due file denominati `appspec.yml` e `install.txt`:

   `appspec.yml`per Windows Server:

   ```
   version: 0.0
   os: windows
   files:
     - source: .\install.txt
       destination: c:\temp\CodeDeployExample
   hooks:
     BeforeInstall:
       - location: .\scripts\before-install.bat
         timeout: 900
     AfterInstall:
       - location: .\scripts\after-install.bat     
         timeout: 900
     ApplicationStart:
       - location: .\scripts\application-start.bat  
         timeout: 900
     ValidateService:
       - location: .\scripts\validate-service.bat    
         timeout: 900
   ```

   `appspec.yml`per Ubuntu Server e RHEL:

   ```
   version: 0.0
   os: linux
   files:
     - source: ./install.txt
       destination: /tmp/CodeDeployExample
   hooks:
     BeforeInstall:
       - location: ./scripts/before-install.sh
         timeout: 900
     AfterInstall:
       - location: ./scripts/after-install.sh
         timeout: 900
     ApplicationStart:
       - location: ./scripts/application-start.sh
         timeout: 900
     ValidateService:
       - location: ./scripts/validate-service.sh
         timeout: 900
   ```

   Per ulteriori informazioni sui AppSpec file, vedere [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md) e[CodeDeploy AppSpec riferimento al file](reference-appspec-file.md).

   `install.txt`:

   ```
   The Install deployment lifecycle event successfully completed.
   ```

1. Nella radice della sottocartella `CodeDeployDemo-OnPrem`, crea una sottocartella `scripts` per poi accedervi:

   Per Windows:

   ```
   mkdir c:\temp\CodeDeployDemo-OnPrem\scripts
   cd c:\temp\CodeDeployDemo-OnPrem\scripts
   ```

   Per Linux, macOS o Unix:

   ```
   mkdir -p /tmp/CodeDeployDemo-OnPrem/scripts
   cd /tmp/CodeDeployDemo-OnPrem/scripts
   ```

1. Nella radice della `scripts` sottocartella, utilizzate un editor di testo per creare quattro file denominati`before-install.bat`,`after-install.bat`,`application-start.bat`, e `validate-service.bat` per Windows Server oppure, `before-install.sh` `after-install.sh``application-start.sh`, e `validate-service.sh` per Ubuntu Server e RHEL:

   Per Windows Server:

   `before-install.bat`:

   ```
   set FOLDER=%HOMEDRIVE%\temp\CodeDeployExample
   
   if exist %FOLDER% (
     rd /s /q "%FOLDER%"
   )
   
   mkdir %FOLDER%
   ```

   `after-install.bat`:

   ```
   cd %HOMEDRIVE%\temp\CodeDeployExample
   
   echo The AfterInstall deployment lifecycle event successfully completed. > after-install.txt
   ```

   `application-start.bat`:

   ```
   cd %HOMEDRIVE%\temp\CodeDeployExample
   
   echo The ApplicationStart deployment lifecycle event successfully completed. > application-start.txt
   ```

   `validate-service.bat`:

   ```
   cd %HOMEDRIVE%\temp\CodeDeployExample
   
   echo The ValidateService deployment lifecycle event successfully completed. > validate-service.txt
   ```

   Per Ubuntu Server e RHEL:

   `before-install.sh`:

   ```
   #!/bin/bash
   export FOLDER=/tmp/CodeDeployExample
   
   if [ -d $FOLDER ]
   then
    rm -rf $FOLDER
   fi
   
   mkdir -p $FOLDER
   ```

   `after-install.sh`:

   ```
   #!/bin/bash
   cd /tmp/CodeDeployExample
   
   echo "The AfterInstall deployment lifecycle event successfully completed." > after-install.txt
   ```

   `application-start.sh`:

   ```
   #!/bin/bash
   cd /tmp/CodeDeployExample
   
   echo "The ApplicationStart deployment lifecycle event successfully completed." > application-start.txt
   ```

   `validate-service.sh`:

   ```
   #!/bin/bash
   cd /tmp/CodeDeployExample
   
   echo "The ValidateService deployment lifecycle event successfully completed." > validate-service.txt
   
   unset FOLDER
   ```

1. Solo per Ubuntu Server e RHEL, assicurati che i quattro script di shell abbiano i permessi di esecuzione:

   ```
   chmod +x ./scripts/*
   ```

# Fase 3: raggruppa e carica la revisione dell'applicazione su Amazon S3
<a name="tutorials-on-premises-instance-3-bundle-sample-revision"></a>

Prima di poter distribuire la revisione dell'applicazione, dovrai raggruppare i file e quindi caricare il pacchetto di file in un bucket Amazon S3. A tale scopo, segui le istruzioni riportate in [Crea un'applicazione con CodeDeploy](applications-create.md) e [Invia una revisione CodeDeploy ad Amazon S3 (solo distribuzioni EC2/on-premise)](application-revisions-push.md). (Consigliamo di utilizzare i nomi `CodeDeploy-OnPrem-App` per l'applicazione e `CodeDeploy-OnPrem-DG` per il gruppo di distribuzione, nonostante la denominazione sia libera, a discrezione dell'utente.) Dopo avere effettuato quanto riportato nelle istruzioni, torna a questa pagina. 

**Nota**  
In alternativa, puoi caricare il pacchetto di file in un GitHub repository e distribuirlo da lì. Per ulteriori informazioni, consulta [Integrazione con CodeDeploy GitHub](integrations-partners-github.md).

# Fase 4: Implementa la revisione dell'applicazione
<a name="tutorials-on-premises-instance-4-deploy-sample-revision"></a>

Dopo aver caricato la revisione dell'applicazione in un bucket Amazon S3, prova a distribuirla sulla tua istanza locale. Segui le istruzioni riportate in [Crea una distribuzione con CodeDeploy](deployments-create.md), poi torna a questa pagina.

# Passaggio 5: verifica la distribuzione
<a name="tutorials-on-premises-instance-5-verify-deployment"></a>

Per verificare l'avvenuta distribuzione, segui le istruzioni riportate in [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md), poi torna a questa pagina.

Se la distribuzione ha avuto successo, troverai quattro file di testo nella `c:\temp\CodeDeployExample` cartella (per Windows Server) o `/tmp/CodeDeployExample` (per Ubuntu Server e RHEL). 

Se la distribuzione non riesce, segui le istruzioni per la risoluzione dei problemi riportate in [Visualizza i dettagli dell'istanza con CodeDeploy](instances-view-details.md) e [Risoluzione dei problemi relativi alle istanze](troubleshooting-ec2-instances.md). Apporta quindi le necessarie modifiche correttive, aggrega e carica nuovamente la revisione di applicazione e, infine, ritenta la distribuzione.

# Fase 6: eliminare le risorse
<a name="tutorials-on-premises-instance-6-clean-up-resources"></a>

Per evitare addebiti continui per le risorse che hai creato per questo tutorial, elimina il bucket Amazon S3 se non lo utilizzerai più. Puoi anche pulire le risorse associate, come i record dell'applicazione e del gruppo di distribuzione CodeDeploy e l'istanza locale.

Puoi utilizzare AWS CLI o una combinazione delle console Amazon S3 CodeDeploy e AWS CLI per ripulire le risorse. 

## Risorse di pulizia (CLI)
<a name="tutorials-on-premises-instance-6-clean-up-resources-cli"></a>

**Per eliminare il bucket Amazon S3**
+ Chiamare il comando [rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) e l'opzione `--recursive` per il bucket (ad esempio, `amzn-s3-demo-bucket`). Il bucket e tutti gli oggetti in esso contenuti saranno eliminati. 

  ```
  aws s3 rm s3://your-bucket-name --recursive --region region
  ```

**Per eliminare i record dell'applicazione e del gruppo di distribuzione in CodeDeploy**
+ Richiamate il comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) sull'applicazione (ad esempio,`CodeDeploy-OnPrem-App`). I record della distribuzione e del gruppo di distribuzione saranno eliminati. 

  ```
  aws deploy delete-application --application-name your-application-name
  ```<a name="tutorials-on-premises-instance-6-clean-up-resources-deregister-cli"></a>

**Per annullare la registrazione dell'istanza locale ed eliminare l'utente IAM**
+ Chiama il comando [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) sull'istanza e sulla regione locali:

  ```
  aws deploy deregister --instance-name your-instance-name --delete-iam-user --region your-region
  ```
**Nota**  
Se non desideri eliminare l'utente IAM associato a questa istanza locale, utilizza invece l'opzione. `--no-delete-iam-user`

**Per disinstallare l' CodeDeploy agente e rimuovere il file di configurazione dall'istanza locale**
+ Dall'istanza locale, chiamate il comando [uninstall](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html):

  ```
  aws deploy uninstall
  ```

A questo punto, la procedura di eliminazione delle risorse impiegate per il tutorial è completa e conclusa.

## Pulisci le risorse (console)
<a name="tutorials-on-premises-instance-6-clean-up-resources-console"></a>

**Per eliminare il bucket Amazon S3**

1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Selezionare l'icona posta accanto al bucket da eliminare (ad esempio, `amzn-s3-demo-bucket`), ma non selezionare il bucket stesso.

1. Scegli **Azioni**, quindi **Elimina**. 

1. Quando viene richiesto di eliminare il bucket, scegliere **OK (OK)**. 

**Per eliminare i record dell'applicazione e del gruppo di distribuzione in CodeDeploy**

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**  
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)

1. Nel riquadro di navigazione, scegliere **Applications (Applicazioni)**.

1. Scegliere il nome dell'applicazione che si desidera eliminare (ad esempio, `CodeDeploy-OnPrem-App`), quindi selezionare **Delete (Elimina)**.

1. Quando richiesto, digitare il nome dell'applicazione per confermare che si desidera eliminarla, quindi scegliere **Delete (Elimina)**. 

Non è possibile utilizzare la AWS CodeDeploy console per annullare la registrazione dell'istanza locale o disinstallare l'agente. CodeDeploy Segui le istruzioni in [Per annullare la registrazione dell'istanza locale ed eliminare l'utente IAM](#tutorials-on-premises-instance-6-clean-up-resources-deregister-cli).

# Tutorial: CodeDeploy Da utilizzare per distribuire un'applicazione in un gruppo di Auto Scaling
<a name="tutorials-auto-scaling-group"></a>

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
<a name="tutorials-auto-scaling-group-prerequisites"></a>

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
<a name="tutorials-auto-scaling-group-create-auto-scaling-group"></a>

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)
<a name="tutorials-auto-scaling-group-create-auto-scaling-group-cli"></a>

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)
<a name="tutorials-auto-scaling-group-create-auto-scaling-group-console"></a>

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
<a name="tutorials-auto-scaling-group-create-deployment"></a>

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)
<a name="tutorials-auto-scaling-group-create-deployment-cli"></a>

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)
<a name="tutorials-auto-scaling-group-create-deployment-console"></a>

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
<a name="tutorials-auto-scaling-group-verify"></a>

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)
<a name="tutorials-auto-scaling-group-verify-cli"></a>

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)
<a name="tutorials-auto-scaling-group-verify-console"></a>

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
<a name="tutorials-auto-scaling-group-scale-up"></a>

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)
<a name="tutorials-auto-scaling-group-scale-up-cli"></a>

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)
<a name="tutorials-auto-scaling-group-scale-up-console"></a>

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
<a name="tutorials-auto-scaling-group-reverify"></a>

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)
<a name="tutorials-auto-scaling-group-reverify-cli"></a>

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)
<a name="tutorials-auto-scaling-group-reverify-console"></a>

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
<a name="tutorials-auto-scaling-group-clean-up"></a>

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)
<a name="tutorials-auto-scaling-group-clean-up-cli"></a>

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)
<a name="tutorials-auto-scaling-group-clean-up-console"></a>

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

# Tutorial: utilizzare CodeDeploy per distribuire un'applicazione da GitHub
<a name="tutorials-github"></a>

In questo tutorial, utilizzerai CodeDeploy per distribuire una revisione di un'applicazione di esempio da GitHub una singola istanza Amazon EC2 che esegue Amazon Linux, una singola istanza Red Hat Enterprise Linux (RHEL) o una singola istanza di Windows Server. Per informazioni sull' GitHub integrazione con, consulta. CodeDeploy [Integrazione con CodeDeploy GitHub](integrations-partners-github.md)

**Nota**  
È inoltre possibile utilizzare CodeDeploy per distribuire una revisione dell'applicazione da un'istanza GitHub di Ubuntu Server. È possibile utilizzare la revisione di esempio descritta [Passaggio 2: creare una revisione di esempio dell'applicazione](tutorials-on-premises-instance-2-create-sample-revision.md) in [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md) oppure creare una revisione compatibile con un'istanza di Ubuntu Server e. CodeDeploy Per creare una tua revisione, consulta [Pianifica una revisione per CodeDeploy](application-revisions-plan.md) e [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md).

**Topics**
+ [Prerequisiti](tutorials-github-prerequisites.md)
+ [Passaggio 1: configura un account GitHub](tutorials-github-create-github-account.md)
+ [Passaggio 2: crea un GitHub repository](tutorials-github-create-github-repository.md)
+ [Passaggio 3: carica un'applicazione di esempio nel tuo GitHub repository](tutorials-github-upload-sample-revision.md)
+ [Fase 4: Eseguire il provisioning di un'istanza](tutorials-github-provision-instance.md)
+ [Passaggio 5: creare un'applicazione e un gruppo di distribuzione](tutorials-github-create-application.md)
+ [Fase 6: Distribuire l'applicazione sull'istanza](tutorials-github-deploy-application.md)
+ [Fase 7: Monitoraggio e verifica della distribuzione](tutorials-github-verify.md)
+ [Fase 8: Pulizia](tutorials-github-clean-up.md)

# Prerequisiti
<a name="tutorials-github-prerequisites"></a>

Prima di iniziare il tutorial effettua le seguenti operazioni:
+ Installa Git sul computer locale. Per installare Git, vedi [Git downloads](http://git-scm.com/downloads).
+ Completa i passi in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md), inclusi l'installazione e la configurazione dell' AWS CLI. Ciò è particolarmente importante se desideri utilizzare il AWS CLI per distribuire una revisione dall' GitHub istanza.

# Passaggio 1: configura un account GitHub
<a name="tutorials-github-create-github-account"></a>

È necessario un GitHub account per creare un GitHub repository in cui archiviare la revisione. Se hai già un GitHub account, vai avanti a. [Passaggio 2: crea un GitHub repository](tutorials-github-create-github-repository.md)

1. Vai a [https://github.com/join](https://github.com).

1. Digitare un nome utente, un indirizzo e-mail e una password.

1. Scegli **Iscriviti a GitHub**, quindi segui le istruzioni.

# Passaggio 2: crea un GitHub repository
<a name="tutorials-github-create-github-repository"></a>

Avrai bisogno di un GitHub repository per archiviare la revisione.

Se hai già un GitHub repository, assicurati di sostituirlo con il nome **CodeDeployGitHubDemo** durante questo tutorial, e poi vai avanti a. [Passaggio 3: carica un'applicazione di esempio nel tuo GitHub repository](tutorials-github-upload-sample-revision.md) 

1. Nella [GitHub home page](https://github.com/dashboard), esegui una delle seguenti operazioni:
   + In **Your repositories (I tuoi repository)**, scegliere **New repository (Nuovo repository)**.
   + Nella barra di navigazione, scegliere **Create new (Crea nuovo)** (**\$1**) e quindi selezionare **New repository (Nuovo repository)**.

1. Nella pagina **Create a new repository (Crea un nuovo repository)**, eseguire queste operazioni:
   + Nel riquadro **Repository name (Nome repository)** immetti **CodeDeployGitHubDemo**.
   + Selezionare **Public (Pubblico)**.
**Nota**  
Selezionando l'opzione predefinita **Public (Pubblico)** chiunque può vedere questo repository. È possibile selezionare l'opzione **Private (Privato)** per limitare chi può visualizzare e eseguire il commit nel repository. 
   + Deselezionare la casella di controllo **Initialize this repository with a README (Inizializza il repository con un README)**. Un file `README.md` potrà essere creato manualmente al prossimo passaggio.
   + Scegli **Create repository (Crea repository)**.

1. Seguire le istruzioni per il tipo di computer locale per utilizzare la riga di comando per creare il repository.
**Nota**  
Se hai abilitato l'autenticazione a due fattori GitHub, assicurati di inserire il token di accesso personale anziché la password di GitHub accesso se ti viene richiesta una password. Per informazioni, consulta [Fornire il codice di autenticazione 2FA](https://help.github.com/articles/providing-your-2fa-authentication-code/).

**Su macchine Linux, macOS o Unix locali:**

1. Dal terminale, esegui i seguenti comandi, uno alla volta, *user-name* dov'è il tuo nome GitHub utente:

   ```
   mkdir /tmp/CodeDeployGitHubDemo
   ```

   ```
   cd /tmp/CodeDeployGitHubDemo
   ```

   ```
   touch README.md
   ```

   ```
   git init
   ```

   ```
   git add README.md
   ```

   ```
   git commit -m "My first commit"
   ```

   ```
   git remote add origin https://github.com/user-name/CodeDeployGitHubDemo.git
   ```

   ```
   git push -u origin master
   ```

1. Lasciare il terminale aperto nel percorso `/tmp/CodeDeployGitHubDemo`.

**Nei computer Windows locali:**

1. Dal prompt dei comandi in esecuzione come amministratore, eseguire i comandi seguenti, uno alla volta:

   ```
   mkdir c:\temp\CodeDeployGitHubDemo
   ```

   ```
   cd c:\temp\CodeDeployGitHubDemo
   ```

   ```
   notepad README.md
   ```

1. Salvare il file `README.md` in Blocco note. Chiudere Blocco note. Esegui i seguenti comandi, uno alla volta, *user-name* dov'è il tuo nome GitHub utente:

   ```
   git init
   ```

   ```
   git add README.md
   ```

   ```
   git commit -m "My first commit"
   ```

   ```
   git remote add origin https://github.com/user-name/CodeDeployGitHubDemo.git
   ```

   ```
   git push -u origin master
   ```

1. Lasciare il prompt dei comandi aperto nel percorso `c:\temp\CodeDeployGitHubDemo`.

# Passaggio 3: carica un'applicazione di esempio nel tuo GitHub repository
<a name="tutorials-github-upload-sample-revision"></a>

In questo passaggio, copierai una revisione di esempio da un bucket Amazon S3 pubblico nel tuo repository. GitHub Per semplicità, le revisioni di esempio fornite per questo tutorial sono singole pagine Web.

**Nota**  
Se utilizzi una delle tue revisioni anziché la nostra revisione di esempio, la tua revisione deve:   
Seguire le linee guida in [Pianifica una revisione per CodeDeploy](application-revisions-plan.md) e [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md).
Utilizzare il tipo di istanza corrispondente.
Sii accessibile dalla tua dashboard. GitHub 
Se la tua revisione soddisfa questi requisiti, passa alla [Passaggio 5: creare un'applicazione e un gruppo di distribuzione](tutorials-github-create-application.md).  
Se stai distribuendo su un'istanza di Ubuntu Server, dovrai caricare nel tuo GitHub repository una revisione compatibile con un'istanza di Ubuntu Server e. CodeDeploy Per ulteriori informazioni, consultare [Pianifica una revisione per CodeDeploy](application-revisions-plan.md) e [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md).

**Topics**
+ [Invia una revisione di esempio da un computer Linux, macOS o Unix locale](#tutorials-github-upload-sample-revision-unixes)
+ [Eseguire il push di una revisione di esempio da un computer Windows locale](#tutorials-github-upload-sample-revision-windows)

## Invia una revisione di esempio da un computer Linux, macOS o Unix locale
<a name="tutorials-github-upload-sample-revision-unixes"></a>

Con il tuo terminale ancora aperto su un percorso, ad esempio `/tmp/CodeDeployGitHubDemo`, esegui i seguenti comandi uno alla volta: 

**Nota**  
Se prevedi di eseguire la distribuzione su un'istanza di Windows Server, `SampleApp_Windows.zip` sostituiscila nei comandi. `SampleApp_Linux.zip`

```
(Amazon S3 copy command)
```

```
unzip SampleApp_Linux.zip
```

```
rm SampleApp_Linux.zip
```

 

```
git add .
```

```
git commit -m "Added sample app"
```

```
git push
```

*(Amazon S3 copy command)*Dov'è uno dei seguenti: 
+ `aws s3 cp s3://aws-codedeploy-us-east-2/samples/latest/SampleApp_Linux.zip . --region us-east-2`per la regione Stati Uniti orientali (Ohio)
+ `aws s3 cp s3://aws-codedeploy-us-east-1/samples/latest/SampleApp_Linux.zip . --region us-east-1`per la regione Stati Uniti orientali (Virginia settentrionale)
+ `aws s3 cp s3://aws-codedeploy-us-west-1/samples/latest/SampleApp_Linux.zip . --region us-west-1` per Regione Stati Uniti occidentali (California settentrionale)
+ `aws s3 cp s3://aws-codedeploy-us-west-2/samples/latest/SampleApp_Linux.zip . --region us-west-2`per la regione Stati Uniti occidentali (Oregon)
+ `aws s3 cp s3://aws-codedeploy-ca-central-1/samples/latest/SampleApp_Linux.zip . --region ca-central-1`per la regione Canada (Centrale)
+ `aws s3 cp s3://aws-codedeploy-eu-west-1/samples/latest/SampleApp_Linux.zip . --region eu-west-1`per la regione Europa (Irlanda) 
+ `aws s3 cp s3://aws-codedeploy-eu-west-2/samples/latest/SampleApp_Linux.zip . --region eu-west-2`per la regione Europa (Londra) 
+ `aws s3 cp s3://aws-codedeploy-eu-west-3/samples/latest/SampleApp_Linux.zip . --region eu-west-3`per la regione Europa (Parigi) 
+ `aws s3 cp s3://aws-codedeploy-eu-central-1/samples/latest/SampleApp_Linux.zip . --region eu-central-1`per la regione Europa (Francoforte)
+ `aws s3 cp s3://aws-codedeploy-il-central-1/samples/latest/SampleApp_Linux.zip . --region il-central-1`per la regione di Israele (Tel Aviv)
+ `aws s3 cp s3://aws-codedeploy-ap-east-1/samples/latest/SampleApp_Linux.zip . --region ap-east-1`per la regione Asia Pacifico (Hong Kong)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-1/samples/latest/SampleApp_Linux.zip . --region ap-northeast-1`per la regione Asia Pacifico (Tokyo)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-2/samples/latest/SampleApp_Linux.zip . --region ap-northeast-2`per la regione Asia Pacifico (Seoul)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-1/samples/latest/SampleApp_Linux.zip . --region ap-southeast-1`per la regione Asia Pacifico (Singapore)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-2/samples/latest/SampleApp_Linux.zip . --region ap-southeast-2`per la regione Asia Pacifico (Sydney)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-4/samples/latest/SampleApp_Linux.zip . --region ap-southeast-4`per la regione Asia Pacifico (Melbourne)
+ `aws s3 cp s3://aws-codedeploy-ap-south-1/samples/latest/SampleApp_Linux.zip . --region ap-south-1`per la regione Asia Pacifico (Mumbai)
+ `aws s3 cp s3://aws-codedeploy-sa-east-1/samples/latest/SampleApp_Linux.zip . --region sa-east-1`per la regione Sud America (San Paolo)

## Eseguire il push di una revisione di esempio da un computer Windows locale
<a name="tutorials-github-upload-sample-revision-windows"></a>

 Con il prompt dei comandi ancora aperto su un percorso, ad esempio `c:\temp\CodeDeployGitHubDemo`, esegui i seguenti comandi uno alla volta:

**Nota**  
Se prevedi di eseguire la distribuzione su un'istanza Amazon Linux o RHEL, sostituiscila `SampleApp_Windows.zip` nei `SampleApp_Linux.zip` comandi.

```
(Amazon S3 copy command)
```

Decomprimi il contenuto del file ZIP `the` direttamente nella directory locale (ad esempio `c:\temp\CodeDeployGitHubDemo`) e non in una nuova sottodirectory.

```
git add .
```

```
git commit -m "Added sample app"
```

```
git push
```

*(Amazon S3 copy command)*Dov'è uno dei seguenti: 
+ `aws s3 cp s3://aws-codedeploy-us-east-2/samples/latest/SampleApp_Windows.zip . --region us-east-2`per la regione Stati Uniti orientali (Ohio)
+ `aws s3 cp s3://aws-codedeploy-us-east-1/samples/latest/SampleApp_Windows.zip . --region us-east-1`per la regione Stati Uniti orientali (Virginia settentrionale)
+ `aws s3 cp s3://aws-codedeploy-us-west-1/samples/latest/SampleApp_Windows.zip . --region us-west-1` per Regione Stati Uniti occidentali (California settentrionale)
+ `aws s3 cp s3://aws-codedeploy-us-west-2/samples/latest/SampleApp_Windows.zip . --region us-west-2`per la regione Stati Uniti occidentali (Oregon)
+ `aws s3 cp s3://aws-codedeploy-ca-central-1/samples/latest/SampleApp_Windows.zip . --region ca-central-1`per la regione Canada (Centrale)
+ `aws s3 cp s3://aws-codedeploy-eu-west-1/samples/latest/SampleApp_Windows.zip . --region eu-west-1`per la regione Europa (Irlanda)
+ `aws s3 cp s3://aws-codedeploy-eu-west-2/samples/latest/SampleApp_Windows.zip . --region eu-west-2`per la regione Europa (Londra)
+ `aws s3 cp s3://aws-codedeploy-eu-west-3/samples/latest/SampleApp_Windows.zip . --region eu-west-3`per la regione Europa (Parigi)
+ `aws s3 cp s3://aws-codedeploy-eu-central-1/samples/latest/SampleApp_Windows.zip . --region eu-central-1`per la regione Europa (Francoforte)
+ `aws s3 cp s3://aws-codedeploy-il-central-1/samples/latest/SampleApp_Windows.zip . --region il-central-1`per la regione di Israele (Tel Aviv)
+ `aws s3 cp s3://aws-codedeploy-ap-east-1/samples/latest/SampleApp_Windows.zip . --region ap-east-1`per la regione Asia Pacifico (Hong Kong)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-1/samples/latest/SampleApp_Windows.zip . --region ap-northeast-1`per la regione Asia Pacifico (Tokyo)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-2/samples/latest/SampleApp_Windows.zip . --region ap-northeast-2`per la regione Asia Pacifico (Seoul)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-1/samples/latest/SampleApp_Windows.zip . --region ap-southeast-1`per la regione Asia Pacifico (Singapore)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-2/samples/latest/SampleApp_Windows.zip . --region ap-southeast-2`per la regione Asia Pacifico (Sydney)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-4/samples/latest/SampleApp_Windows.zip . --region ap-southeast-4`per la regione Asia Pacifico (Melbourne)
+ `aws s3 cp s3://aws-codedeploy-ap-south-1/samples/latest/SampleApp_Windows.zip . --region ap-south-1`per la regione Asia Pacifico (Mumbai)
+ `aws s3 cp s3://aws-codedeploy-sa-east-1/samples/latest/SampleApp_Windows.zip . --region sa-east-1`per la regione Sud America (San Paolo)

Per inviare la tua revisione a un'istanza di Ubuntu Server, copia la revisione nel repository locale, quindi chiama quanto segue:

```
git add .
git commit -m "Added Ubuntu app"
git push
```

# Fase 4: Eseguire il provisioning di un'istanza
<a name="tutorials-github-provision-instance"></a>

In questa fase, verrà creata o configurata l'istanza in cui vuoi distribuire l'applicazione di esempio. Puoi eseguire la distribuzione su un'istanza Amazon EC2 o un'istanza locale che esegue uno dei sistemi operativi supportati da. CodeDeploy Per informazioni, consulta [Sistemi operativi supportati dall'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems). (Se hai già un'istanza configurata per l'uso nelle CodeDeploy distribuzioni, vai al passaggio successivo).

**Per effettuare il provisioning di un'istanza**

1. Segui le istruzioni per effettuare il provisioning [Avvia un'istanza Amazon EC2 (console)](instances-ec2-create.md#instances-ec2-create-console) di un'istanza.

1. Quando avvii l'istanza, ricordati di specificare un tag nella pagina **Aggiungi tag**. Per i dettagli su come specificare il tag, consulta[Avvia un'istanza Amazon EC2 (console)](instances-ec2-create.md#instances-ec2-create-console).

**Per verificare che l' CodeDeploy agente sia in esecuzione sull'istanza**
+ Segui le istruzioni riportate [Verifica che l' CodeDeploy agente sia in esecuzione](codedeploy-agent-operations-verify.md) per verificare che l'agente sia in esecuzione.

Dopo aver effettuato correttamente il provisioning dell'istanza e verificato che l' CodeDeploy agente sia in esecuzione, vai al passaggio successivo.

# Passaggio 5: creare un'applicazione e un gruppo di distribuzione
<a name="tutorials-github-create-application"></a>

In questo passaggio, utilizzerai la CodeDeploy console o creerai un'applicazione e un gruppo di distribuzione da utilizzare per distribuire la revisione di esempio dal tuo GitHub repository. AWS CLI 



## Creare un'applicazione e un gruppo di distribuzioni (console)
<a name="tutorials-github-create-application-console"></a>

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)

1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.

   

1. Scegliere **Create application (Crea applicazione)**, quindi selezionare **Custom application (Applicazione personalizzata)**.

1. In **Application name (Nome applicazione)**, immettere **CodeDeployGitHubDemo-App**.

1. In **Compute Platform (Piattaforma di calcolo)**, scegliere **EC2/On-premises (EC2/Locale)**.

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 **CodeDeployGitHubDemo-DepGrp**.

1. In **Ruolo di servizio**, scegli il nome del ruolo di CodeDeploy servizio che hai creato in [Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).

1. In **Deployment type (Tipo di distribuzione)**, scegliere **In-place (Locale)**.

1. **Nella **configurazione dell'ambiente**, a seconda del tipo di istanza che stai utilizzando, scegli istanze **Amazon EC2 o istanze locali**.** Per **Key (Chiave)** e **Value (Valore)**, digitare la chiave e il valore del tag dell'istanza applicati all'istanza nell'ambito della [Fase 4: Eseguire il provisioning di un'istanza](tutorials-github-provision-instance.md).

1. **In **Configurazione di distribuzione, scegli**. CodeDeployDefault AllatOnce**.

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

1. Espandere **Advanced (Avanzate)**.

1. In **Alarms (Allarmi)**, selezionare **Ignore alarm configuration (Ignora configurazione allarme)**.

1. Selezionare **Create deployment group (Crea gruppo di distribuzione)** e continuare con la fase successiva. 

## Creare un'applicazione e un gruppo di distribuzioni (CLI)
<a name="tutorials-github-create-application-cli"></a>

1. Chiamare il comando **create-application** per creare un'applicazione in CodeDeploy denominata `CodeDeployGitHubDemo-App`:

   ```
   aws deploy create-application --application-name CodeDeployGitHubDemo-App
   ```

1. Chiamare il comando **create-deployment-group** per creare un gruppo di distribuzioni denominato `CodeDeployGitHubDemo-DepGrp`:
   + Se esegui la distribuzione su un'istanza Amazon EC2*ec2-tag-key*, è la chiave del tag dell'istanza Amazon EC2 che è stata applicata alla tua istanza Amazon EC2 come parte di. [Fase 4: Eseguire il provisioning di un'istanza](tutorials-github-provision-instance.md)
   + Se esegui la distribuzione su un'istanza Amazon EC2*ec2-tag-value*, è il valore del tag dell'istanza Amazon EC2 che è stato applicato alla tua istanza Amazon EC2 come parte di. [Fase 4: Eseguire il provisioning di un'istanza](tutorials-github-provision-instance.md)
   + Se esegui la distribuzione su un'istanza locale, *on-premises-tag-key* è la chiave del tag dell'istanza locale che è stata applicata all'istanza locale come parte di. [Fase 4: Eseguire il provisioning di un'istanza](tutorials-github-provision-instance.md)
   + Se stai eseguendo la distribuzione su un'istanza locale, *on-premises-tag-value* è il valore del tag dell'istanza locale che è stato applicato all'istanza locale come parte di. [Fase 4: Eseguire il provisioning di un'istanza](tutorials-github-provision-instance.md)
   + *service-role-arn*è l'ARN del ruolo di servizio per il ruolo di servizio creato in [Creare un ruolo di servizio](getting-started-create-service-role.md) per. CodeDeploy Per trovare 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).

   ```
   aws deploy create-deployment-group --application-name CodeDeployGitHubDemo-App --ec2-tag-filters Key=ec2-tag-key,Type=KEY_AND_VALUE,Value=ec2-tag-value --on-premises-tag-filters Key=on-premises-tag-key,Type=KEY_AND_VALUE,Value=on-premises-tag-value --deployment-group-name CodeDeployGitHubDemo-DepGrp --service-role-arn service-role-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.

# Fase 6: Distribuire l'applicazione sull'istanza
<a name="tutorials-github-deploy-application"></a>

In questo passaggio, si utilizza la CodeDeploy console o si distribuisce AWS CLI la revisione di esempio dal GitHub repository all'istanza. 



## Per distribuire la revisione (console)
<a name="tutorials-github-deploy-application-console"></a>

1. Nella pagina **Deployment group details (Dettagli gruppo di distribuzione)**, scegliere **Create deployment (Crea distribuzione)**.

1. In **Deployment group (Gruppo di distribuzione)**, scegliere **`CodeDeployGitHubDemo-DepGrp`**.

1. In Tipo di **revisione, scegli**. **GitHub**

1. In **Connect to GitHub**, effettuate una delle seguenti operazioni:
   + Per creare una connessione per CodeDeploy le applicazioni a un GitHub account, esci da una scheda separata del browser Web. GitHub In **GitHub Account**, inserisci un nome per identificare questa connessione, quindi scegli **Connetti a GitHub**. La pagina Web richiede l'autorizzazione all'interazione con GitHub l' CodeDeploy applicazione denominata. `CodeDeployGitHubDemo-App` Continuare con la fase 5.
   + Per utilizzare una connessione già creata, in **GitHubAccount**, selezionane il nome, quindi scegli **Connetti a GitHub**. Continuare con la fase 7.
   + Per creare una connessione a un altro GitHub account, esci da una scheda separata del browser web. GitHub Scegli **Connetti a un altro GitHub account**, quindi scegli **Connetti a GitHub**. Continuare con la fase 5.

1. Segui le istruzioni **nella pagina di accesso** per accedere con il tuo GitHub account.

1. Nella pagina **Authorize application (Autorizza applicazione)**, scegli **Authorize application (Autorizza applicazione)**. 

1. Nella pagina CodeDeploy **Crea distribuzione**, in **Nome archivio, inserisci il nome** GitHub utente che hai usato per accedere, seguito da una barra (`/`), seguito dal nome del repository in cui hai inviato la revisione dell'applicazione (ad esempio,). ***my-github-user-name*/CodeDeployGitHubDemo**

   Se non si è sicuri del valore da inserire oppure si desidera specificare un repository diverso:

   1. [In una scheda separata del browser Web, accedi alla dashboard. GitHub ](https://github.com/dashboard)

   1. In **Your repositories (I tuoi repository)**, passa il puntatore del mouse sul nome del repository di destinazione. Viene visualizzato un tooltip che mostra il nome dell' GitHub utente o dell'organizzazione, seguito da una barra (`/`), seguita dal nome del repository. Inserire il valore in **Repository name (Nome repository)**.
**Nota**  
Se il nome del repository di destinazione non viene visualizzato in I **tuoi repository, utilizza la GitHub casella di **ricerca** per trovare il repository** di destinazione e il nome dell'utente o dell'organizzazione. GitHub 

1. Nella casella **Commit ID**, inserisci l'ID del commit associato al push della revisione dell'applicazione a. GitHub

   In caso di dubbi sul valore da inserire:

   1. In una scheda separata del browser Web, accedi alla [GitHub dashboard](https://github.com/dashboard).

   1. In **Your repositories (I tuoi repository)**, scegliere **CodeDeployGitHubDemo**.

   1. Nell'elenco dei commit, trova e copia l'ID di commit associato al push della revisione dell'applicazione su. GitHub Questo ID è in genere lungo 40 caratteri ed è composto da lettere e numeri. Non utilizzare la versione breve dell'ID commit che in genere è costituita dai primi 10 caratteri della versione più lunga.

   1. Incolla l'ID commit nella casella **Commit ID (ID commit)**.

1. Selezionare **Deploy (Distribuisci)** e continuare con la fase successiva. 

## Per distribuire la revisione (CLI)
<a name="tutorials-github-deploy-application-cli"></a>

Prima di poter richiamare qualsiasi AWS CLI comando con cui interagisci GitHub (ad esempio il **create-deployment** comando, che chiamerai in seguito), devi CodeDeploy autorizzare l'uso del tuo account GitHub utente con cui interagire GitHub per l'`CodeDeployGitHubDemo-App`applicazione. Al momento, è necessario utilizzare la console CodeDeploy per eseguire questa operazione.

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](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. Selezionare **CodeDeployGitHubDemo-App**.

1. Nella scheda **Deployments (Distribuzioni)**, scegli **Create deployment (Crea distribuzione)**.
**Nota**  
Non verrà creata una nuova distribuzione. Attualmente questo è l'unico modo per CodeDeploy autorizzare l'interazione per GitHub conto del tuo account GitHub utente.

1. Dal **gruppo Deployment**, scegli **CodeDeployGitHubDemo- DepGrp**.

1. In **Tipo di revisione**, scegliete **GitHub**.

1. In **Connect to GitHub**, effettuate una delle seguenti operazioni:
   + Per creare una connessione per CodeDeploy le applicazioni a un GitHub account, esci da una scheda separata del browser Web. GitHub In **GitHub Account**, digita un nome per identificare la connessione, quindi scegli **Connetti a GitHub**. La pagina Web richiede l'autorizzazione all'interazione con CodeDeploy l'applicazione GitHub denominata. `CodeDeployGitHubDemo-App` Continuare con la fase 8.
   + Per utilizzare una connessione già creata, in **GitHubAccount**, selezionane il nome, quindi scegli **Connetti a GitHub**. Continuare con la fase 10.
   + Per creare una connessione a un altro GitHub account, esci da una scheda separata del browser web. GitHub Scegli **Connetti a un altro GitHub account**, quindi scegli **Connetti a GitHub**. Continuare con la fase 8.

1. Segui le istruzioni **nella pagina di accesso** per accedere con il tuo nome GitHub utente o e-mail e password.

1. Nella pagina **Authorize application (Autorizza applicazione)**, scegli **Authorize application (Autorizza applicazione)**. 

1. Nella pagina CodeDeploy **Crea distribuzione**, scegli **Annulla**.

1. Chiama il **create-deployment** comando per distribuire la revisione dal tuo GitHub repository all'istanza, dove:
   + *repository*è il nome del tuo GitHub account, seguito da una barra forward-slash (`/`), seguito dal nome del tuo repository (), ad esempio. `CodeDeployGitHubDemo` `MyGitHubUserName/CodeDeployGitHubDemo`

     Se non si è sicuri del valore da usare oppure se si desidera specificare un repository diverso:

     1. [In una scheda separata del browser web, vai alla dashboard. GitHub ](https://github.com/dashboard)

     1. In **Your repositories (I tuoi repository)**, passa il puntatore del mouse sul nome del repository di destinazione. Viene visualizzato un tooltip che mostra il nome dell' GitHub utente o dell'organizzazione, seguito da una barra (`/`), seguita dal nome del repository. Si tratta del valore da usare.
**Nota**  
Se il nome del repository di destinazione non compare in I **tuoi repository, utilizza la GitHub casella di **ricerca** per trovare il repository** di destinazione e il nome dell'utente o dell'organizzazione corrispondente. GitHub 
   + *commit-id*è il commit associato alla versione della revisione dell'applicazione che hai inviato al tuo repository (ad esempio,). `f835159a...528eb76f` 

     In caso di dubbi sul valore da utilizzare:

     1. [In una scheda separata del browser Web, accedi alla dashboard. GitHub ](https://github.com/dashboard)

     1. In **Your repositories (I tuoi repository)**, scegliere **CodeDeployGitHubDemo**.

     1. Nell'elenco dei commit, trova l'ID di commit associato al push della revisione dell'applicazione a. GitHub Questo ID è in genere lungo 40 caratteri ed è composto da lettere e numeri. Non utilizzare la versione breve dell'ID commit che in genere è costituita dai primi 10 caratteri della versione più lunga. Usare questo valore.

   Se stai lavorando su una macchina Linux, macOS o Unix locale:

   ```
   aws deploy create-deployment \
     --application-name CodeDeployGitHubDemo-App \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --deployment-group-name CodeDeployGitHubDemo-DepGrp \
     --description "My GitHub deployment demo" \
     --github-location repository=repository,commitId=commit-id
   ```

   Se si sta utilizzando un computer Windows locale:

   ```
   aws deploy create-deployment --application-name CodeDeployGitHubDemo-App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name CodeDeployGitHubDemo-DepGrp --description "My GitHub deployment demo" --github-location repository=repository,commitId=commit-id
   ```

# Fase 7: Monitoraggio e verifica della distribuzione
<a name="tutorials-github-verify"></a>

In questa fase, utilizzerai la CodeDeploy console o il AWS CLI per verificare il successo della distribuzione. Puoi usare il tuo browser Web per visualizzare la pagina Web che è stata distribuita all'istanza creata o configurata.

**Nota**  
Se esegui la distribuzione su un'istanza di Ubuntu Server, utilizza la tua strategia di test per determinare se la revisione distribuita funziona come previsto sull'istanza, quindi vai al passaggio successivo.

**Per monitorare e verificare la distribuzione (console)**

1. **Nel riquadro di navigazione, espandi **Deploy, quindi scegli Deployments**.**

   

1. ****Nell'elenco delle distribuzioni, cerca la riga con un valore **Application** pari a **CodeDeployGitHubDemo-App** e un valore Deployment Group pari a -. CodeDeployGitHubDemo DepGrp**** Se **Succeeded (Riuscito)** o **Failed (Non riuscito)** non vengono visualizzati nella colonna **Status (Stato)**, premere ripetutamente il pulsante **Refresh (Aggiorna)**.

1. Se **Failed (Non riuscito)** viene visualizzato nella colonna **Status (Stato)**, seguire le istruzioni in [Visualizza i dettagli dell'istanza (console)](instances-view-details.md#instances-view-details-console) per risolvere i problemi della distribuzione.

1. Se **Succeeded (Riuscito)** viene visualizzato nella colonna **Status (Stato)**, è possibile verificare la distribuzione tramite il browser Web. La revisione di esempio distribuisce un'unica pagina Web all'istanza. Se esegui la distribuzione su un'istanza Amazon EC2, nel tuo browser Web, accedi `http://public-dns` all'istanza (ad esempio,). `http://ec2-01-234-567-890.compute-1.amazonaws.com`

1. Se è possibile visualizzare la pagina Web, la distribuzione è andata a buon fine. Ora che hai implementato AWS CodeDeploy con successo una revisione di GitHub, puoi passare a. [Fase 8: Pulizia](tutorials-github-clean-up.md)

**Per monitorare e verificare la distribuzione (CLI)**

1. Chiamare il comando **list-deployments** per ottenere l'ID distribuzione per l'applicazione denominata `CodeDeployGitHubDemo-App` e il gruppo di distribuzione con nome `CodeDeployGitHubDemo-DepGrp`:

   ```
   aws deploy list-deployments --application-name CodeDeployGitHubDemo-App --deployment-group-name CodeDeployGitHubDemo-DepGrp --query "deployments" --output text
   ```

1. Chiamare il comando **get-deployment** fornendo l'ID della distribuzione nell'output del comando **list-deployments**:

   ```
   aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.[status, creator]" --output text
   ```

1. Se viene restituito **Failed (Non riuscito)**, seguire le istruzioni in [Visualizza i dettagli dell'istanza (console)](instances-view-details.md#instances-view-details-console) per risolvere i problemi della distribuzione.

1. Se viene restituito **Succeeded (Riuscito)** è possibile verificare la distribuzione tramite il browser Web. La revisione di esempio è un'unica pagina Web distribuita all'istanza. Se esegui la distribuzione su un'istanza Amazon EC2, puoi visualizzare questa pagina nel tuo browser Web accedendo `http://public-dns` all'istanza Amazon EC2 (ad esempio,). `http://ec2-01-234-567-890.compute-1.amazonaws.com`

1. Se è possibile visualizzare la pagina Web, la distribuzione è andata a buon fine. La distribuzione dal tuo repository è stata AWS CodeDeploy eseguita con successo. GitHub 

# Fase 8: Pulizia
<a name="tutorials-github-clean-up"></a>

Per evitare ulteriori addebiti per le risorse utilizzate durante questo tutorial, devi terminare l'istanza Amazon EC2 e le risorse associate. Facoltativamente, puoi eliminare i record del componente di distribuzione CodeDeploy associati a questo tutorial. Se stavi usando un GitHub repository solo per questo tutorial, ora puoi anche eliminarlo.

## Per eliminare uno CloudFormation stack (se hai utilizzato il CloudFormation modello per creare un'istanza Amazon EC2)
<a name="tutorials-github-clean-up-cloudformation-template"></a>

1. [Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo https://console.aws.amazon.com /cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Nella colonna **Stacks (Stack)** scegliere lo stack che inizia con `CodeDeploySampleStack`.

1. Scegli **Elimina**.

1. Quando viene richiesto, scegliere nuovamente **Delete stack (Elimina stack)**. L'istanza Amazon EC2 e il profilo e il ruolo di servizio dell'istanza IAM associati vengono eliminati.

## Per annullare manualmente la registrazione e cancellare un'istanza locale (se è stato eseguito il provisioning di un'istanza locale)
<a name="tutorials-github-clean-up-on-premises-instance"></a>

1. Usa il AWS CLI per chiamare il comando [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) sull'istanza locale rappresentata qui da *your-instance-name* e sulla regione associata da: *your-region*

   ```
   aws deploy deregister --instance-name your-instance-name --no-delete-iam-user --region your-region
   ```

1. [Dall'istanza locale, chiama il comando uninstall:](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html)

   ```
   aws deploy uninstall
   ```

## Per terminare manualmente un'istanza Amazon EC2 (se hai avviato manualmente un'istanza Amazon EC2)
<a name="tutorials-github-clean-up-ec2-instance"></a>

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 riquadro di navigazione, in **Istanze** scegli **Istanze**.

1. Seleziona la casella accanto all'istanza Amazon EC2 che desideri terminare. Nel menu **Actions (Operazioni)**, passare a **Instance State (Stato istanza)**, quindi selezionare **Terminate (Termina)**.

1. Quando richiesto, scegliere **Yes, Terminate (Sì, termina)**. 

## Per eliminare i record dei componenti CodeDeploy di distribuzione
<a name="tutorials-github-clean-up-codedeploy-records"></a>

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](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. Selezionare **CodeDeployGitHubDemo-App**.

1. Scegli **Elimina applicazione**.

1. Quando richiesto, digitare **Delete**, quindi scegliere **Delete (Elimina)**. 

## Per eliminare il tuo repository GitHub
<a name="tutorials-github-clean-up-github-repository"></a>

[Vedi [Eliminazione di un repository](https://help.github.com/articles/deleting-a-repository/) nella guida. GitHub ](https://help.github.com)

# Tutorial: distribuire un'applicazione in Amazon ECS
<a name="tutorial-ecs-deployment"></a>

 In questo tutorial, imparerai come distribuire un'applicazione in Amazon ECS utilizzando. CodeDeploy Si inizia con un'applicazione già creata e distribuita in Amazon ECS. La prima fase consiste nell'aggiornare l'applicazione modificando il file di definizione dell'attività con un nuovo tag. Successivamente, si utilizza CodeDeploy per distribuire l'aggiornamento. Durante la distribuzione, CodeDeploy installa l'aggiornamento in un nuovo set di attività sostitutivo. Quindi, sposta il traffico di produzione dalla versione originale dell'applicazione Amazon ECS, che si trova nel set di attività originale, alla versione aggiornata nel set di attività sostitutivo.

 Durante una distribuzione di Amazon ECS, CodeDeploy utilizza un sistema di bilanciamento del carico configurato con due gruppi target e un listener di traffico di produzione. Il diagramma seguente mostra come il load balancer, il listener di produzione, i gruppi target e l'applicazione Amazon ECS sono correlati prima dell'inizio della distribuzione. In questa esercitazione viene utilizzato un Application Load Balancer. Puoi anche usare un Network Load Balancer. 

![\[Application Load Balancer o Network Load Balancer, un listener di produzione, due gruppi target, un set di attività e un servizio Amazon ECS.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-with-no-test-listener-step-1.png)


 Una volta completata la distribuzione, il listener del traffico di produzione serve il traffico verso il nuovo set di attività di sostituzione e il set di attività originale viene terminato. Il seguente diagramma mostra il modo in cui le risorse sono correlate dopo una distribuzione riuscita. Per ulteriori informazioni, consulta [Cosa succede durante una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-what-happens). 

![\[Application Load Balancer o Network Load Balancer, un listener di produzione, due gruppi target e un set di attività sostitutivo.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-with-no-test-listener-step-5.png)


Per informazioni su come utilizzare AWS CLI per distribuire un'applicazione in Amazon ECS, consulta [Tutorial: Creazione di un servizio utilizzando una blue/green ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html) distribuzione. Per informazioni su come rilevare e distribuire automaticamente le modifiche CodePipeline a un servizio Amazon ECS con CodeDeploy, consulta [Tutorial: Create a pipeline with an Amazon ECR](https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-ecs-ecr-codedeploy.html) source and deployment. ECS-to-CodeDeploy 

Dopo aver completato questo tutorial, puoi utilizzare l' CodeDeploy applicazione e il gruppo di distribuzione che hai creato per aggiungere un test di convalida della distribuzione. [Tutorial: distribuisci un servizio Amazon ECS con un test di convalida](tutorial-ecs-deployment-with-hooks.md) 

**Topics**
+ [Prerequisiti](tutorial-ecs-prereqs.md)
+ [Fase 1: aggiorna la tua applicazione Amazon ECS](tutorial-ecs-update-the-ecs-application.md)
+ [Fase 2: Creare il file AppSpec](tutorial-ecs-create-appspec-file.md)
+ [Passaggio 3: utilizza la CodeDeploy console per distribuire l'applicazione](tutorial-ecs-deployment-deploy.md)
+ [Fase 4: pulizia](tutorial-ecs-clean-up.md)

# Prerequisiti
<a name="tutorial-ecs-prereqs"></a>

Per completare questo tutorial, è necessario innanzitutto:
+  Completare le fasi 2 e 3 in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md). 
+  Crea un Application Load Balancer configurato con due gruppi target e un listener. Per informazioni sulla creazione di un sistema di bilanciamento del carico tramite la console, consulta [Configura un sistema di bilanciamento del carico, gruppi target e listener per le distribuzioni di CodeDeploy Amazon ECS](deployment-groups-create-load-balancer-for-ecs.md). Per informazioni sulla creazione di un load balancer utilizzando AWS CLI, consulta [Step 1: Create an Application Load Balancer](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html#create-blue-green-loadbalancer) nella *Amazon Elastic Container Service* User Guide. Quando si crea il sistema di bilanciamento del carico, annotare quanto segue per questo tutorial: 
  +  Il nome del sistema di bilanciamento del carico. 
  +  I nomi dei gruppi target. 
  +  La porta utilizzata dal listener del sistema di bilanciamento del carico. 
+  Crea un cluster e un servizio Amazon ECS. Per ulteriori informazioni, consulta i passaggi 2, 3 e 4 del [Tutorial: Creazione di un servizio utilizzando una blue/green distribuzione](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html) nella *Amazon Elastic Container Service User Guide*. Annota quanto segue per questo tutorial: 
  +  Il nome del tuo cluster Amazon ECS. 
  +  L'ARN della definizione dell'attività utilizzata dal tuo servizio Amazon ECS. 
  +  Il nome del contenitore utilizzato dal tuo servizio Amazon ECS. 
+  Crea un bucket Amazon S3 per il tuo file. AppSpec 

# Fase 1: aggiorna la tua applicazione Amazon ECS
<a name="tutorial-ecs-update-the-ecs-application"></a>

 In questa sezione, aggiorni la tua applicazione Amazon ECS con una nuova revisione della definizione del task. La revisione aggiornata aggiunge una nuova coppia di chiavi e tag. Nel[Passaggio 3: utilizza la CodeDeploy console per distribuire l'applicazione](tutorial-ecs-deployment-deploy.md), distribuisci la versione aggiornata della tua applicazione Amazon ECS. 

**Per aggiornare la definizione dell'attività**

1. [Apri la console nella versione 2. https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/v2)

1.  Nel riquadro di navigazione, scegli **Definizioni di attività**. 

1. Scegli la definizione di attività utilizzata dal tuo servizio Amazon ECS.

1. Seleziona la revisione della definizione di attività, quindi scegli **Crea nuova revisione**, **Crea nuova revisione**.

1.  Per questo tutorial, è necessario effettuare un piccolo aggiornamento alla definizione dell'attività aggiungendo un tag. Nella parte inferiore della pagina, sotto **Tag**, crea un nuovo tag inserendo una nuova coppia di chiavi e valori. 

1.  Scegli **Create** (Crea). 

   Il numero di revisione della definizione dell'attività viene incrementato di uno. 

1.  Scegli la scheda **JSON**. Prendere nota di quanto segue perché queste informazioni sono necessarie nella fase successiva. 
   +  Il valore per `taskDefinitionArn`. Il formato è: `arn:aws:ecs:aws-region:account-id:task-definition/task-definition-family:task-definition-revision`. Questo è l'ARN della definizione di attività aggiornata. 
   +  Nell'elemento `containerDefinitions`, il valore per `name`. Questo è il nome del container. 
   +  Nell'elemento `portMappings`, il valore per `containerPort`. Questa è la porta per il container. 

# Fase 2: Creare il file AppSpec
<a name="tutorial-ecs-create-appspec-file"></a>

 In questa sezione, crei il tuo AppSpec file e lo carichi nel bucket Amazon S3 che hai creato nella sezione. [Prerequisiti](tutorial-ecs-prereqs.md) Il AppSpec file per una distribuzione Amazon ECS specifica la definizione dell'attività, il nome del contenitore e la porta del contenitore. Per ulteriori informazioni, consultare [AppSpec Esempio di file per una distribuzione Amazon ECS](reference-appspec-file-example.md#appspec-file-example-ecs) e [AppSpec sezione «risorse» per le distribuzioni di Amazon ECS](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs). 

**Per creare il tuo file AppSpec**

1.  Se vuoi creare il tuo AppSpec file usando YAML, crea un file denominato. `appspec.yml` Se vuoi creare il tuo AppSpec file usando JSON, crea un file denominato. `appspec.json` 

1.  Scegli la scheda appropriata, a seconda che utilizzi YAML o JSON per il tuo AppSpec file, e copiane il contenuto nel AppSpec file appena creato. Per la proprietà `TaskDefinition`, utilizzare l'ARN della definizione dell'attività annotato nella sezione [Fase 1: aggiorna la tua applicazione Amazon ECS](tutorial-ecs-update-the-ecs-application.md). 

------
#### [ JSON AppSpec ]

   ```
   {
     "version": 0.0,
     "Resources": [
       {
         "TargetService": {
           "Type": "AWS::ECS::Service",
           "Properties": {
             "TaskDefinition": "arn:aws:ecs:aws-region-id:aws-account-id:task-definition/ecs-demo-task-definition:revision-number",
             "LoadBalancerInfo": {
               "ContainerName": "your-container-name",
               "ContainerPort": your-container-port
             }
           }
         }
       }
     ]
   }
   ```

------
#### [ YAML AppSpec ]

   ```
   version: 0.0
   Resources:
     - TargetService:
         Type: AWS::ECS::Service
         Properties:
           TaskDefinition: "arn:aws:ecs:aws-region-id:aws-account-id:task-definition/ecs-demo-task-definition:revision-number"
           LoadBalancerInfo:
             ContainerName: "your-container-name"
             ContainerPort: your-container-port
   ```

------
**Nota**  
 Il set di attività di sostituzione eredita la sottorete, il gruppo di sicurezza, la versione della piattaforma e i valori IP pubblici assegnati dal set di attività originale. È possibile sovrascrivere questi valori per il set di attività sostitutivo impostando le relative proprietà opzionali nel file. AppSpec Per ulteriori informazioni, consultare [AppSpec sezione «risorse» per le distribuzioni di Amazon ECS](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs) e [AppSpec Esempio di file per una distribuzione Amazon ECS](reference-appspec-file-example.md#appspec-file-example-ecs). 

1.  Carica il AppSpec file nel bucket S3 che hai creato come prerequisito per questo tutorial. 

# Passaggio 3: utilizza la CodeDeploy console per distribuire l'applicazione
<a name="tutorial-ecs-deployment-deploy"></a>

 In questa sezione, crei un' CodeDeploy applicazione e un gruppo di distribuzione per distribuire l'applicazione aggiornata in Amazon ECS. Durante la distribuzione, CodeDeploy sposta il traffico di produzione dell'applicazione alla nuova versione in un nuovo set di attività sostitutivo. Per completare questa fase, sono necessari i seguenti elementi: 
+  Il nome del tuo cluster Amazon ECS. 
+  Il nome del tuo servizio Amazon ECS. 
+  Il nome dell'Application Load Balancer. 
+  La porta del listener di produzione. 
+  I nomi dei gruppi target. 
+  Nome del bucket S3 creato. 

**Per creare un'applicazione CodeDeploy**

1. Accedi a Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1. Scegli **Crea applicazione**.

1. In **Application name (Nome applicazione)**, immettere **ecs-demo-codedeploy-app**.

1. In **Compute platform (Piattaforma di calcolo)**, scegli **Amazon ECS**.

1. Scegli **Crea applicazione**.

**Per creare un gruppo CodeDeploy di distribuzione**

1. Nella pagina delle applicazioni, 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 **ecs-demo-dg**.

1. In **Ruolo di servizio**, scegli un ruolo di servizio che garantisca CodeDeploy l'accesso ad Amazon ECS. Per ulteriori informazioni, consulta [Gestione delle identità e degli accessi per AWS CodeDeploy](security-iam.md).

1. In **Configurazione dell'ambiente**, scegli il nome del cluster Amazon ECS e il nome del servizio.

1. In **Load balancer**, scegli il nome del load balancer che serve il traffico verso il tuo servizio Amazon ECS.

1. **Da **Production listener port**, scegli la porta e il protocollo per il listener che fornisce il traffico di produzione al tuo servizio Amazon ECS (ad esempio, HTTP: 80).** Questo tutorial non include un listener di test opzionale, quindi non scegliere una porta da **Test listener port (Porta listener test)**. 

1. Da **Target group 1 name (Nome gruppo di destinazione 1)** e **Target group 2 name (Nome gruppo di destinazione 2)**, scegliere i due diversi gruppi di destinazione utilizzati per instradare il traffico durante la distribuzione. Assicurati che questi siano i gruppi di destinazione creati per il sistema di bilanciamento del carico. Non importa quale viene utilizzato per il gruppo target 1 e quale viene utilizzato per il gruppo target 2.

1. Scegliere **Reroute traffic immediately (Reinstrada immediatamente il traffico)**.

1. Per **Original revision termination (Terminazione revisione originale)**, scegliere 0 giorni, 0 ore e 5 minuti. In questo modo la distribuzione viene completata più rapidamente rispetto all'utilizzo dell'impostazione predefinita (1 ora).  
![\[La sezione di configurazione dell'ambiente della console. CodeDeploy\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-demo-create-acd-dg.png)

1. Scegliere **Create deployment group (Crea gruppo di distribuzione)**.

**Per distribuire la tua applicazione Amazon ECS**

1. Nella pagina della console del gruppo di distribuzione, scegliere **Create deployment (Crea distribuzione)**.

1.  Per il **gruppo Deployment**, scegli. **ecs-demo-dg** 

1.  Per **Revision type (Tipo di revisione)**, scegliere **My application is stored in Amazon S3 (La mia applicazione è archiviata in Amazon S3)**. In **Revision location (Posizione revisione)**, immettere il nome del bucket S3. 

1.  Per **Revision file type (Tipo di file revisione)**, scegliere **.json** o **.yaml**, a seconda dei casi. 

1.  (Facoltativo) In **Deployment description (Descrizione distribuzione)**, immetti una descrizione per questa distribuzione. 

1. Scegli **Create deployment (Crea distribuzione)**.

1.  In **Deployment status (Stato distribuzione)**, è possibile monitorare la distribuzione. Dopo che il 100% del traffico di produzione è stato indirizzato al set di attività sostitutivo e prima della scadenza del tempo di attesa di cinque minuti, puoi scegliere **Termina il set di attività originale per terminare immediatamente il set** di attività originale. Se non si sceglie **Terminate original task set (Termina set di attività originale)**, il set di attività originale termina dopo la scadenza del tempo di attesa di cinque minuti specificato.  
![\[La sezione sullo stato della distribuzione della console. CodeDeploy\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-without-test-listener.png)

# Fase 4: pulizia
<a name="tutorial-ecs-clean-up"></a>

 Il tutorial successivo, [Tutorial: distribuisci un servizio Amazon ECS con un test di convalida](tutorial-ecs-deployment-with-hooks.md), si basa su questo tutorial e utilizza il gruppo di distribuzione e l’applicazione CodeDeploy creati. Per seguire le fasi del tutorial, ignorare questa fase e non eliminare le risorse create. 

**Nota**  
 Sul tuo AWS account non sono previsti addebiti per le CodeDeploy risorse che hai creato. 

I nomi delle risorse in questi passaggi sono i nomi suggeriti in questo tutorial (ad esempio, **ecs-demo-codedeploy-app** per il nome dell' CodeDeploy applicazione). Se hai utilizzato nomi diversi, assicurati di utilizzarli durante la pulizia. 

1. Utilizzate il [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando per eliminare il gruppo CodeDeploy di distribuzione.

   ```
   aws deploy delete-deployment-group --application-name ecs-demo-codedeploy-app --deployment-group-name ecs-demo-dg --region aws-region-id
   ```

1. Utilizzate il comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) per eliminare l' CodeDeploy applicazione.

   ```
   aws deploy delete-application --application-name ecs-demo-codedeploy-app --region aws-region-id
   ```

# Tutorial: distribuisci un servizio Amazon ECS con un test di convalida
<a name="tutorial-ecs-deployment-with-hooks"></a>

 In questo tutorial, imparerai come usare una funzione Lambda per convalidare parte della distribuzione di un'applicazione Amazon ECS aggiornata. Questo tutorial utilizza l' CodeDeploy applicazione, il gruppo di CodeDeploy distribuzione e l'applicazione Amazon ECS in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md) cui hai utilizzato. Completare il tutorial prima di iniziare questo.

 Per aggiungere il test di convalida, devi prima implementare il test in una funzione Lambda. Successivamente, nel AppSpec file di distribuzione, specifichi la funzione Lambda per l'hook del ciclo di vita che desideri testare. Se un test di convalida ha esito negativo, la distribuzione viene interrotta, viene eseguito il rollback e contrassegnato come non riuscito. Se il test va a buon fine, la distribuzione continua con l'hook o l'evento del ciclo di vita della distribuzione successivo. 

 Durante una distribuzione Amazon ECS con test di convalida, CodeDeploy utilizza un sistema di bilanciamento del carico configurato con due gruppi target: un listener di traffico di produzione e un listener di traffico di test. Il diagramma seguente mostra come il load balancer, i listener di produzione e test, i gruppi target e l'applicazione Amazon ECS sono correlati prima dell'inizio della distribuzione. In questa esercitazione viene utilizzato un Application Load Balancer. Puoi anche usare un Network Load Balancer. 

![\[Le connessioni tra Application Load Balancer o Network Load Balancer, listener, gruppi target, set di attività e servizio Amazon ECS.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-1.png)


 Durante una distribuzione di Amazon ECS, sono disponibili cinque hook del ciclo di vita per i test. Questo tutorial implementa un test durante il terzo hook di distribuzione del ciclo di vita, `AfterAllowTestTraffic`. Per ulteriori informazioni, consulta [Elenco di eventi del ciclo di vita per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs). Una volta completata la distribuzione, il listener del traffico di produzione serve il traffico verso il nuovo set di attività di sostituzione e il set di attività originale viene terminato. Il seguente diagramma mostra il modo in cui le risorse sono correlate dopo una distribuzione riuscita. Per ulteriori informazioni, consulta [Cosa succede durante una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-what-happens). 

![\[Le connessioni tra Application Load Balancer o Network Load Balancer, listener, gruppi target e attività sostitutive impostate dopo una distribuzione.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-6.png)


**Nota**  
Il completamento di questo tutorial potrebbe comportare addebiti sul tuo account. AWS Questi includono possibili addebiti per CodeDeploy AWS Lambda, e CloudWatch. Per ulteriori informazioni, consulta [AWS CodeDeploy prezzi](https://aws.amazon.com/codedeploy/pricing/), [AWS Lambda prezzi](https://aws.amazon.com/lambda/pricing/) e [ CloudWatch prezzi Amazon](https://aws.amazon.com/cloudwatch/pricing/).

**Topics**
+ [Prerequisiti](tutorial-ecs-with-hooks-prereqs.md)
+ [Fase 1: Creare un listener di test](tutorial-ecs-with-hooks-create-second-listener.md)
+ [Fase 2: aggiorna la tua applicazione Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md)
+ [Fase 3: Creare una funzione Lambda dell'hook del ciclo di vita](tutorial-ecs-with-hooks-create-hooks.md)
+ [Passaggio 4: aggiorna il file AppSpec](tutorial-ecs-with-hooks-create-appspec-file.md)
+ [Fase 5: utilizza la CodeDeploy console per distribuire il servizio Amazon ECS](tutorial-ecs-with-hooks-deployment.md)
+ [Fase 6: Visualizza l'output della funzione Lambda hook in Logs CloudWatch](tutorial-ecs-with-hooks-view-cw-logs.md)
+ [Fase 7: pulire](tutoria-ecs-with-hooks-clean-up.md)

# Prerequisiti
<a name="tutorial-ecs-with-hooks-prereqs"></a>

Per completare questo tutorial, è necessario innanzitutto:
+  Completa i prerequisiti in [Prerequisiti](tutorial-ecs-prereqs.md) per [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). 
+  Completa le fasi descritte in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). Prendi nota di quanto segue: 
  +  Il nome del sistema di bilanciamento del carico. 
  +  I nomi dei gruppi target. 
  +  La porta utilizzata dal listener del sistema di bilanciamento del carico. 
  +  L'ARN del sistema di bilanciamento del carico. Per creare un nuovo listener si dovrà utilizzare questo. 
  +  L'ARN di uno dei gruppi target. Per creare un nuovo listener si dovrà utilizzare questo. 
  +  L' CodeDeploy applicazione e il gruppo di distribuzione che crei. 
  +  Il AppSpec file creato che viene utilizzato dalla CodeDeploy distribuzione. Questo file viene modificato in questo tutorial. 

# Fase 1: Creare un listener di test
<a name="tutorial-ecs-with-hooks-create-second-listener"></a>

 Una distribuzione Amazon ECS con test di convalida richiede un secondo listener. Questo listener viene utilizzato per fornire traffico di test all'applicazione Amazon ECS aggiornata in un set di attività sostitutivo. I test di convalida vengono eseguiti sul traffico di test. 

 Il listener per il traffico di test può utilizzare uno dei gruppi target. Usa il AWS CLI comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) per creare un secondo listener con una regola predefinita che inoltra il traffico di test alla porta 8080. Utilizzare l'ARN del sistema di bilanciamento del carico e l'ARN di uno dei gruppi target.

```
aws elbv2 create-listener --load-balancer-arn your-load-balancer-arn \
--protocol HTTP --port 8080 \
--default-actions Type=forward,TargetGroupArn=your-target-group-arn --region your-aws-region
```

# Fase 2: aggiorna la tua applicazione Amazon ECS
<a name="tutorial-ecs-with-hooks-update-the-ecs-application"></a>

 In questa sezione, aggiorni la tua applicazione Amazon ECS per utilizzare una nuova revisione della definizione del task. È possibile creare la nuova revisione e aggiungervi un aggiornamento secondario aggiungendo un tag. 

**Per aggiornare la definizione dell'attività**

1. Apri la console Amazon ECS classic all'indirizzo [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1.  Nel riquadro di navigazione, scegli **Definizioni di attività**. 

1.  Seleziona la casella di controllo per la definizione dell'attività utilizzata dal tuo servizio Amazon ECS.

1.  Scegliere **Create new revision (Crea nuova revisione)**. 

1.  Effettuare un piccolo aggiornamento alla definizione dell'attività aggiungendo un tag. Nella parte inferiore della pagina, in **Tags (Tag)**, creare un nuovo tag immettendo una nuova coppia chiave-valore. 

1.  Scegli **Create** (Crea). Il numero di revisione della definizione dell'attività è stato incrementato di uno. 

1.  Scegli la scheda **JSON**. Annotare il valore per `taskDefinitionArn`. Il formato è: `arn:aws:ecs:aws-region: account-id:task-definition/task-definition-family: task-definition-revision`. Questo è l'ARN della definizione di attività aggiornata. 

# Fase 3: Creare una funzione Lambda dell'hook del ciclo di vita
<a name="tutorial-ecs-with-hooks-create-hooks"></a>

In questa sezione, implementerai una funzione Lambda per l'hook della tua distribuzione Amazon ECS. `AfterAllowTestTraffic` La funzione Lambda esegue un test di convalida prima dell'installazione dell'applicazione Amazon ECS aggiornata. Per questo tutorial, viene restituita la funzione Lambda. `Succeeded` Durante una distribuzione reale, i test di convalida restituiscono `Succeeded` o `Failed`, a seconda del risultato del test di convalida. Inoltre, durante una distribuzione nel mondo reale, puoi implementare una funzione di test Lambda per uno o più degli altri eventi del ciclo di vita della distribuzione Amazon ECS (`BeforeInstall`,, e). `AfterInstall` `BeforeAllowTraffic` `AfterAllowTraffic` Per ulteriori informazioni, consulta [Elenco di eventi del ciclo di vita per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs).

 È necessario un ruolo IAM per creare la funzione Lambda. Il ruolo concede alla funzione Lambda il permesso di scrivere CloudWatch nei registri e impostare lo stato di un hook del ciclo di CodeDeploy vita. 

**Per creare un ruolo IAM**

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

1. Nel riquadro di navigazione selezionare **Roles (Ruoli)**, quindi **Create role (Crea ruolo)**.

1.  Creare un ruolo con le seguenti proprietà: 
   +  **Trusted entity (Entità attendibile)**: **AWS Lambda**. 
   +  **Autorizzazioni:. **AWSLambdaBasicExecutionRole**** Ciò concede alla funzione Lambda il permesso di scrivere CloudWatch nei registri. 
   +  **Nome ruolo**: **`lambda-cli-hook-role`**. 

   Per ulteriori informazioni, consulta [Creare un AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-userapp.html#with-userapp-walkthrough-custom-events-create-iam-role) ruolo di esecuzione. 

1.  Collega l'autorizzazione `codedeploy:PutLifecycleEventHookExecutionStatus` al ruolo creato. Ciò concede alle funzioni Lambda l'autorizzazione a impostare lo stato di CodeDeploy un hook del ciclo di vita durante una distribuzione. *Per ulteriori informazioni, consulta [Aggiungere i permessi di identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella *Guida per l'AWS Identity and Access Management utente* e [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)nel riferimento API. CodeDeploy * 

**Per creare una funzione Lambda a forma di `AfterAllowTestTraffic` hook**

1.  Crea un file denominato `AfterAllowTestTraffic.js` con i seguenti contenuti. 

   ```
   'use strict';
    
    const AWS = require('aws-sdk');
    const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
    
    exports.handler = (event, context, callback) => {
    
    	console.log("Entering AfterAllowTestTraffic hook.");
    	
    	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
     var deploymentId = event.DeploymentId;
    	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
    	var validationTestResult = "Failed";
    	
    	// Perform AfterAllowTestTraffic validation tests here. Set the test result 
    	// to "Succeeded" for this tutorial.
    	console.log("This is where AfterAllowTestTraffic validation tests happen.")
    	validationTestResult = "Succeeded";
    	
    	// Complete the AfterAllowTestTraffic hook by sending CodeDeploy the validation status
    	var params = {
    		deploymentId: deploymentId,
    		lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
    		status: validationTestResult // status can be 'Succeeded' or 'Failed'
    	};
    	
    	// Pass CodeDeploy the prepared validation test results.
    	codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
    		if (err) {
    			// Validation failed.
    			console.log('AfterAllowTestTraffic validation tests failed');
    			console.log(err, err.stack);
    			callback("CodeDeploy Status update failed");
    		} else {
    			// Validation succeeded.
    			console.log("AfterAllowTestTraffic validation tests succeeded");
    			callback(null, "AfterAllowTestTraffic validation tests succeeded");
    		}
    	});
    }
   ```

1.  Crea un pacchetto di distribuzione Lambda. 

   ```
   zip AfterAllowTestTraffic.zip AfterAllowTestTraffic.js 
   ```

1.  Usa il `create-function` comando per creare una funzione Lambda per il tuo `AfterAllowTestTraffic` hook. 

   ```
   aws lambda create-function --function-name AfterAllowTestTraffic \
          --zip-file fileb://AfterAllowTestTraffic.zip \
          --handler AfterAllowTestTraffic.handler \
          --runtime nodejs10.x \
          --role arn:aws:iam::aws-account-id:role/lambda-cli-hook-role
   ```

1.  Prendi nota dell'ARN della tua funzione Lambda nella risposta. `create-function` Questo ARN viene utilizzato quando si aggiorna il AppSpec file della CodeDeploy distribuzione nel passaggio successivo. 

# Passaggio 4: aggiorna il file AppSpec
<a name="tutorial-ecs-with-hooks-create-appspec-file"></a>

 In questa sezione, aggiorni il AppSpec file con una `Hooks` sezione. Nella `Hooks` sezione, si specifica una funzione Lambda per il `AfterAllowTestTraffic` lifecycle hook. 

**Per aggiornare il file AppSpec**

1.  Apri il AppSpec file che hai creato in [Fase 2: Creare il file AppSpec](tutorial-ecs-create-appspec-file.md)[Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). 

1.  Aggiornare la proprietà `TaskDefinition` con l'ARN della definizione dell'attività annotato in [Fase 2: aggiorna la tua applicazione Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md). 

1. Copia e incolla la `Hooks` sezione nel tuo AppSpec file di file. Aggiorna l'ARN dopo `AfterAllowTestTraffic` con l'ARN della funzione Lambda che hai annotato. [Fase 3: Creare una funzione Lambda dell'hook del ciclo di vita](tutorial-ecs-with-hooks-create-hooks.md) 

------
#### [ JSON AppSpec ]

   ```
   {
     "version": 0.0,
     "Resources": [
       {
         "TargetService": {
           "Type": "AWS::ECS::Service",
           "Properties": {
             "TaskDefinition": "arn:aws:ecs:aws-region-id:aws-account-id::task-definition/ecs-demo-task-definition:revision-number",
             "LoadBalancerInfo": {
               "ContainerName": "sample-website",
               "ContainerPort": 80
             }
           }
         }
       }
     ],
     "Hooks": [
       {
         "AfterAllowTestTraffic": "arn:aws:lambda:aws-region-id:aws-account-id:function:AfterAllowTestTraffic"
       }
     ]
   }
   ```

------
#### [ YAML AppSpec ]

   ```
   version: 0.0
   Resources:
     - TargetService:
         Type: AWS::ECS::Service
         Properties:
           TaskDefinition: "arn:aws:ecs:aws-region-id:aws-account-id::task-definition/ecs-demo-task-definition:revision-number"
           LoadBalancerInfo:
             ContainerName: "sample-website"
             ContainerPort: 80
   Hooks:
     - AfterAllowTestTraffic: "arn:aws:lambda:aws-region-id:aws-account-id:function:AfterAllowTestTraffic"
   ```

------

1.  Salva il AppSpec file e caricalo nel relativo bucket S3. 

# Fase 5: utilizza la CodeDeploy console per distribuire il servizio Amazon ECS
<a name="tutorial-ecs-with-hooks-deployment"></a>

 In questa sezione, aggiornerai il gruppo di distribuzione specificando la porta per il listener di test. Questo è il listener creato in [Fase 1: Creare un listener di test](tutorial-ecs-with-hooks-create-second-listener.md). Nel corso della distribuzione, CodeDeploy esegue il test di convalida durante l'hook del ciclo di vita della distribuzione `AfterAllowTestTraffic` utilizzando il traffico di test servito al set di attività di sostituzione mediante il listener di test. Il test di convalida restituisce il risultato `Succeeded`, quindi la distribuzione procede con il successivo evento del ciclo di vita della distribuzione. In uno scenario reale, la funzione di test restituisce `Succeeded` o `Failed`. 

**Per aggiungere un listener di test al gruppo di distribuzione**

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo. [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/)

1. Nel riquadro di navigazione , scegliere **Applications (Applicazioni)**. 

1. Scegliere l'applicazione creata in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). Se hai utilizzato il nome suggerito, è **ecs-demo-codedeploy-app**.

1. In **Deployment group (Gruppo di distribuzione)**, scegliere il gruppo di distribuzione appena creato in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). Se hai utilizzato il nome suggerito, è **ecs-demo-dg**.

1.  Scegli **Modifica**. 

1. Da **Test listener port (Porta listener di test)**, scegliere la porta e il protocollo per il listener di test creato in precedenza in questo tutorial. Deve essere **HTTP: 8080**. 

1.  Scegli **Save changes** (Salva modifiche). 

**Per distribuire la tua applicazione Amazon ECS**

1. Nella pagina della console del gruppo di distribuzione, scegliere **Create deployment (Crea distribuzione)**.

1.  Per il **gruppo Deployment**, scegli. **ecs-demo-dg** 

1.  Per **Revision type (Tipo di revisione)**, scegliere **My application is stored in Amazon S3 (La mia applicazione è archiviata in Amazon S3)**. In **Posizione di revisione**, inserisci il nome del bucket e del AppSpec file S3 (ad esempio,). **s3://my-s3-bucket/appspec.json** 

1.  Per **Revision file type (Tipo di file revisione)**, scegliere **.json** o **.yaml** a seconda dei casi. 

1.  (Facoltativo) In **Deployment description (Descrizione distribuzione)**, immetti una descrizione per questa distribuzione. 

1. Scegli **Create deployment (Crea distribuzione)**.

 Puoi monitorare la distribuzione in **Deployment status (Stato distribuzione)**. Dopo che il 100% del traffico di produzione è stato indirizzato al set di attività sostitutivo, puoi scegliere **Termina il set di attività originale per terminare immediatamente il set di attività originale**. Se non si sceglie **Terminate original task set (Termina set di attività originale)**, il set di attività originale termina dopo la durata specificata al momento della creazione del gruppo di distribuzione. 

![\[La sezione sullo stato della distribuzione della console. CodeDeploy\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-with-test-listener.png)


# Fase 6: Visualizza l'output della funzione Lambda hook in Logs CloudWatch
<a name="tutorial-ecs-with-hooks-view-cw-logs"></a>

 Se l' CodeDeploy implementazione ha esito positivo, anche i test di convalida delle funzioni hook Lambda hanno esito positivo. Puoi confermarlo esaminando il registro della funzione hook in Logs. CloudWatch 

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Nel riquadro di navigazione scegliere **Log**. Dovresti vedere un nuovo gruppo di log per la funzione hook Lambda che hai specificato nel tuo AppSpec file.   
![\[Il nuovo gruppo di log nella CloudWatch console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-demo-cw-logs.png)

1.  Scegliere il nuovo gruppo di log. Dovrebbe essere**/aws/lambda/AfterAllowTestTrafficHook**. 

1.  Scegli il flusso di log. Se si visualizza più di un flusso di log, scegliere quello con la data e l'ora più recenti in **Last Event Time (Ora ultimo evento)**. 

1.  Espandi gli eventi del flusso di registro per confermare che la funzione Lambda hook abbia scritto messaggi di successo nel registro. Quanto segue mostra che la funzione `AfterAllowTraffic` Lambda hook ha avuto successo.   
![\[Gli eventi del flusso di registro che mostrano l'AfterAllowTraffichook.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-demo-cw-log-events.png)

# Fase 7: pulire
<a name="tutoria-ecs-with-hooks-clean-up"></a>

 Una volta terminato questo tutorial, rimuovi le risorse associate per evitare costi aggiuntivi per risorse che non utilizzi. I nomi delle risorse in questo passaggio sono i nomi suggeriti in questo tutorial (ad esempio, **ecs-demo-codedeploy-app** per il nome dell' CodeDeploy applicazione). Se sono stati utilizzati nomi diversi, utilizzarli nella pulizia. 

**Per eliminare le risorse del tutorial**

1. Utilizzate il [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando per eliminare il gruppo CodeDeploy di distribuzione.

   ```
   aws deploy delete-deployment-group --application-name ecs-demo-deployment-group --deployment-group-name ecs-demo-dg --region aws-region-id
   ```

1. Utilizzate il comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) per eliminare l' CodeDeploy applicazione.

   ```
   aws deploy delete-application --application-name ecs-demo-deployment-group --region aws-region-id
   ```

1. Usa il comando [delete-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/delete-function.html) per eliminare la funzione hook Lambda.

   ```
   aws lambda delete-function --function-name AfterAllowTestTraffic
   ```

1. Usa il [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)comando per eliminare il tuo CloudWatch gruppo di log.

   ```
   aws logs delete-log-group --log-group-name /aws/lambda/AfterAllowTestTraffic
   ```

# Tutorial: implementa una funzione Lambda aggiornata CodeDeploy con e AWS il modello di applicazione Serverless
<a name="tutorial-lambda-sam"></a>

AWS SAM è un framework open source per la creazione di applicazioni serverless. Trasforma ed espande la sintassi YAML in un AWS SAM modello in CloudFormation sintassi per creare applicazioni serverless, come una funzione Lambda. [Per ulteriori informazioni, consulta What is the Serverless Application Model? AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) 

 In questo tutorial, utilizzi AWS SAM per creare una soluzione che esegua le seguenti operazioni: 
+  Crea la tua funzione Lambda. 
+  Crea CodeDeploy l'applicazione e il gruppo di distribuzione. 
+  Crea due funzioni Lambda che eseguono test di convalida della distribuzione durante CodeDeploy gli hook del ciclo di vita. 
+  Rileva quando la funzione Lambda viene aggiornata. L'aggiornamento della funzione Lambda attiva una distribuzione CodeDeploy che sposta in modo incrementale il traffico di produzione dalla versione originale della funzione Lambda alla versione aggiornata. 

**Nota**  
Questo tutorial richiede la creazione di risorse che potrebbero comportare addebiti sull’account AWS . Questi includono possibili addebiti per CodeDeploy CloudWatch, Amazon e AWS Lambda. Per ulteriori informazioni, consulta [CodeDeploy i prezzi](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch i prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/) e [AWS Lambda i prezzi](https://aws.amazon.com/lambda/pricing/).

**Topics**
+ [Prerequisiti](tutorial-lambda-sam-prereqs.md)
+ [Fase 1: Configura la tua infrastruttura](tutorial-lambda-sam-setup-infrastructure.md)
+ [Fase 2: Aggiornare la funzione Lambda](tutorial-lambda-sam-update-function.md)
+ [Fase 3: Implementazione della funzione Lambda aggiornata](tutorial-lambda-sam-deploy-update.md)
+ [Fase 4: Visualizza i risultati della distribuzione](tutorial-lambda-sam-deploy-view-results.md)
+ [Fase 5: rimozione](tutorial-lambda-clean-up.md)

# Prerequisiti
<a name="tutorial-lambda-sam-prereqs"></a>

Per completare questo tutorial, è necessario innanzitutto:
+  Completa le fasi descritte in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md). 
+  Installa la AWS Serverless Application Model CLI. Per informazioni, consulta [Installare la CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). 
+  Crea un bucket S3. AWS [SAM carica gli artefatti a cui si fa riferimento nel modello SAM in questo AWS bucket.](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) 

# Fase 1: Configura la tua infrastruttura
<a name="tutorial-lambda-sam-setup-infrastructure"></a>

 Questo argomento mostra come utilizzare AWS SAM per creare file per il AWS SAM modello e le funzioni Lambda. Quindi, usi i `deploy` comandi AWS SAM `package` and per generare i componenti della tua infrastruttura. Quando l'infrastruttura è pronta, si dispone di un gruppo di CodeDeploy applicazioni e di distribuzione, della funzione Lambda per l'aggiornamento e la distribuzione e di due funzioni Lambda che contengono test di convalida eseguiti quando si distribuisce la funzione Lambda. Al termine, puoi utilizzarli CloudFormation per visualizzare i componenti nella console Lambda o AWS CLI per testare la funzione Lambda. 

**Topics**
+ [Crea i tuoi file](tutorial-lambda-create-files.md)
+ [Package dell'applicazione AWS SAM](tutorial-lambda-sam-package.md)
+ [Distribuire l'applicazione AWS SAM](tutorial-lambda-sam-deploy.md)
+ [(Facoltativo) ispeziona e testa la tua infrastruttura](tutorial-lambda-sam-confirm-components.md)

# Crea i tuoi file
<a name="tutorial-lambda-create-files"></a>

 Per creare l'infrastruttura, è necessario creare i file seguenti: 
+ `template.yml`
+ `myDateTimeFunction.js`
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`

**Topics**
+ [Crea il tuo modello AWS SAM](tutorial-lambda-sam-template.md)
+ [Crea un file per la tua funzione Lambda](tutorial-lambda-sam-create-lambda-function.md)
+ [Crea un file per la tua funzione BeforeAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-before-traffic.md)
+ [Crea un file per la tua funzione AfterAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-after-traffic.md)

# Crea il tuo modello AWS SAM
<a name="tutorial-lambda-sam-template"></a>

Crea un file modello AWS SAM che specifichi i componenti della tua infrastruttura.

**Per creare il tuo modello AWS SAM**

1.  Crea una directory denominata `SAM-Tutorial`. 

1.  Nella directory `SAM-Tutorial`, creare un file denominato `template.yml`. 

1.  Copiare il seguente codice YAML in `template.yml`. Questo è il modello AWS SAM . 

   ```
   AWSTemplateFormatVersion : '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: A sample SAM template for deploying Lambda functions.
   
   Resources:
   # Details about the myDateTimeFunction Lambda function
     myDateTimeFunction:
       Type: AWS::Serverless::Function
       Properties:
         Handler: myDateTimeFunction.handler
         Runtime: nodejs18.x
   # Instructs your myDateTimeFunction is published to an alias named "live".      
         AutoPublishAlias: live
   # Grants this function permission to call lambda:InvokeFunction
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: '*'
         DeploymentPreference:
   # Specifies the deployment configuration      
             Type: Linear10PercentEvery1Minute
   # Specifies Lambda functions for deployment lifecycle hooks
             Hooks:
               PreTraffic: !Ref beforeAllowTraffic
               PostTraffic: !Ref afterAllowTraffic
               
   # Specifies the BeforeAllowTraffic lifecycle hook Lambda function
     beforeAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: beforeAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call lambda:InvokeFunction        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_beforeAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
             
   # Specifies the AfterAllowTraffic lifecycle hook Lambda function
     afterAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: afterAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus         
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call lambda:InvokeFunction          
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_afterAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
   ```

Questo modello specifica quanto segue. Per ulteriori informazioni, consulta i [concetti relativi ai AWS SAM modelli](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html).

**Una funzione Lambda chiamata `myDateTimeFunction`**  
 Quando questa funzione Lambda viene pubblicata, la `AutoPublishAlias` riga del modello la collega a un alias denominato. `live` Più avanti in questo tutorial, un aggiornamento di questa funzione attiva una distribuzione AWS CodeDeploy che sposta in modo incrementale il traffico di produzione dalla versione originale alla versione aggiornata. 

**Due funzioni di convalida dell'implementazione Lambda**  
 Le seguenti funzioni Lambda vengono eseguite durante gli hook del ciclo di CodeDeploy vita. Le funzioni contengono codice che convalida la distribuzione del codice `myDateTimeFunction` aggiornato. Il risultato dei test di convalida viene passato a CodeDeploy utilizzando il relativo metodo API `PutLifecycleEventHookExecutionStatus`. Se un test di convalida ha esito negativo, la distribuzione ha esito negativo e viene eseguito il rollback.   
+  `CodeDeployHook_beforeAllowTraffic` viene eseguito durante l'hook `BeforeAllowTraffic`. 
+  `CodeDeployHook_afterAllowTraffic` viene eseguito durante l'hook `AfterAllowTraffic`. 
Il nome di entrambe le funzioni inizia con `CodeDeployHook_`. Il `CodeDeployRoleForLambda` ruolo consente chiamate al `invoke` metodo Lambda solo nelle funzioni Lambda con nomi che iniziano con questo prefisso. Per ulteriori informazioni, consulta le pagine [AppSpec sezione 'hooks' per una distribuzione AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) e [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) nella *Documentazione di riferimento dell'API CodeDeploy *. 

**Rilevamento automatico di una funzione Lambda aggiornata**  
 Il termine `AutoPublishAlias` indica al framework di rilevare quando la funzione `myDateTimeFunction` cambia e quindi distribuirla utilizzando l'alias `live`. 

**Una configurazione della distribuzione**  
 La configurazione di distribuzione determina la velocità con cui l' CodeDeployapplicazione sposta il traffico dalla versione originale della funzione Lambda alla nuova versione. Questo modello specifica la configurazione della distribuzione predefinita `Linear10PercentEvery1Minute`.   
 Non è possibile specificare una configurazione di distribuzione personalizzata in un modello AWS SAM. Per ulteriori informazioni, consulta [Crea una configurazione di distribuzione con CodeDeploy](deployment-configurations-create.md).

**Funzioni hook del ciclo di vita della distribuzione**  
 La sezione `Hooks` specifica le funzioni da eseguire durante gli hook degli eventi del ciclo di vita. `PreTraffic` specifica la funzione che viene eseguita durante l'hook `BeforeAllowTraffic`. `PostTraffic` specifica la funzione che viene eseguita durante l'hook `AfterAllowTraffic`. 

**Autorizzazioni per Lambda per richiamare un'altra funzione Lambda**  
 L'`lambda:InvokeFunction`autorizzazione specificata concede al ruolo utilizzato dall'applicazione AWS SAM il permesso di richiamare una funzione Lambda. Ciò è necessario quando `CodeDeployHook_afterAllowTraffic` le funzioni `CodeDeployHook_beforeAllowTraffic` and richiamano la funzione Lambda distribuita durante i test di convalida. 

# Crea un file per la tua funzione Lambda
<a name="tutorial-lambda-sam-create-lambda-function"></a>

Creare il file per la funzione da aggiornare e distribuire più avanti in questo tutorial.

**Nota**  
 Una funzione Lambda può utilizzare qualsiasi runtime supportato da. AWS Lambda Per ulteriori informazioni, consulta [Tempi di esecuzione AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). 

**Per creare la tua funzione Lambda**

1.  Creare un file di testo e salvarlo come `myDateTimeFunction.js` nella directory `SAM-Tutorial`. 

1.  Copiare il seguente codice Node.js in `myDateTimeFunction.js`. 

   

   ```
   'use strict';
       
       exports.handler = function(event, context, callback) {
       
         if (event.body) {
           event = JSON.parse(event.body);
         }
       
         var sc; // Status code
         var result = ""; // Response payload
       
         switch(event.option) {
           case "date": 
             switch(event.period) {
               case "yesterday":
                 result = setDateResult("yesterday");
                 sc = 200;
                 break;
               case "today":
                 result = setDateResult();
                 sc = 200;
                 break;
               case "tomorrow":
                 result = setDateResult("tomorrow");
                 sc = 200;
                 break;
               default:
                 result = {
                   "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
                 };
                 sc = 400;
                 break;
             }
             break;
             
       /*      Later in this tutorial, you update this function by uncommenting 
               this section. The framework created by AWS SAM detects the update 
               and triggers a deployment by CodeDeploy. The deployment shifts 
               production traffic to the updated version of this function.
               
               case "time":
               var d = new Date();
               var h = d.getHours();
               var mi = d.getMinutes();
               var s = d.getSeconds();
       
               result = {
                 "hour": h,
                 "minute": mi,
                 "second": s
               };
               sc = 200;
               break;
       */
             default:
               result = {
                 "error": "Must specify 'date' or 'time'."
               };
               sc = 400;
             break;
         }
       
         const response = {
           statusCode: sc,
           headers: { "Content-type": "application/json" },
           body: JSON.stringify( result )
         };
       
         callback(null, response);
       
         function setDateResult(option) {
       
           var d = new Date(); // Today
           var mo; // Month
           var da; // Day
           var y; // Year
       
           switch(option) {
             case "yesterday":
               d.setDate(d.getDate() - 1);
               break;
             case "tomorrow":
               d.setDate(d.getDate() + 1);
             default:
              break;
           }
       
           mo = d.getMonth() + 1; // Months are zero offset (0-11)
           da = d.getDate();
           y = d.getFullYear();
       
           result = {
             "month": mo,
             "day": da,
             "year": y
           };
       
           return result;
         }
       };
   ```

La funzione Lambda restituisce il giorno, il mese e l'anno di ieri, oggi o domani. Più avanti in questo tutorial, si decomprimerà il codice che aggiorna la funzione per restituire informazioni sul giorno o sull'ora specificati (ad esempio, giorno, mese e anno o ora, minuto e secondo correnti). Il framework creato da AWS SAM rileva e distribuisce la versione aggiornata della funzione. 

**Nota**  
 Questa funzione Lambda viene utilizzata anche in un AWS Cloud9 tutorial. AWS Cloud9 è un ambiente di sviluppo integrato basato sul cloud. [Per informazioni su come creare, eseguire, aggiornare ed eseguire il debug di questa funzione in AWS Cloud9, consulta AWS Lambda il tutorial per. AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html) 

# Crea un file per la tua funzione BeforeAllowTraffic Lambda
<a name="tutorial-lambda-sam-create-lambda-before-traffic"></a>

Crea il file per la tua funzione Lambda dell'`beforeAllowTraffic`hook.

1.  Creare un file di testo e salvarlo come `beforeAllowTraffic.js` nella directory `SAM-Tutorial`. 

1.  Copiare il seguente codice Node.js in `beforeAllowTraffic.js`. Questa funzione viene eseguita durante l'hook `BeforeAllowTraffic` della distribuzione. 

   ```
   'use strict';
       
       const AWS = require('aws-sdk'); 
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PreTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("BeforeAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the newly added "time" option. If the function did not
       	// update, then the "time" option is invalid and function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"time\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PreTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Crea un file per la tua funzione AfterAllowTraffic Lambda
<a name="tutorial-lambda-sam-create-lambda-after-traffic"></a>

Crea il file per la tua funzione Lambda dell'`afterAllowTraffic`hook.

1.  Creare un file di testo e salvarlo come `afterAllowTraffic.js` nella directory `SAM-Tutorial`. 

1.  Copiare il seguente codice Node.js in `afterAllowTraffic.js`. Questa funzione viene eseguita durante l'hook `AfterAllowTraffic` della distribuzione. 

   ```
   'use strict';
       
       const AWS = require('aws-sdk');
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PostTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("AfterAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the original "date" parameter. If the function did not 
       	// update as expected, then the "date" option might be invalid. If 
       	// the parameter is invalid, the function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"date\", \"period\": \"today\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation of time parameter succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PostTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Package dell'applicazione AWS SAM
<a name="tutorial-lambda-sam-package"></a>

 Ora, la directory `SAM-Tutorial` dovrebbe contenere quattro file: 
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
+ `myDateTimeFunction.js`
+ `template.yml`

 Ora sei pronto per usare il **sam package** comando AWS SAM per creare e impacchettare artefatti per le tue funzioni e applicazioni Lambda. CodeDeploy Gli artefatti vengono caricati in un bucket S3. L'output del comando è un nuovo file denominato `package.yml`. Questo file viene utilizzato dal **sam deploy** comando AWS SAM nel passaggio successivo. 

**Nota**  
 Per ulteriori informazioni sul **sam package** comando, consulta il [riferimento ai comandi AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) nella *AWS Serverless Application Model Developer* Guide. 

 Nella directory `SAM-Tutorial`, eseguire il seguente comando. 

```
sam package \
  --template-file template.yml \
  --output-template-file package.yml \
  --s3-bucket amzn-s3-demo-bucket
```

Per il `s3-bucket` parametro, specifica il bucket Amazon S3 che hai creato come prerequisito per questo tutorial. `output-template-file`specifica il nome del nuovo file utilizzato dal comando SAM. AWS **sam deploy**

# Distribuire l'applicazione AWS SAM
<a name="tutorial-lambda-sam-deploy"></a>

 Usa il **sam deploy** comando AWS SAM con il `package.yml` file per creare le funzioni Lambda, CodeDeploy l'applicazione e il gruppo di distribuzione utilizzando. CloudFormation

**Nota**  
Per ulteriori informazioni sul **sam deploy** comando, consulta il [riferimento ai comandi AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) nella *AWS Serverless Application Model Developer* Guide. 

 Nella directory `SAM-Tutorial`, eseguire il seguente comando. 

```
sam deploy \
  --template-file package.yml \
  --stack-name my-date-time-app \
  --capabilities CAPABILITY_IAM
```

 Il `--capabilities CAPABILITY_IAM` parametro è necessario per autorizzare la creazione CloudFormation di ruoli IAM. 

# (Facoltativo) ispeziona e testa la tua infrastruttura
<a name="tutorial-lambda-sam-confirm-components"></a>

 Questo argomento mostra come visualizzare i componenti dell'infrastruttura e testare la funzione Lambda. 

**Per visualizzare il risultato dello stack dopo aver eseguito `sam deploy`**

1. Apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1.  Nel riquadro di navigazione selezionare **Stacks (Stack)**. Lo stack `my-date-time-app` viene visualizzato nella parte superiore. 

1.  Scegliere la scheda **Events (Eventi)** per visualizzare quali eventi sono completi. È possibile visualizzare gli eventi mentre è in corso la creazione dello stack. Al termine della creazione dello stack, è possibile visualizzare tutti gli eventi di creazione dello stack. 

1.  Con lo stack selezionato, scegliere **Resources (Risorse)**. Nella colonna **Tipo**, puoi vedere le tue funzioni Lambda, `myDateTimeFunction``CodeDeployHook_beforeAllowTraffic`, e. `CodeDeployHook_afterAllowTraffic` La colonna **Physical ID** di ciascuna delle tue funzioni Lambda contiene un link per visualizzare le funzioni nella console Lambda. 
**Nota**  
 Il nome della funzione `myDateTimeFunction` Lambda è preceduto dal nome dello CloudFormation stack e ha un identificatore aggiunto, quindi sembra. `my-date-time-app-myDateTimeFunction-123456ABCDEF` 

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

1.  Nel riquadro di navigazione espandere **Deploy (Distribuisci)** e scegliere **Applications (Applicazioni)**. 

1.  Dovresti vedere una nuova CodeDeploy applicazione creata da CloudFormation con un nome che inizia con`my-date-time-app-ServerlessDeploymentApplication`. Scegliere questa applicazione. 

1.  Viene visualizzato un gruppo di distribuzione con un nome che inizia con `my-date-time-app-myDateTimeFunctionDeploymentGroup`. Scegliere questo gruppo di distribuzione. 

    In **Configurazione di distribuzione**, dovresti vedere **CodeDeployDefault. LambdaLinear10 PercentEvery 1 minuto.** 

**(Facoltativo) per testare la funzionalità (console)**

1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Nel riquadro di navigazione, scegliere la funzione `my-date-time-app-myDateTimeFunction`. Nella console, il suo nome contiene un identificatore, quindi è simile a `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Scegli **Test (Esegui test)**. 

1.  In **Event name (Nome evento)**, immettere un nome per l'evento di test. 

1.  Immettere quanto segue per l'evento di test, quindi scegliere **Create (Crea)**. 

   ```
   {
     "option": "date",
     "period": "today"
   }
   ```

1.  Scegli **Test (Esegui test)**. Viene visualizzato solo l'evento di test nell'elenco degli eventi di test. 

    Per **Execution result (Risultato esecuzione)**, viene visualizzato **succeeded (riuscito)**. 

1.  In **Execution result (Risultato esecuzione)**, espandere **Details (Dettagli)** per visualizzare i risultati. Vengono visualizzati il mese, il giorno e l'anno corrente. 

**(Facoltativo) per testare la funzionalità (AWS CLI)**

1.  Individua l'ARN della tua funzione Lambda. Viene visualizzato nella parte superiore della console Lambda quando visualizzi la funzione. 

1.  Eseguire il seguente comando seguente. Sostituire *your-function-arn* con la funzione ARN. 

   ```
   aws lambda invoke \
   --function your-function-arn \
   --cli-binary-format raw-in-base64-out \
   --payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt
   ```

1.  Aprire `out.txt` per confermare che il risultato contenga il mese, il giorno e l'anno corrente. 

# Fase 2: Aggiornare la funzione Lambda
<a name="tutorial-lambda-sam-update-function"></a>

 Questo argomento illustra come aggiornare il file `myDateTimeFunction.js`. Nella fase successiva, si utilizzerà il file per distribuire la funzione aggiornata. Ciò avvia la distribuzione CodeDeploy spostando il traffico di produzione dalla versione corrente della funzione Lambda alla versione aggiornata. 

**Per aggiornare la funzione Lambda**

1.  Aprire `myDateTimeFunction.js`. 

1.  Rimuovere i due contrassegni di commento ("`/*`" e "`*/`") e il testo esplicativo all'inizio e alla fine del `case` denominato `time` nel blocco `switch`. 

    Il codice non commentato consente di passare un nuovo parametro `time` alla funzione. Se si passa `time` alla funzione aggiornata, restituisce i `hour`, `minute` e `second` correnti. 

1.  Salva `myDateTimeFunction.js`. Avrà un aspetto simile al seguente: 

   ```
   'use strict';
   
   exports.handler = function(event, context, callback) {
   
     if (event.body) {
       event = JSON.parse(event.body);
     }
   
     var sc; // Status code
     var result = ""; // Response payload
   
     switch(event.option) {
       case "date":
         switch(event.period) {
           case "yesterday":
             result = setDateResult("yesterday");
             sc = 200;
             break;
           case "today":
             result = setDateResult();
             sc = 200;
             break;
           case "tomorrow":
             result = setDateResult("tomorrow");
             sc = 200;
             break;
           default:
             result = {
               "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
             };
             sc = 400;
             break;
         }
         break;
         case "time":
           var d = new Date();
           var h = d.getHours();
           var mi = d.getMinutes();
           var s = d.getSeconds();
   
           result = {
             "hour": h,
             "minute": mi,
             "second": s
           };
           sc = 200;
           break;
   
         default:
           result = {
             "error": "Must specify 'date' or 'time'."
           };
           sc = 400;
         break;
     }
   
     const response = {
       statusCode: sc,
       headers: { "Content-type": "application/json" },
       body: JSON.stringify( result )
     };
   
     callback(null, response);
   
     function setDateResult(option) {
   
       var d = new Date(); // Today
       var mo; // Month
       var da; // Day
       var y; // Year
   
       switch(option) {
         case "yesterday":
           d.setDate(d.getDate() - 1);
           break;
         case "tomorrow":
           d.setDate(d.getDate() + 1);
         default:
          break;
       }
   
       mo = d.getMonth() + 1; // Months are zero offset (0-11)
       da = d.getDate();
       y = d.getFullYear();
   
       result = {
         "month": mo,
         "day": da,
         "year": y
       };
   
       return result;
     }
   };
   ```

# Fase 3: Implementazione della funzione Lambda aggiornata
<a name="tutorial-lambda-sam-deploy-update"></a>

 In questo passaggio, usi il tuo update `myDateTimeFunction.js` per aggiornare e avviare la distribuzione della tua funzione Lambda. Puoi monitorare l'avanzamento della distribuzione nella console CodeDeploy o AWS Lambda . 

 La `AutoPublishAlias: live` riga del AWS SAM modello fa sì che l'infrastruttura rilevi gli aggiornamenti delle funzioni che utilizzano l'`live`alias. Un aggiornamento della funzione attiva una distribuzione CodeDeploy che sposta il traffico di produzione dalla versione originale della funzione alla versione aggiornata. 

 I **sam deploy** comandi **sam package** and vengono utilizzati per aggiornare e attivare la distribuzione della funzione Lambda. Questi comandi sono stati eseguiti in [Package dell'applicazione AWS SAM](tutorial-lambda-sam-package.md) e [Distribuire l'applicazione AWS SAM](tutorial-lambda-sam-deploy.md). 

**Per distribuire la funzione Lambda aggiornata**

1.  Nella directory `SAM-Tutorial`, eseguire il seguente comando. 

   ```
   sam package \
     --template-file template.yml \
     --output-template-file package.yml  \
     --s3-bucket amzn-s3-demo-bucket
   ```

    Questo crea un nuovo set di artefatti che fanno riferimento alla funzione Lambda aggiornata nel bucket S3. 

1.  Nella directory `SAM-Tutorial`, eseguire il seguente comando. 

   ```
   sam deploy \
     --template-file package.yml \
     --stack-name my-date-time-app \
     --capabilities CAPABILITY_IAM
   ```

   Poiché il nome dello stack è fisso`my-date-time-app`, CloudFormation riconosce che si tratta di un aggiornamento dello stack. **Per visualizzare lo stack aggiornato, torna alla CloudFormation console e, dal pannello di navigazione, scegli Stacks.**

**(Facoltativo) per visualizzare il traffico durante una distribuzione (console) CodeDeploy**

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

1.  Nel riquadro di navigazione, espandi **Applicazioni**, quindi scegli la tua **my-date-time-app- ServerlessDeploymentApplication** applicazione. 

1.  In **Deployment groups (Gruppi di distribuzione)**, scegliere il gruppo di distribuzione dell'applicazione. Il suo stato deve essere **In progress (In corso)**. 

1.  In **Deployment group history (Cronologia gruppo di distribuzione)**, scegliere la distribuzione in corso. 

   La barra di avanzamento di **Traffic shifting (Trasferimento traffico)** e le percentuali nelle caselle **Original (Origine)** e **Replacement (Sostituzione)** di questa pagina visualizzano l'avanzamento.   
![\[La sezione relativa all'avanzamento dello spostamento del traffico della CodeDeploy console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png)

**(Facoltativo) per visualizzare il traffico durante una distribuzione (console Lambda)**

1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Nel riquadro di navigazione, scegliere la funzione `my-date-time-app-myDateTimeFunction`. Nella console, il suo nome contiene un identificatore, quindi è simile a `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Scegli **Alias**, quindi scegli **live**. 

I pesi accanto alla versione originale della funzione (versione 1) e alla versione della funzione aggiornata (versione 2) mostrano quanto traffico viene servito a ciascuna versione nel momento in cui questa pagina della AWS Lambda console è stata caricata. La pagina non aggiorna i pesi nel tempo. Se aggiorni la pagina una volta al minuto, il peso per la versione 1 diminuisce del 10% e il peso per la versione 2 aumenta del 10% fino a quando il peso per la versione 2 è 100. 

![\[La sezione alias della CodeDeploy console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png)


# Fase 4: Visualizza i risultati della distribuzione
<a name="tutorial-lambda-sam-deploy-view-results"></a>

In questa fase, vengono visualizzati i risultati della distribuzione. Se l'implementazione ha esito positivo, puoi confermare che la funzione Lambda aggiornata riceva traffico di produzione. Se la distribuzione fallisce, puoi utilizzare CloudWatch Logs per visualizzare l'output dei test di convalida nella funzione Lambda che viene eseguita durante gli hook del ciclo di vita della distribuzione. 

**Topics**
+ [Metti alla prova la funzione distribuita](#tutorial-lambda-sam-deploy-test-deployed-function)
+ [Visualizza gli eventi degli hook nei registri CloudWatch](#tutorial-lambda-view-hook-events)

## Metti alla prova la funzione distribuita
<a name="tutorial-lambda-sam-deploy-test-deployed-function"></a>

 Il **sam deploy** comando aggiorna la funzione `my-date-time-app-myDateTimeFunction` Lambda. La versione della funzione viene aggiornata a 2 e aggiunta all'alias `live`. 

**Per vedere l'aggiornamento nella console Lambda**

1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Nel riquadro di navigazione, scegliere la funzione `my-date-time-app-myDateTimeFunction`. Nella console, il suo nome contiene un identificatore, quindi è simile a `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Scegliere **Qualifiers (Qualificatori)**, quindi **Aliases (Alias)**. Una volta completata la distribuzione (circa 10 minuti), per l'alias `live`, viene visualizzato **Version: 2 (Versione: 2)**.  
![\[La sezione degli alias della CodeDeploy console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png)

1.  In **Function code (Codice funzione)**, visualizzare il codice sorgente per la funzione. Verrà visualizzata la modifica. 

1.  (Facoltativo) È possibile utilizzare le istruzioni di test in [Fase 2: Aggiornare la funzione Lambda](tutorial-lambda-sam-update-function.md) per testare la funzione aggiornata. Creare un nuovo evento di test con il payload seguente, quindi confermare che il risultato contenga l'ora, il minuto e il secondo correnti. 

   ```
   {
       "option": "time"
     }
   ```

    Per utilizzare la funzione AWS CLI per testare la funzione aggiornata, esegui il comando seguente, quindi apri `out.txt` per confermare che il risultato contenga l'ora, il minuto e il secondo correnti. 

   ```
   aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt 
   ```
**Nota**  
 Se utilizzi il AWS CLI per testare la tua funzione prima del completamento della distribuzione, potresti ricevere risultati imprevisti. Questo perché ogni minuto sposta CodeDeploy in modo incrementale il 10 percento del traffico verso la versione aggiornata. Durante la distribuzione, il traffico continua a puntare alla versione originale, quindi `aws lambda invoke` potrebbe utilizzare la versione originale. Dopo 10 minuti, la distribuzione è completa e tutto il traffico punta alla nuova versione della funzione. 

## Visualizza gli eventi degli hook nei registri CloudWatch
<a name="tutorial-lambda-view-hook-events"></a>

 Durante l'`BeforeAllowTraffic`hook, CodeDeploy esegue la funzione `CodeDeployHook_beforeAllowTraffic` Lambda. Durante l'`AfterAllowTraffic`hook, CodeDeploy esegue la funzione `CodeDeployHook_afterAllowTraffic` Lambda. Ogni funzione esegue un test di convalida che richiama la versione aggiornata della funzione utilizzando il nuovo parametro `time`. Se l'aggiornamento della funzione Lambda ha esito positivo, l'`time`opzione non causa errori e la convalida ha esito positivo. Se la funzione non è stata aggiornata, il parametro non riconosciuto genera un errore e la convalida ha esito negativo. Questi test di convalida sono solo a scopo dimostrativo. È possibile scrivere i test per convalidare la distribuzione. Puoi utilizzare la console CloudWatch Logs per visualizzare i test di convalida. 

**Per visualizzare i tuoi eventi hook CodeDeploy**

1. Apri la CloudWatch console su [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Nel riquadro di navigazione scegliere **Log**. 

1.  Dall'elenco dei gruppi di log, scegli**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** o**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 

1.  Scegli il flusso di log. Ne viene visualizzato solo uno. 

1.  Espandere gli eventi per visualizzarne i dettagli.   
![\[Il flusso di log di un gruppo di CodeDeployHook log.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png)

# Fase 5: rimozione
<a name="tutorial-lambda-clean-up"></a>

Per evitare ulteriori addebiti per le risorse utilizzate durante questo tutorial, elimina le risorse create dal AWS SAM modello e CloudWatch i log creati dalle funzioni di convalida Lambda.

**Per eliminare il tuo stack CloudFormation**

1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Nella colonna **Stacks (Stack)** scegliere lo stack `my-date-time-app`, quindi **Delete (Elimina)**.

1. Quando viene richiesto, scegliere nuovamente **Delete stack (Elimina stack)**. Le funzioni Lambda, il gruppo di CodeDeploy applicazioni e distribuzione e i ruoli IAM creati da AWS SAM vengono eliminati.

**Per eliminare i log in Logs CloudWatch**

1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1.  Nel riquadro di navigazione scegliere **Log**. 

1.  Dall'elenco dei gruppi di log, scegli il pulsante accanto a**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic**. 

1.  In **Actions (Operazioni)**, scegliere **Delete log group (Elimina gruppo di log)**, quindi **Yes, Delete (Sì, elimina)**. 

1.  Dall'elenco dei gruppi di log, scegli il pulsante accanto a**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 

1.  In **Actions (Operazioni)**, scegliere **Delete log group (Elimina gruppo di log)**, quindi **Yes, Delete (Sì, elimina)**.