Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: utilizzare CodeDeploy per distribuire un'applicazione da GitHub
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
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
È 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
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
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
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
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
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
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)
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)
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
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)
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)
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
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
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)
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)
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)
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
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
[Vedi [Eliminazione di un repository](https://help.github.com/articles/deleting-a-repository/) nella guida. GitHub ](https://help.github.com)