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: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)
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
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
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
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
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
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.
```
Hello, World!
Hello, World!
You have successfully deployed an application using CodeDeploy
```
## Crea uno script per eseguire l'applicazione
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
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
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
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)
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)
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
È 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
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
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
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
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)
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)
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
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)
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)
**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
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
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
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:
```
Hello Again, World!
Hello Again, World!
You have successfully deployed a revision of an application using CodeDeploy
```
## Ridistribuire il sito
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)
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)
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
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)
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)
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
Se sei arrivato qui, hai completato con successo una distribuzione con. CodeDeploy Complimenti\$1