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à.
# Utilizzo delle distribuzioni in CodeDeploy
In CodeDeploy, una distribuzione è il processo e i componenti coinvolti nel processo di installazione del contenuto su una o più istanze. Questo contenuto può essere costituito da codice, file Web e di configurazione, eseguibili, pacchetti, script e così via. CodeDeploy distribuisce il contenuto archiviato in un archivio di origine, in base alle regole di configurazione specificate.
Se si utilizza la piattaforma di calcolo EC2/on-premise, è possibile eseguire contemporaneamente due distribuzioni sullo stesso set di istanze.
CodeDeploy offre due opzioni di tipo di implementazione, implementazioni sul posto e implementazioni blu/verdi.
+ **Distribuzione sul posto**: l'applicazione su ogni istanza del gruppo di distribuzione viene interrotta, viene installata la revisione più recente dell'applicazione e la nuova versione dell'applicazione viene avviata e convalidata. È possibile utilizzare un sistema di bilanciamento del carico in modo che ogni istanza venga annullata durante la distribuzione e quindi ripristinata in servizio al termine della distribuzione. Solo le distribuzioni che utilizzano la piattaforma di elaborazione EC2/on-premise possono utilizzare le distribuzioni sul posto. Per ulteriori informazioni sulle implementazioni sul posto, consulta. [Panoramica di una distribuzione sul posto](welcome.md#welcome-deployment-overview-in-place)
+ **Implementazione blu/verde**: il comportamento della distribuzione dipende dalla piattaforma di elaborazione utilizzata:
+ **Blue/green on an EC2/On-Piattaforma di elaborazione locale**: le istanze in un gruppo di distribuzione (l'ambiente originale) vengono sostituite da un diverso set di istanze (l'ambiente sostitutivo) utilizzando questi passaggi:
+ Le istanze vengono fornite per l'ambiente sostitutivo.
+ La revisione più recente dell'applicazione viene installata sulle istanze sostitutive.
+ Si verifica un tempo di attesa opzionale per attività come il test delle applicazioni e la verifica del sistema.
+ Le istanze nell'ambiente sostitutivo vengono registrate con uno o più sistemi di bilanciamento del carico Elastic Load Balancing, causando il reindirizzamento del traffico verso di essi. Le istanze nell'ambiente originale vengono cancellate e possono essere terminate o mantenute in esecuzione per altri usi.
**Nota**
Se utilizzi una piattaforma di elaborazione EC2/on-premise, tieni presente che le blue/green distribuzioni funzionano solo con istanze Amazon EC2.
+ **Blu/verde su una piattaforma di calcolo AWS Lambda Amazon ECS** **o Amazon: il traffico viene spostato in incrementi in base a una configurazione **canaria**, lineare o di distribuzione. **all-at-once****
+ **Implementazioni blu/verdi tramite CloudFormation**: il traffico viene spostato dalle risorse attuali alle risorse aggiornate come parte di un aggiornamento dello stack. CloudFormation Attualmente sono supportate solo le implementazioni ECS. blue/green
Per ulteriori informazioni sulle blue/green distribuzioni, consulta. [Panoramica di una distribuzione blue/green](welcome.md#welcome-deployment-overview-blue-green)
Per informazioni sulla distribuzione automatica da Amazon S3, [consulta Distribuzione automatica da Amazon S3](https://aws.amazon.com/blogs/devops/automatically-deploy-from-amazon-s3-using-aws-codedeploy/) utilizzando. CodeDeploy
**Topics**
+ [Crea distribuzione](deployments-create.md)
+ [Visualizza i dettagli della distribuzione](deployments-view-details.md)
+ [Visualizza i dati dei log di distribuzione](deployments-view-logs.md)
+ [Interrompere una distribuzione](deployments-stop.md)
+ [Ridistribuisci e ripristina una distribuzione](deployments-rollback-and-redeploy.md)
+ [Distribuisci un'applicazione in un account diverso AWS](deployments-cross-account.md)
+ [Convalida un pacchetto di distribuzione su un computer locale](deployments-local.md)
# Crea una distribuzione con CodeDeploy
Puoi utilizzare la CodeDeploy console, le o le AWS CLI CodeDeploy API per creare una distribuzione che installi le revisioni delle applicazioni che hai già inviato ad Amazon S3 o, se la distribuzione è su una piattaforma di elaborazione EC2/on-premise, sulle istanze di un gruppo di distribuzione. GitHub
Il processo di creazione di una distribuzione dipende dalla piattaforma di elaborazione utilizzata dalla distribuzione.
**Topics**
+ [Prerequisiti di distribuzione](deployments-create-prerequisites.md)
+ [Crea un'implementazione di Amazon ECS Compute Platform (console)](deployments-create-console-ecs.md)
+ [Creare un'implementazione della AWS Lambda Compute Platform (console)](deployments-create-console-lambda.md)
+ [Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)](deployments-create-console.md)
+ [Crea un'implementazione di Amazon ECS Compute Platform (CLI)](deployments-create-ecs-cli.md)
+ [Crea un'implementazione della AWS Lambda Compute Platform (CLI)](deployments-create-lambda-cli.md)
+ [Crea un'implementazione della piattaforma di elaborazione (CLI) EC2/on-premise](deployments-create-cli.md)
+ [Crea una blue/green distribuzione Amazon ECS tramite CloudFormation](deployments-create-ecs-cfn.md)
# Prerequisiti di distribuzione
Assicurati di completare i seguenti passaggi prima di avviare una distribuzione.
## Prerequisiti di implementazione su una piattaforma di elaborazione AWS Lambda
+ Crea un'applicazione che include almeno un gruppo di distribuzione. Per informazioni, consulta [Crea un'applicazione con CodeDeploy](applications-create.md) e [Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md).
+ Prepara la revisione dell'applicazione, nota anche come AppSpec file, che specifica la versione della funzione Lambda che desideri distribuire. Il AppSpec file può anche specificare funzioni Lambda per convalidare la distribuzione. Per ulteriori informazioni, consulta [Utilizzo delle revisioni delle applicazioni per CodeDeploy](application-revisions.md).
+ Se desideri utilizzare la configurazione della distribuzione personalizzata per la distribuzione, creala prima di avviare il processo di distribuzione. Per informazioni, consulta [Crea una configurazione di distribuzione con CodeDeploy](deployment-configurations-create.md).
## Prerequisiti di implementazione su una piattaforma di elaborazione EC2/locale
+ Per una distribuzione in loco, crea o configura le istanze da distribuire. Per informazioni, consulta [Utilizzo delle istanze per CodeDeploy](instances.md). Per una blue/green distribuzione, disponi di un gruppo Amazon EC2 Auto Scaling esistente da utilizzare come modello per il tuo ambiente sostitutivo oppure hai una o più istanze o gruppi Amazon EC2 Auto Scaling specificati come ambiente originale. Per ulteriori informazioni, consultare [Tutorial: CodeDeploy Da utilizzare per distribuire un'applicazione in un gruppo di Auto Scaling](tutorials-auto-scaling-group.md) e [Integrazione CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
+ Crea un'applicazione che include almeno un gruppo di distribuzione. Per informazioni, consulta [Crea un'applicazione con CodeDeploy](applications-create.md) e [Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md).
+ Prepara la revisione dell'applicazione che desideri distribuire alle istanze nel gruppo di distribuzione. Per informazioni, consulta [Utilizzo delle revisioni delle applicazioni per CodeDeploy](application-revisions.md).
+ Se desideri utilizzare la configurazione della distribuzione personalizzata per la distribuzione, creala prima di avviare il processo di distribuzione. Per informazioni, consulta [Crea una configurazione di distribuzione con CodeDeploy](deployment-configurations-create.md).
+ Se stai distribuendo la revisione dell'applicazione da un bucket Amazon S3, il bucket si trova nella AWS stessa regione delle istanze del gruppo di distribuzione.
+ Se stai distribuendo la revisione dell'applicazione da un bucket Amazon S3, al bucket è stata applicata una policy del bucket Amazon S3. Questa policy concede alle istanze le autorizzazioni richieste per scaricare la revisione dell'applicazione.
Ad esempio, la seguente policy sui bucket di Amazon S3 consente a qualsiasi istanza Amazon EC2 con un profilo di istanza IAM collegato contenente l'ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` di essere scaricata da qualsiasi punto del bucket Amazon S3 denominato: `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"
]
}
}
]
}
```
La seguente policy sui bucket di Amazon S3 consente a qualsiasi istanza locale con un utente IAM associato contenente l'ARN di essere scaricata `arn:aws:iam::444455556666:user/CodeDeployUser` da qualsiasi punto del bucket Amazon S3 denominato: `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:user/CodeDeployUser"
]
}
}
]
}
```
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).
+ Se stai creando una blue/green distribuzione o hai specificato un Classic Load Balancer, Application Load Balancer o Network Load Balancer opzionale nel gruppo di distribuzione per una distribuzione locale, hai creato un VPC utilizzando Amazon VPC che contiene almeno due sottoreti. (CodeDeploy utilizza Elastic Load Balancing, che richiede che tutte le istanze di un gruppo di bilanciamento del carico si trovino in un singolo VPC.)
Se non hai ancora creato un VPC, consulta la Amazon [VPC](https://docs.aws.amazon.com/AmazonVPC/latest/GettingStartedGuide/ExerciseOverview.html) Getting Started Guide.
+ Se stai creando una blue/green distribuzione, hai configurato almeno un Classic Load Balancer, Application Load Balancer o Network Load Balancer in Elastic Load Balancing e l'hai usato per registrare le istanze che compongono l'ambiente originale.
**Nota**
Le istanze nell'ambiente di sostituzione verranno registrate con il sistema di bilanciamento del carico in seguito.
Per ulteriori informazioni sulla configurazione di un load balancer, consulta, e. [Configura un sistema di bilanciamento del carico nelle distribuzioni Elastic Load Balancing for Amazon CodeDeploy EC2](deployment-groups-create-load-balancer.md) [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)
## Prerequisiti di distribuzione per una distribuzione tramite blue/green CloudFormation
+ Il modello non deve necessariamente modellare le risorse per un' CodeDeploy applicazione o un gruppo di distribuzione.
+ Il modello deve includere risorse per un VPC che utilizza Amazon VPC che contiene almeno due sottoreti.
+ Il modello deve includere risorse per uno o più Classic Load Balancer, Application Load Balancer o Network Load Balancer in Elastic Load Balancing utilizzati per indirizzare il traffico verso i gruppi target.
# Crea un'implementazione di Amazon ECS Compute Platform (console)
Questo argomento mostra come distribuire un servizio Amazon ECS utilizzando la console. Per ulteriori informazioni, consultare [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md) e [Tutorial: distribuisci un servizio Amazon ECS con un test di convalida](tutorial-ecs-deployment-with-hooks.md).
1. [Accedi Console di gestione AWS e apri la CodeDeploy console su 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. Esegui una delle seguenti operazioni:
+ Se desideri distribuire un'applicazione, nel riquadro di navigazione espandi **Deploy (Distribuisci)** e scegli **Applications (Applicazioni)**. Seleziona il nome dell'applicazione da distribuire. Assicurati che la colonna della **piattaforma Compute** per la tua applicazione sia **Amazon ECS**.
+ Se desideri ridistribuire una distribuzione, nel riquadro di navigazione espandi **Deploy (Distribuisci)** e scegli **Deployments (Distribuzioni)**. Scegli la distribuzione che desideri ridistribuire e seleziona il nome della relativa applicazione nella colonna **Application (Applicazione)**. Assicurati che la colonna della **piattaforma Compute** per la tua distribuzione sia **Amazon ECS**.
1. Nella scheda **Deployments (Distribuzioni)**, scegli **Create deployment (Crea distribuzione)**.
**Nota**
L'applicazione deve disporre di un gruppo di distribuzione prima di poter essere distribuita. Se l'applicazione non dispone di un gruppo di distribuzione, nella scheda **Gruppi di distribuzione**, scegli **Crea gruppo di distribuzione**. Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md).
1. In **Deployment group (Gruppo di distribuzione)**, scegli un gruppo di distribuzione da utilizzare per questa distribuzione.
1. Accanto a **Revision location (Posizione revisione)** seleziona dove si trova la revisione:
+ **La mia applicazione è archiviata in Amazon S3**: per informazioni[Specificare le informazioni su una revisione archiviata in un bucket Amazon S3](deployments-create-console-s3.md), consulta e torna al passaggio 6.
+ **Usa l' AppSpec editor**: seleziona JSON o YAML, quindi inserisci il AppSpec file nell'editor. Puoi salvare il AppSpec file scegliendo **Salva come** file di testo. Quando fai clic su **Distribuisci** al termine di queste fasi ricevi un errore se JSON o YAML non è valido. Per ulteriori informazioni sulla creazione di un AppSpec file, consulta[Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md).
1. (Facoltativo) In **Deployment description (Descrizione distribuzione)**, immetti una descrizione per questa distribuzione.
1. (Facoltativo) In **Rollback configuration overrides (Rollback di sovrascritture della configurazione)**, puoi specificare opzioni di rollback automatiche diverse per questa distribuzione rispetto a quelle eventualmente specificate per il gruppo di distribuzione.
Per informazioni sui rollback in CodeDeploy, vedere [Ridistribuzioni e rollback della distribuzione](deployment-steps-lambda.md#deployment-rollback-lambda) e[Ridistribuisci e ripristina una distribuzione con CodeDeploy](deployments-rollback-and-redeploy.md).
Scegli tra le seguenti opzioni:
+ Effettua il **rollback quando una distribuzione fallisce**: CodeDeploy ridistribuisce l'ultima revisione valida conosciuta come nuova distribuzione.
+ **Ripristino quando vengono raggiunte le soglie di allarme: se sono** stati aggiunti degli allarmi al gruppo di distribuzione, CodeDeploy ridistribuisce l'ultima revisione valida conosciuta quando vengono attivati uno o più degli allarmi specificati.
+ **Disabilita i rollback: non eseguire i rollback** per questa distribuzione.
1. Scegli **Create deployment (Crea distribuzione)**.
Per monitorare lo stato della distribuzione, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
# Creare un'implementazione della AWS Lambda Compute Platform (console)
Questo argomento mostra come distribuire una funzione Lambda utilizzando la console.
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. Esegui una delle seguenti operazioni:
+ Se desideri distribuire un'applicazione, nel riquadro di navigazione espandi **Deploy (Distribuisci)** e scegli **Applications (Applicazioni)**. Seleziona il nome dell'applicazione da distribuire. Assicurati che la colonna della **piattaforma Compute** per la tua applicazione sia **AWS Lambda**.
+ Se desideri ridistribuire una distribuzione, nel riquadro di navigazione espandi **Deploy (Distribuisci)** e scegli **Deployments (Distribuzioni)**. Scegli la distribuzione che desideri ridistribuire e seleziona il nome della relativa applicazione nella colonna **Application (Applicazione)**. Assicurati che la colonna della **piattaforma Compute** per la tua implementazione sia **AWS Lambda**.
1. Nella scheda **Deployments (Distribuzioni)**, scegli **Create deployment (Crea distribuzione)**.
**Nota**
L'applicazione deve disporre di un gruppo di distribuzione prima di poter essere distribuita. Se l'applicazione non dispone di un gruppo di distribuzione, nella scheda **Gruppi di distribuzione**, scegli **Crea gruppo di distribuzione**. Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md).
1. In **Deployment group (Gruppo di distribuzione)**, scegli un gruppo di distribuzione da utilizzare per questa distribuzione.
1. Accanto a **Revision location (Posizione revisione)** seleziona dove si trova la revisione:
+ **La mia applicazione è archiviata in Amazon S3**: per informazioni[Specificare le informazioni su una revisione archiviata in un bucket Amazon S3](deployments-create-console-s3.md), consulta e torna al passaggio 6.
+ **Usa l' AppSpec editor**: seleziona JSON o YAML, quindi inserisci il AppSpec file nell'editor. Puoi salvare il AppSpec file scegliendo **Salva come** file di testo. Quando fai clic su **Distribuisci** al termine di queste fasi ricevi un errore se JSON o YAML non è valido. Per ulteriori informazioni sulla creazione di un AppSpec file, consulta[Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md).
1. (Facoltativo) In **Deployment description (Descrizione distribuzione)**, immetti una descrizione per questa distribuzione.
1. (Facoltativo) Espandi le **sostituzioni del gruppo** di distribuzione per scegliere una configurazione di distribuzione per controllare il modo in cui il traffico viene spostato alla versione della funzione Lambda diversa da quella specificata nel gruppo di distribuzione.
Per ulteriori informazioni, consulta [Configurazioni di distribuzione su una piattaforma di elaborazione AWS Lambda](deployment-configurations.md#deployment-configuration-lambda).
1. (Facoltativo) In **Rollback configuration overrides (Rollback di sovrascritture della configurazione)**, puoi specificare opzioni di rollback automatiche diverse per questa distribuzione rispetto a quelle eventualmente specificate per il gruppo di distribuzione.
Per informazioni sui rollback in, consulta e. CodeDeploy [Ridistribuzioni e rollback della distribuzione](deployment-steps-lambda.md#deployment-rollback-lambda) [Ridistribuisci e ripristina una distribuzione con CodeDeploy](deployments-rollback-and-redeploy.md)
Scegli tra le seguenti opzioni:
+ Effettua il **rollback quando una distribuzione fallisce**: CodeDeploy ridistribuisce l'ultima revisione valida conosciuta come nuova distribuzione.
+ **Ripristino quando vengono raggiunte le soglie di allarme: se sono** stati aggiunti degli allarmi al gruppo di distribuzione, CodeDeploy ridistribuisce l'ultima revisione valida conosciuta quando vengono attivati uno o più degli allarmi specificati.
+ **Disabilita i rollback: non eseguire i rollback** per questa distribuzione.
1. Scegli **Create deployment (Crea distribuzione)**.
Per monitorare lo stato della distribuzione, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
# Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)
Questo argomento mostra come distribuire un'applicazione su un server Amazon EC2 o locale utilizzando la console.
1. [Accedi Console di gestione AWS e apri la CodeDeploy console su /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. Esegui una delle seguenti operazioni:
+ Se desideri distribuire un'applicazione, nel riquadro di navigazione espandi **Deploy (Distribuisci)** e scegli **Applications (Applicazioni)**. Seleziona il nome dell'applicazione da distribuire. Assicurati che la colonna della **piattaforma Compute** per la tua applicazione sia **EC2/On-premise**.
+ Se desideri ridistribuire una distribuzione, nel riquadro di navigazione espandi **Deploy (Distribuisci)** e scegli **Deployments (Distribuzioni)**. Individua la distribuzione che desideri ridistribuire, quindi scegli il nome della relativa applicazione nella colonna **Application (Applicazione)**. **Assicurati che la colonna della **piattaforma Compute per la tua implementazione** sia EC2/On-premise.**
1. Nella scheda **Deployments (Distribuzioni)**, scegli **Create deployment (Crea distribuzione)**.
**Nota**
L'applicazione deve disporre di un gruppo di distribuzione prima di poter essere distribuita. Se l'applicazione non dispone di un gruppo di distribuzione, nella scheda **Gruppi di distribuzione**, scegli **Crea gruppo di distribuzione**. Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md).
1. In **Deployment group (Gruppo di distribuzione)**, scegli un gruppo di distribuzione da utilizzare per questa distribuzione.
1. Accanto a **Repository type (Tipo di repository)** scegliere il tipo di repository in cui è archiviata la revisione:
+ **La mia applicazione è archiviata in Amazon S3**: per informazioni[Specificare le informazioni su una revisione archiviata in un bucket Amazon S3](deployments-create-console-s3.md), consulta e torna al passaggio 6.
+ **La mia applicazione è archiviata in GitHub**: per informazioni, consulta[Specificare le informazioni su una revisione memorizzata in un repository GitHub](deployments-create-console-github.md), quindi torna al passaggio 6.
1. (Facoltativo) In **Deployment description (Descrizione distribuzione)**, immetti una descrizione per questa distribuzione.
1. (Facoltativo) Espandi la **configurazione di distribuzione Override** per scegliere una configurazione di distribuzione per controllare il modo in cui il traffico viene spostato su Amazon EC2 o sul server locale diversa da quella specificata nel gruppo di distribuzione.
Per ulteriori informazioni, consulta [Utilizzo delle configurazioni di distribuzione in CodeDeploy](deployment-configurations.md).
1.
1. Seleziona **Non interrompere la distribuzione se l'evento del ApplicationStop ciclo di vita fallisce se desideri che la distribuzione su un'istanza abbia esito positivo se l'evento** del ciclo di vita fallisce. `ApplicationStop`
1. Espandi **le impostazioni aggiuntive sul comportamento di distribuzione** per specificare in che modo CodeDeploy gestisce i file in una posizione di destinazione di distribuzione che non facevano parte della precedente distribuzione riuscita.
Scegli tra le seguenti opzioni:
+ **Implementazione non riuscita**: viene segnalato un errore e lo stato della distribuzione viene modificato in`Failed`.
+ **Sovrascrivi il contenuto**: se nella posizione di destinazione esiste un file con lo stesso nome, la versione della revisione dell'applicazione lo sostituisce.
+ **Conserva il contenuto**: se nella posizione di destinazione esiste un file con lo stesso nome, il file viene conservato e la versione nella revisione dell'applicazione non viene copiata nell'istanza.
Per ulteriori informazioni, consulta [Comportamento di rollback con il contenuto esistente](deployments-rollback-and-redeploy.md#deployments-rollback-and-redeploy-content-options).
1. (Facoltativo) In **Rollback configuration overrides (Rollback di sovrascritture della configurazione)**, puoi specificare opzioni di rollback automatiche diverse per questa distribuzione rispetto a quelle eventualmente specificate per il gruppo di distribuzione.
Per informazioni sui rollback in CodeDeploy, consulta e. [Ridistribuzioni e rollback di distribuzione](deployment-steps-server.md#deployment-rollback) [Ridistribuisci e ripristina una distribuzione con CodeDeploy](deployments-rollback-and-redeploy.md)
Scegli tra le seguenti opzioni:
+ Effettua il **rollback quando una distribuzione fallisce**: CodeDeploy ridistribuisce l'ultima revisione valida conosciuta come nuova distribuzione.
+ **Ripristino quando vengono raggiunte le soglie di allarme: se gli allarmi sono** stati aggiunti al gruppo di distribuzione, CodeDeploy implementa l'ultima revisione valida nota quando vengono attivati uno o più degli allarmi specificati.
+ **Disabilita i rollback: non eseguire i rollback** per questa distribuzione.
1. Selezionare **Start deployment (Avvia distribuzione)**.
Per monitorare lo stato della distribuzione, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
**Topics**
+ [Specificare le informazioni su una revisione archiviata in un bucket Amazon S3](deployments-create-console-s3.md)
+ [Specificare le informazioni su una revisione memorizzata in un repository GitHub](deployments-create-console-github.md)
# Specificare le informazioni su una revisione archiviata in un bucket Amazon S3
Se stai seguendo i passaggi indicati[Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)](deployments-create-console.md), segui questi passaggi per aggiungere dettagli sulla revisione di un'applicazione archiviata in un bucket Amazon S3.
1. Copia il link Amazon S3 della tua revisione **nella** 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/)
Individua e seleziona la revisione.
1. Se il riquadro **Properties (Proprietà)** non è visibile, scegli il pulsante **Properties (Proprietà)**.
1. Nel riquadro **Proprietà**, copia il valore del campo **Link** nella casella **Posizione di revisione** della CodeDeploy console.
Per specificare un ETag (un checksum del file) come parte della posizione di revisione:
+ Se il valore del campo **Link** termina con**?versionId=*versionId***, aggiungi **&etag=** e ETag alla fine del valore del campo **Link**.
+ Se il valore del campo **Link** non specifica un ID di versione, aggiungi **?etag=** e ETag alla fine del campo **Link**.
**Nota**
Sebbene non sia semplice come copiare il valore del campo **Link**, puoi anche digitare la posizione della revisione in uno dei seguenti formati:
**s3://*bucket-name*/*folders*/*objectName***
**s3://*bucket-name*/*folders*/*objectName*?versionId=*versionId***
**s3://*bucket-name*/*folders*/*objectName*?etag=*etag***
**s3://*bucket-name*/*folders*/*objectName*?versionId=*versionId*&etag=*etag***
***bucket-name*.s3.amazonaws.com/*folders*/*objectName***
1. Se nell'elenco **File type (Tipo di file)** viene visualizzato un messaggio che indica che non è possibile rilevare il tipo di file, scegli il tipo di file della revisione. In caso contrario, accetta il tipo di file rilevato.
# Specificare le informazioni su una revisione memorizzata in un repository GitHub
Se stai seguendo i passaggi indicati[Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)](deployments-create-console.md), segui questi passaggi per aggiungere dettagli sulla revisione di un'applicazione archiviata in un repository. GitHub
1. In **Connect to GitHub**, effettuate una delle seguenti operazioni:
+ Per creare una connessione per CodeDeploy le applicazioni a un GitHub account, in un'altra scheda del browser Web, disconnettiti da GitHub. In **GitHub Account**, inserisci un nome per identificare questa connessione, quindi scegli **Connetti a GitHub**. La pagina web ti chiede di autorizzare l'interazione con CodeDeploy GitHub la tua applicazione. Continua alla fase 2.
+ Per utilizzare una connessione già creata, in **GitHubAccount**, selezionane il nome, quindi scegli **Connetti a GitHub**. Continua alla fase 4.
+ Per creare una connessione a un altro GitHub account, in un'altra scheda del browser Web, esci da GitHub. Scegli **Connetti a un altro GitHub account**, quindi scegli **Connetti a GitHub**. Continua alla fase 2.
1. Se ti viene richiesto di accedere a GitHub, segui le istruzioni **nella pagina di accesso**. Accedi con il tuo nome GitHub utente o email e password.
1. Se viene visualizzata una pagina **Authorize application (Autorizza applicazione)**, scegli **Authorize application (Autorizza applicazione)**.
1. Nella pagina **Crea distribuzione**, nella casella **Nome archivio, inserisci il nome** GitHub dell'utente o dell'organizzazione che contiene la revisione, seguito da una barra (`/`), seguita dal nome del repository che contiene la revisione. In caso di dubbi sul valore da digitare:
1. [In un'altra scheda 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. Digita questo valore visualizzato nella casella **Repository name (Nome repository)**.
**Nota**
Se il nome del repository di destinazione non è visibile in I **tuoi repository**, utilizza la GitHub casella di **ricerca** per trovare il nome del repository di destinazione e il nome dell'utente o dell'organizzazione. GitHub
1. In **Commit ID (ID commit)**, digita l'ID commit che si riferisce alla revisione nel repository. In caso di dubbi sul valore da digitare:
1. [In un'altra scheda del browser web, vai alla dashboard. GitHub](https://github.com/dashboard)
1. In **Your repositories (I tuoi repository)**, sceglie il nome del repository contenente il commit di destinazione.
1. Nell'elenco di commit, trova e copia l'ID commit che si riferisce alla revisione nel repository. 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 dell'ID commit.
1. Incolla l'ID commit nella casella **Commit ID (ID commit)**.
# Crea un'implementazione di Amazon ECS Compute Platform (CLI)
Dopo aver creato l'applicazione e la revisione (nelle distribuzioni di Amazon ECS, questo è il file): AppSpec
Chiama il comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html), specificando:
+ Un nome dell'applicazione. [Per visualizzare un elenco di nomi di applicazioni, chiamate il comando list-applications.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html)
+ Un nome del gruppo di distribuzione. Per visualizzare un elenco di nomi dei gruppi di distribuzione, chiama il comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ Le informazioni relative alla revisione da distribuire:
Per le revisioni archiviate in Amazon S3:
+ Il nome del bucket Amazon S3 che contiene la revisione.
+ Il nome della revisione caricata.
+ (Facoltativo) L'identificatore della versione di Amazon S3 per la revisione. (Se l'identificatore di versione non è specificato, CodeDeploy utilizza la versione più recente.)
+ (Facoltativo) Il ETag per la revisione. (Se non ETag è specificato, CodeDeploy salta la convalida dell'oggetto).
Per le revisioni archiviate in un file che non si trova in Amazon S3, sono necessari il nome e il percorso del file. Il file di revisione è stato scritto utilizzando JSON o YAML, pertanto è probabile che abbia estensione .json o .yaml.
+ (Facoltativo) Una descrizione della distribuzione.
Il file di revisione può essere specificato come file caricato in un bucket Amazon S3 o come stringa. La sintassi per ciascuna quando utilizzata come parte del comando **create-deployment** è la seguente:
+ Bucket Amazon S3:
`version` e `eTag` sono facoltativi.
```
--s3-location bucket=string,key=string,bundleType=JSON|YAML,version=string,eTag=string
```
+ Stringa:
```
--revision '{"revisionType": "String", "string": {"content":"revision-as-string"}}'
```
**Nota**
Il comando **create-deployment** può caricare una revisione da un file. Per ulteriori informazioni, consultare la sezione relativa al [caricamento di parametri da un file](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file).
Per i modelli AWS Lambda di revisione della distribuzione, consulta. [Aggiungere un AppSpec file per una distribuzione AWS Lambda](application-revisions-appspec-file.md#add-appspec-file-lambda) Per una revisione di esempio, consulta [AppSpec Esempio di file per una distribuzione AWS Lambda](reference-appspec-file-example.md#appspec-file-example-lambda).
Per monitorare lo stato della distribuzione, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
# Crea un'implementazione della AWS Lambda Compute Platform (CLI)
Dopo aver creato l'applicazione e la revisione (nelle distribuzioni AWS Lambda, questo è il file): AppSpec
Chiama il comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html), specificando:
+ Un nome dell'applicazione. [Per visualizzare un elenco di nomi di applicazioni, chiamate il comando list-applications.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html)
+ Un nome del gruppo di distribuzione. Per visualizzare un elenco di nomi dei gruppi di distribuzione, chiama il comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ Le informazioni relative alla revisione da distribuire:
Per le revisioni archiviate in Amazon S3:
+ Il nome del bucket Amazon S3 che contiene la revisione.
+ Il nome della revisione caricata.
+ (Facoltativo) L'identificatore della versione di Amazon S3 per la revisione. (Se l'identificatore di versione non è specificato, CodeDeploy utilizza la versione più recente.)
+ (Facoltativo) Il ETag per la revisione. (Se non ETag è specificato, CodeDeploy salta la convalida dell'oggetto).
Per le revisioni archiviate in un file che non si trova in Amazon S3, sono necessari il nome e il percorso del file. Il file di revisione è stato scritto utilizzando JSON o YAML, pertanto è probabile che abbia estensione .json o .yaml.
+ (Facoltativo) Il nome di una configurazione della distribuzione da utilizzare. Per visualizzare un elenco di configurazioni della distribuzione, chiama il comando [list-deployment-configs](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-configs.html). (Se non specificato, CodeDeploy utilizza una configurazione di distribuzione predefinita specifica.)
+ (Facoltativo) Una descrizione della distribuzione.
Il file di revisione può essere specificato come file caricato in un bucket Amazon S3 o come stringa. La sintassi per ciascuna quando utilizzata come parte del comando **create-deployment** è la seguente:
+ Bucket Amazon S3:
`version` e `eTag` sono facoltativi.
```
--s3-location bucket=string,key=string,bundleType=JSON|YAML,version=string,eTag=string
```
+ Stringa:
```
--revision '{"revisionType": "String", "string": {"content":"revision-as-string"}}'
```
**Nota**
Il comando **create-deployment** può caricare una revisione da un file. Per ulteriori informazioni, consultare la sezione relativa al [caricamento di parametri da un file](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file).
Per i modelli AWS Lambda di revisione della distribuzione, consulta. [Aggiungere un AppSpec file per una distribuzione AWS Lambda](application-revisions-appspec-file.md#add-appspec-file-lambda) Per una revisione di esempio, consulta [AppSpec Esempio di file per una distribuzione AWS Lambda](reference-appspec-file-example.md#appspec-file-example-lambda).
Per monitorare lo stato della distribuzione, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
# Crea un'implementazione della piattaforma di elaborazione (CLI) EC2/on-premise
Per utilizzare il per distribuire una revisione AWS CLI alla piattaforma di calcolo EC2/on-premise:
1. Dopo aver preparato le istanze, creato l'applicazione ed eseguito il push della revisione, procedi in uno dei seguenti modi:
+ Se desideri distribuire una revisione da un bucket Amazon S3, continua subito con la fase 2.
+ Se desideri distribuire una revisione da un GitHub repository, completa prima i passaggi indicati e poi continua con il passaggio 2[Connect un' CodeDeploy applicazione a un GitHub repository](deployments-create-cli-github.md).
1. Chiamate il comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html), specificando:
+ `--application-name`: nome di un'applicazione. Per visualizzare un elenco di nomi di applicazioni, chiamate il comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ `--deployment-group-name`: nome di un gruppo di distribuzione Amazon EC2. Per visualizzare un elenco di nomi dei gruppi di distribuzione, chiama il comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ `--revision`: Informazioni sulla revisione da distribuire:
Per le revisioni archiviate in Amazon S3:
+ `s3Location`: il nome del bucket Amazon S3 che contiene la revisione.
+ `s3Location --> key`: il nome della revisione caricata.
+ `s3Location --> bundleType`: il tipo di file della revisione caricata.
**Nota**
I formati di file di archivio tar e tar compressi (.tar e .tar.gz) non sono supportati per le istanze di Windows Server.
+ `s3Location --> version`: (Facoltativo) L'identificatore della versione di Amazon S3 per la revisione. (Se l'identificatore di versione non è specificato, CodeDeploy utilizza la versione più recente.)
+ `s3Location --> eTag`: (Facoltativo) Il ETag per la revisione. (Se non ETag è specificato, CodeDeploy salta la convalida dell'oggetto).
Per le revisioni archiviate in: GitHub
+ `gitHubLocation --> repository`: il nome GitHub dell'utente o del gruppo assegnato al repository che contiene la revisione, seguito da una barra (`/`), seguita dal nome del repository.
+ `gitHubLocation --> commitId`: L'ID di commit per la revisione.
+ `--deployment-config-name`: (Facoltativo) Il nome di una configurazione di distribuzione da utilizzare. Per visualizzare un elenco di configurazioni della distribuzione, chiama il comando [list-deployment-configs](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-configs.html). (Se non specificato, CodeDeploy utilizza una configurazione di distribuzione predefinita specifica.)
+ `--ignore-application-stop-failures | --no-ignore-application-stop-failures`: (Facoltativo) Se si desidera che la distribuzione su un'istanza continui fino all'evento del ciclo di vita della `BeforeInstall` distribuzione se l'evento del ciclo di vita della `ApplicationStop` distribuzione fallisce.
+ `--description`: (Facoltativo) Una descrizione per la distribuzione.
+ `--file-exists-behavior`: (Facoltativo) Come parte del processo di distribuzione, l' CodeDeploy agente rimuove da ogni istanza tutti i file installati dalla distribuzione più recente. Scegli cosa succede quando i file che non facevano parte di una distribuzione precedente vengono visualizzati nelle posizioni di distribuzione di destinazione.
+ `--target-instances`: per le blue/green distribuzioni, informazioni sulle istanze che appartengono all'ambiente sostitutivo in una blue/green distribuzione, inclusi i nomi di uno o più gruppi Amazon EC2 Auto Scaling o la chiave di filtro dei tag, il tipo e il valore utilizzati per identificare le istanze Amazon EC2.
**Nota**
Usa questa sintassi come parte della **create-deployment** chiamata per specificare informazioni su una revisione in Amazon S3 direttamente sulla riga di comando. (`version` e `eTag` sono facoltativi.)
```
--s3-location bucket=string,key=string,bundleType=tar|tgz|zip,version=string,eTag=string
```
Usa questa sintassi come parte della **create-deployment** chiamata per specificare le informazioni su una revisione GitHub direttamente sulla riga di comando:
```
--github-location repository=string,commitId=string
```
Per ottenere informazioni sulle revisioni di cui è già stato eseguito il push, chiama il comando [list-application-revisions](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-application-revisions.html).
Per monitorare lo stato della distribuzione, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
## riferimento al comando create-deployment
Di seguito sono riportate la struttura e le opzioni del `create-deployment` comando. Per ulteriori informazioni, consulta il riferimento [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) nel *AWS CLI Command* Reference.
```
create-deployment
--application-name
[--deployment-group-name ]
[--revision ]
[--deployment-config-name ]
[--description ]
[--ignore-application-stop-failures | --no-ignore-application-stop-failures]
[--target-instances ]
[--auto-rollback-configuration ]
[--update-outdated-instances-only | --no-update-outdated-instances-only]
[--file-exists-behavior ]
[--s3-location ]
[--github-location ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
# Connect un' CodeDeploy applicazione a un GitHub repository
Prima di poter distribuire un'applicazione da un GitHub repository per la prima volta utilizzando il AWS CLI, devi prima CodeDeploy autorizzare l'interazione con per GitHub conto del tuo account. GitHub Questo passaggio deve essere completato una volta per ogni applicazione che utilizza la CodeDeploy console.
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. Selezionare **Applications (Applicazioni)**.
1. Da **Applicazioni**, scegli l'applicazione che desideri collegare al tuo account GitHub utente e scegli **Deploy application.**
**Nota**
Non si sta creando una distribuzione. Questo è attualmente l'unico modo per CodeDeploy autorizzare l'interazione per GitHub conto del tuo account GitHub utente.
1. Accanto a **Tipo di repository**, scegli **La revisione della mia applicazione è archiviata**. GitHub
1. Scegli **Connect a GitHub**.
**Nota**
Se vedi il link **Connetti a un altro GitHub account**:
Potresti aver già autorizzato CodeDeploy l'interazione per GitHub conto di un GitHub account diverso per l'applicazione.
Potresti aver revocato l'autorizzazione CodeDeploy all'interazione per GitHub conto dell'account connesso per tutte le applicazioni GitHub collegate all'account. CodeDeploy
Per ulteriori informazioni, consulta [GitHub autenticazione con applicazioni in CodeDeploy](integrations-partners-github.md#behaviors-authentication).
1. **Se non hai già effettuato l'accesso GitHub, segui le istruzioni nella pagina di accesso.**
1. Nella pagina **Authorize application (Autorizza applicazione)**, scegli **Authorize application (Autorizza applicazione)**.
1. Ora CodeDeploy che hai l'autorizzazione, scegli **Annulla** e continua con i passaggi indicati[Crea un'implementazione della piattaforma di elaborazione (CLI) EC2/on-premise](deployments-create-cli.md).
# Crea una blue/green distribuzione Amazon ECS tramite CloudFormation
Puoi utilizzarlo AWS CloudFormation per gestire le blue/green distribuzioni di Amazon ECS tramite. CodeDeploy La distribuzione viene generata definendo le risorse verdi e blu e specificando le impostazioni di routing e stabilizzazione del traffico da utilizzare in CloudFormation. Questo argomento tratta le differenze tra le blue/green distribuzioni di Amazon ECS gestite da CodeDeploy e le distribuzioni gestite da. CloudFormation
*Per step-by-step istruzioni sull'uso CloudFormation per gestire le distribuzioni blu/verde di Amazon ECS, consulta [Automatizza le distribuzioni blu/verde di Amazon ECS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) tramite l'uso nella Guida per l'utente. CodeDeploy AWS CloudFormationAWS CloudFormation *
**Nota**
La gestione delle blue/green distribuzioni Amazon ECS con non CloudFormation è disponibile nella regione Asia Pacifico (Osaka).
## Differenze tra le blue/green implementazioni di Amazon ECS tramite e CodeDeploy CloudFormation
Il modello di CloudFormation stack modella le risorse e l'infrastruttura relative alle attività di Amazon ECS e anche le opzioni di configurazione per le distribuzioni. Esistono quindi differenze tra le distribuzioni standard di Amazon ECS e blue/green le distribuzioni tramite cui blue/green vengono create. CloudFormation
A differenza delle blue/green distribuzioni standard di Amazon ECS, non modelli né crei manualmente quanto segue:
+ Non si crea un' AWS CodeDeploy applicazione specificando un nome che rappresenti in modo univoco ciò che si desidera distribuire.
+ Non si crea un AWS CodeDeploy gruppo di distribuzione.
+ Non si specifica un file di *specifiche dell'applicazione (AppSpec file*). Le informazioni normalmente gestite con il AppSpec file, come le opzioni di configurazione ponderate o gli eventi del ciclo di vita, vengono gestite dall'hook. `AWS::CodeDeploy::BlueGreen`
In questa tabella vengono riepilogate le differenze nel flusso di lavoro di alto livello tra i tipi di distribuzione.
****
| Funzione | Implementazioni standard blue/green | Implementazioni blu/verdi tramite CloudFormation |
| --- | --- | --- |
| Specificare il cluster Amazon ECS, il servizio Amazon ECS, Application Load Balancer o Network Load Balancer, il listener di produzione, il listener di test e due gruppi target. | Crea un gruppo di CodeDeploy distribuzione che specifichi queste risorse. | Crea un CloudFormation modello per modellare queste risorse. |
| Specificare la modifica da distribuire. | Crea un' CodeDeploy applicazione. | Crea un CloudFormation modello che specifichi l'immagine del contenitore. |
| Specificare la definizione dell'attività di Amazon ECS, il nome del contenitore e la porta del contenitore. | Crea un AppSpec file che specifichi queste risorse. | Crea un CloudFormation modello per modellare queste risorse. |
| Specificare le opzioni di spostamento del traffico di distribuzione e gli hook degli eventi del ciclo di vita. | Crea un AppSpec file che specifichi queste opzioni. | Create un CloudFormation modello che utilizzi i parametri AWS::CodeDeploy::BlueGreen hook per specificare queste opzioni. |
| CloudWatch allarmi. | Crea un CloudWatch allarme che attiva un rollback. | Configura un CloudWatch allarme a livello di CloudFormation stack che attiva un rollback. |
| Rollback/ridistribuzione. | Specificare le opzioni di rollback e ridistribuzione. | Annulla l'aggiornamento dello stack in. CloudFormation |
## Monitoraggio delle blue/green distribuzioni di Amazon ECS tramite CloudFormation
Puoi monitorare le blue/green distribuzioni tramite e. CloudFormation CodeDeploy Per informazioni sul monitoraggio tramite CloudFormation, consulta [Monitoraggio blue/green degli eventi CloudFormation nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html#blue-green-events) per l'*AWS CloudFormation utente*.
**Per visualizzare lo stato di implementazione delle blue/green distribuzioni 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 che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. In **Deployments**, viene visualizzata la distribuzione attivata dall'aggiornamento dello CloudFormation stack. Scegliere la distribuzione per visualizzare **Cronologia delle distribuzioni**.
![\[Screenshot della console che mostra la sezione Distribuzioni e la cronologia della distribuzione.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/cfn-cd-bg-deplhist.png)
1. Scegliere la distribuzione per visualizzare lo stato dello spostamento del traffico. Si noti che l'applicazione e il gruppo di distribuzione non vengono creati.
![\[Screenshot della console che mostra i dettagli della distribuzione con stato di distribuzione completato.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/cfn-cd-bg-deplstatus.png)
1. Quanto segue si applica per il rollback o l'arresto della distribuzione:
+ La distribuzione riuscita viene visualizzata in CodeDeploy e mostra che la distribuzione è stata avviata da. CloudFormation
+ Se si desidera interrompere e ripristinare la distribuzione, è necessario annullare l'aggiornamento dello stack in. CloudFormation
# Visualizza i dettagli CodeDeploy della distribuzione
Puoi utilizzare la CodeDeploy console, il o il AWS CLI CodeDeploy APIs per visualizzare i dettagli sulle distribuzioni associate al tuo account. AWS
**Nota**
Puoi visualizzare i log di distribuzione EC2/on-premise sulle tue istanze nelle seguenti posizioni:
Amazon Linux, RHEL e Ubuntu Server: `/opt/codedeploy-agent/deployment-root/deployment-logs/codedeploy-agent-deployments.log`
Windows Server: C:\$1ProgramData\$1 Amazon\$1 CodeDeploy \$1 logs\$1 scripts.log
Per ulteriori informazioni, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
**Topics**
+ [Visualizza i dettagli di distribuzione (console)](#deployments-view-details-console)
+ [Visualizza i dettagli della distribuzione (CLI)](#deployments-view-details-cli)
## Visualizza i dettagli di distribuzione (console)
Per utilizzare la CodeDeploy console per visualizzare i dettagli della 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 con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy**, quindi scegli **Deployments**.
**Nota**
Se non viene visualizzata alcuna voce, assicurati che sia selezionata la regione corretta. Nella barra di navigazione, nel selettore di regione, scegli 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* CodeDeploy è supportato solo in queste regioni.
1. Per visualizzare ulteriori dettagli per una singola distribuzione, in **Deployment history (Cronologia distribuzione)**, scegli l'ID della distribuzione o seleziona il pulsante accanto all'ID della distribuzione, quindi scegli **View (Visualizza)**.
## Visualizza i dettagli della distribuzione (CLI)
Per utilizzare il AWS CLI per visualizzare i dettagli della distribuzione, chiama il `get-deployment` comando o il `batch-get-deployments` comando. È possibile chiamare il `list-deployments` comando per ottenere un elenco di distribuzioni IDs univoche da utilizzare come input per il `get-deployment` comando e il `batch-get-deployments` comando.
Per visualizzare i dettagli su una singola distribuzione, chiama il comando [get-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment.html), specificando l'identificatore di distribuzione univoco. [Per ottenere l'ID di distribuzione, chiama il comando list-deployments.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html)
Per visualizzare i dettagli relativi a più distribuzioni, chiama il comando [batch-get-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-deployments.html), specificando più identificatori di distribuzione univoci: [Per ottenere la distribuzione IDs, chiama il comando list-deployments.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html)
Per visualizzare un elenco delle distribuzioni IDs, chiamate il comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html), specificando:
+ Il nome dell'applicazione associata alla distribuzione. [Per visualizzare un elenco di nomi di applicazioni, chiamate il comando list-applications.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html)
+ Il nome del gruppo di distribuzione associato alla distribuzione. Per visualizzare un elenco di nomi dei gruppi di distribuzione, chiama il comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ Facoltativamente, se includere i dettagli relativi alle distribuzioni in base al loro stato di distribuzione. (Se non specificato, vengono elencati tutte le distribuzioni corrispondenti, indipendentemente dallo stato di distribuzione.)
+ Facoltativamente, se includere i dettagli relativi alle distribuzioni in base alle ore di inizio o fine della creazione della distribuzione, o entrambe. (Se non specificato, vengono elencate tutte le distribuzioni corrispondenti, indipendentemente dall'ora di creazione.)
# Visualizzazione dei dati di registro per le distribuzioni CodeDeploy EC2/on-premise
Puoi visualizzare i dati di log creati da una CodeDeploy distribuzione configurando l' CloudWatch agente Amazon per visualizzare i dati aggregati nella CloudWatch console o accedendo a una singola istanza per esaminare il file di registro.
**Nota**
I log non sono supportati per le distribuzioni AWS Lambda o Amazon ECS. Possono essere creati solo per le distribuzioni EC2/on-premise.
**Topics**
+ [Visualizza i dati dei file di registro nella CloudWatch console Amazon](#deployments-view-logs-cloudwatch)
+ [Visualizza i file di registro su un'istanza](#deployments-view-logs-instance)
## Visualizza i dati dei file di registro nella CloudWatch console Amazon
Quando l' CloudWatch agente Amazon viene installato su un'istanza, i dati di distribuzione per tutte le distribuzioni su quell'istanza diventano disponibili per la CloudWatch visualizzazione nella console. Per semplicità, consigliamo di utilizzarli CloudWatch per monitorare centralmente i file di registro anziché visualizzarli istanza per istanza. Per ulteriori informazioni, consulta [Invia i log degli CodeDeploy agenti a CloudWatch](codedeploy-agent-operations-cloudwatch-agent.md).
## Visualizza i file di registro su un'istanza
Per visualizzare la distribuzione dei dati di log per una singola istanza, è possibile effettuare l'accesso all'istanza e navigare per cercare informazioni su errori o altri eventi di distribuzione.
**Topics**
+ [Per visualizzare i file di registro della distribuzione su istanze di Amazon Linux, RHEL e Ubuntu Server](#deployments-view-logs-instance-unix)
+ [Per visualizzare i file di registro della distribuzione sulle istanze di Windows Server](#deployments-view-logs-instance-windows)
### Per visualizzare i file di registro della distribuzione su istanze di Amazon Linux, RHEL e Ubuntu Server
Nelle istanze di Amazon Linux, RHEL e Ubuntu Server, i log di distribuzione vengono archiviati nella seguente posizione:
`/opt/codedeploy-agent/deployment-root/deployment-logs/codedeploy-agent-deployments.log`
Per visualizzare o analizzare i log di distribuzione su istanze Amazon Linux, RHEL e Ubuntu Server, accedi all'istanza e digita il seguente comando per aprire il file di registro dell' CodeDeploy agente:
```
less /var/log/aws/codedeploy-agent/codedeploy-agent.log
```
Digitare i seguenti comandi per cercare messaggi di errore nel file di log:
| Comando | Risultato |
| --- | --- |
| & ERROR | Mostra solo i messaggi di errore nel file di log. Utilizza un unico spazio prima e dopo la parola ERROR. |
| / ERROR | Cerca il messaggio di errore successivo.¹ |
| ? ERROR | Cerca il messaggio di errore precedente.² Usa un solo spazio prima e dopo la parola. ERROR |
| G | Vai alla fine del file di log. |
| g | Vai all'inizio del file di log. |
| q | Esci dal file di log. |
| h | Ulteriori informazioni sui comandi aggiuntivi. |
| ¹ Dopo aver digitato**/ ERROR **, digita il messaggio **n** di errore successivo. Digita **N** per il precedente messaggio di errore. ² Dopo aver digitato**? ERROR **, digitare **n** per il messaggio di errore successivo o digitare **N** il messaggio di errore precedente. |
È inoltre possibile digitare il seguente comando per aprire un file di registro CodeDeploy degli script:
```
less /opt/codedeploy-agent/deployment-root/deployment-group-ID/deployment-ID/logs/scripts.log
```
Digitare i seguenti comandi per cercare messaggi di errore nel file di log:
| Comando | Risultato |
| --- | --- |
| &stderr | Mostra solo i messaggi di errore nel file di log. |
| /stderr | Cerca il messaggio di errore successivo.¹ |
| ?stderr | Cerca il messaggio di errore precedente.² |
| G | Vai alla fine del file di log. |
| g | Vai all'inizio del file di log. |
| q | Esci dal file di log. |
| h | Ulteriori informazioni sui comandi aggiuntivi. |
| ¹ Dopo aver digitato**/stderr**, digita il messaggio **n** di errore successivo. Digita **N** per il precedente messaggio di errore indietro. ² Dopo aver digitato**?stderr**, digita **n** all'indietro il messaggio di errore successivo. Digita **N** per il precedente messaggio di errore avanti. |
### Per visualizzare i file di registro della distribuzione sulle istanze di Windows Server
**CodeDeploy file di registro dell'agente**: nelle istanze di Windows Server, il file di registro dell' CodeDeploy agente viene archiviato nella seguente posizione:
`C:\ProgramData\Amazon\CodeDeploy\log\codedeploy-agent-log.txt`
Per visualizzare o analizzare il file di registro dell' CodeDeploy agente su un'istanza di Windows Server, accedi all'istanza e digita il comando seguente per aprire il file:
```
notepad C:\ProgramData\Amazon\CodeDeploy\log\codedeploy-agent-log.txt
```
Per ricercare messaggi di errore nel file di log, premere CTRL\$1F, digitare **ERROR [**, quindi premere Invio per trovare il primo errore.
**CodeDeploy file di registro degli script**: nelle istanze di Windows Server, i registri di distribuzione vengono archiviati nella seguente posizione:
`C:\ProgramData\Amazon\CodeDeploy\deployment-group-id\deployment-id\logs\scripts.log`
Dove:
+ *deployment-group-id*è una stringa come `examplebf3a9c7a-7c19-4657-8684-b0c68d0cd3c4`
+ *deployment-id*è un identificatore come `d-12EXAMPLE`
Digitate il seguente comando per aprire un file di registro CodeDeploy degli script:
```
notepad C:\ProgramData\Amazon\CodeDeploy\deployment-group-ID\deployment-ID\logs\scripts.log
```
Per ricercare messaggi di errore nel file di log, premere CTRL\$1F, digitare **stderr**, quindi premere Invio per trovare il primo errore.
# Interrompi una distribuzione con CodeDeploy
Puoi utilizzare la CodeDeploy console AWS CLI, la o la CodeDeploy APIs per interrompere le distribuzioni associate al tuo AWS account.
**avvertimento**
L'interruzione di una distribuzione EC2 /On-Premises può lasciare alcune o tutte le istanze nei gruppi di distribuzione in uno stato di distribuzione indeterminato. Per ulteriori informazioni, consulta [Distribuzioni interrotte e non riuscite](deployment-steps-server.md#deployment-stop-fail).
**Topics**
+ [Arresto di una distribuzione (console)](#deployments-stop-console)
+ [Arresto di una distribuzione (CLI)](#deployments-stop-cli)
**Nota**
Se la distribuzione è una distribuzione blu/verde CloudFormation, non è possibile eseguire questa attività nella console. CodeDeploy Vai alla CloudFormation console per eseguire questa operazione.
## Arresto di una distribuzione (console)
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 **Deploy**, quindi scegli **Deployments**.
**Nota**
Se non viene visualizzata alcuna voce, assicurati che sia selezionata la regione corretta. Nella barra di navigazione, nel selettore di regione, scegli 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* CodeDeploy è supportato solo in queste regioni.
1. Scegli la distribuzione che desideri arrestare con una delle seguenti operazioni:
1. Scegli **Stop deployment (Arresta distribuzione)** per arrestare la distribuzione senza un rollback.
1. Scegli **Stop and roll back deployment (Arresta la distribuzione ed esegui il rollback)** per arrestare la distribuzione ed eseguire un rollback.
Per ulteriori informazioni, consulta [Ridistribuisci e ripristina una distribuzione con CodeDeploy](deployments-rollback-and-redeploy.md).
**Nota**
Se le opzioni **Stop deployment (Arresta distribuzione)** e **Stop and roll back deployment (Arresta distribuzione ed esegui il rollback)** non sono disponibili, la distribuzione è avanzata fino a un punto in cui non può essere arrestata.
## Arresto di una distribuzione (CLI)
Chiama il comando [stop-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/stop-deployment.html), specificando l'ID di distribuzione. [Per visualizzare un elenco delle distribuzioni IDs, chiama il comando list-deployments.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html)
# Ridistribuisci e ripristina una distribuzione con CodeDeploy
CodeDeploy ripristina le distribuzioni ridistribuendo una revisione precedentemente distribuita di un'applicazione come nuova distribuzione. Queste distribuzioni ripristinate sono tecnicamente nuove implementazioni, con una nuova distribuzione, anziché versioni ripristinate di una distribuzione precedente. IDs
Le distribuzioni possono essere ripristinate automaticamente o manualmente.
**Topics**
+ [Rollback automatici](#deployments-rollback-and-redeploy-automatic-rollbacks)
+ [Rollback manuali](#deployments-rollback-and-redeploy-manual-rollbacks)
+ [Flusso di lavoro di rollback e ridistribuzione](#deployments-rollback-and-redeploy-workflow)
+ [Comportamento di rollback con il contenuto esistente](#deployments-rollback-and-redeploy-content-options)
## Rollback automatici
È possibile configurare un gruppo di distribuzione o una distribuzione in modo che venga eseguito automaticamente il ripristino quando una distribuzione non riesce o quando viene raggiunta una soglia di monitoraggio specificata. In questo caso, viene distribuita la versione più recente di una revisione di applicazione valida nota. È possibile configurare i rollback automatici al momento della creazione di un'applicazione o quando si creare o si aggiorna un gruppo di distribuzione.
Quando si crea una nuova distribuzione, è possibile anche scegliere di ignorare la configurazione di rollback automatico specificata per il gruppo di distribuzione.
**Nota**
Puoi utilizzare Amazon Simple Notification Service per ricevere una notifica ogni volta che una distribuzione viene ripristinata automaticamente. Per informazioni, consulta [Monitoraggio delle distribuzioni con le notifiche degli eventi di Amazon SNS](monitoring-sns-event-notifications.md).
Per ulteriori informazioni sulla configurazione dei rollback automatici, consulta [Configurazione delle opzioni avanzate per un gruppo di distribuzione](deployment-groups-configure-advanced-options.md).
## Rollback manuali
Se non hai configurato i rollback automatici, puoi ripristinare una distribuzione manualmente creando una nuova distribuzione che utilizza una revisione dell'applicazione distribuita in precedenza, quindi seguendo la procedura per ridistribuire una revisione. Potresti dover eseguire questa operazione nel caso in cui un'applicazione si trovi in uno stato sconosciuto. Anziché dedicare molto tempo a risolvere il problema, puoi ridistribuire l'applicazione con uno stato operativo noto. Per ulteriori informazioni, consulta [Crea una distribuzione con CodeDeploy](deployments-create.md).
**Nota**
Se rimuovi un'istanza da un gruppo di distribuzione, CodeDeploy non disinstalla nulla che potrebbe essere già stato installato su quell'istanza.
## Flusso di lavoro di rollback e ridistribuzione
Quando viene avviato il rollback automatico o quando si avvia manualmente una ridistribuzione o un rollback manuale, tenta CodeDeploy innanzitutto di rimuovere da ogni istanza partecipante tutti i file che sono stati installati con successo l'ultima volta. CodeDeploy lo fa controllando il file di pulizia:
`/opt/codedeploy-agent/deployment-root/deployment-instructions/deployment-group-ID-cleanup`file (per Amazon Linux, Ubuntu Server e istanze RHEL)
`C:\ProgramData\Amazon\CodeDeploy\deployment-instructions\deployment-group-ID-cleanup`file (per istanze di Windows Server)
Se esiste, CodeDeploy utilizza il file di pulizia per rimuovere dall'istanza tutti i file elencati prima di iniziare la nuova distribuzione.
Ad esempio, i primi due file di testo e due file di script sono già stati distribuiti su un'istanza Amazon EC2 che esegue Windows Server e gli script hanno creato altri due file di testo durante gli eventi del ciclo di vita della distribuzione:
```
c:\temp\a.txt (previously deployed by CodeDeploy)
c:\temp\b.txt (previously deployed by CodeDeploy)
c:\temp\c.bat (previously deployed by CodeDeploy)
c:\temp\d.bat (previously deployed by CodeDeploy)
c:\temp\e.txt (previously created by c.bat)
c:\temp\f.txt (previously created by d.bat)
```
Nel file di cleanup saranno elencati solo i primi due file di testo e due file script:
```
c:\temp\a.txt
c:\temp\b.txt
c:\temp\c.bat
c:\temp\d.bat
```
Prima della nuova distribuzione, CodeDeploy rimuoverà solo i primi due file di testo e i due file di script, lasciando intatti gli ultimi due file di testo:
```
c:\temp\a.txt will be removed
c:\temp\b.txt will be removed
c:\temp\c.bat will be removed
c:\temp\d.bat will be removed
c:\temp\e.txt will remain
c:\temp\f.txt will remain
```
Come parte di questo processo, CodeDeploy non cercherà di ripristinare o riconciliare in altro modo le azioni intraprese dagli script nelle distribuzioni precedenti durante le ridistribuzioni successive, che si tratti di rollback manuali o automatici. Ad esempio, se `d.bat` i file `c.bat` and contengono la logica per non ricreare i file and se già esistono, le versioni precedenti di `e.txt` e `f.txt` rimarranno invariate ogni volta che vengono eseguite e nelle distribuzioni successive. `e.txt` `f.txt` CodeDeploy `c.bat` `d.bat` È possibile aggiungere la logica a `c.bat` e `d.bat` per verificare sempre la presenza di versioni precedenti di `e.txt` e `f.txt` ed eliminarle prima di crearne di nuove.
## Comportamento di rollback con il contenuto esistente
Come parte del processo di distribuzione, l' CodeDeploy agente rimuove da ogni istanza tutti i file installati dalla distribuzione più recente. Se i file che non facevano parte di una distribuzione precedente vengono visualizzati nelle posizioni di distribuzione di destinazione, puoi scegliere CodeDeploy cosa farne durante la distribuzione successiva:
+ **Interruzione non riuscita**: viene segnalato un errore e lo stato della distribuzione viene modificato in Non riuscito.
+ **Sovrascrivi il contenuto**: la versione del file contenuta nella revisione dell'applicazione sostituisce la versione già presente sull'istanza.
+ **Conserva il contenuto**: il file nella posizione di destinazione viene conservato e la versione nella revisione dell'applicazione non viene copiata nell'istanza.
È possibile scegliere questo comportamento quando si crea una distribuzione. Se si crea una distribuzione nella console, vedere[Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)](deployments-create-console.md). Se si crea una distribuzione con AWS CLI, vedere[Crea un'implementazione della piattaforma di elaborazione (CLI) EC2/on-premise](deployments-create-cli.md).
Puoi scegliere di mantenere i file che desideri inserire nella successiva distribuzione senza doverli aggiungere al pacchetto della revisione dell'applicazione. Ad esempio, potresti caricare direttamente nell'istanza i file che sono necessari per la distribuzione, ma che non sono stati aggiunti al pacchetto di revisione dell'applicazione. Oppure puoi caricare file sull'istanza se le tue applicazioni sono già nell'ambiente di produzione ma desideri utilizzarle CodeDeploy per la prima volta per distribuirle.
Nel caso dei rollback, in cui per un errore di distribuzione viene ridistribuita la revisione dell'applicazione distribuita più recente, alla distribuzione di ripristino viene applicata l'opzione di gestione del contenuto relativa a quell'ultima distribuzione.
Tuttavia, se la distribuzione non riuscita è stata configurata per sovrascrivere, anziché conservare, i file, durante il rollback potrebbe verificarsi un risultato inaspettato. Nello specifico, potrebbe accadere che i file che devono essere conservati vengano rimossi dalla distribuzione non riuscita. I file non sono presenti nell'istanza quando viene eseguita la distribuzione di rollback.
Nell'esempio seguente, sono presenti tre distribuzioni. Tutti i file che vengono sovrascritti (eliminati) durante la seconda distribuzione non riuscita non sono più disponibili (non possono essere conservati) quando la revisione dell'applicazione 1 viene nuovamente distribuita durante la distribuzione 3:
****
| Implementazione | Revisione dell'applicazione | Opzione sovrascrittura contenuto | Stato dell’implementazione | Comportamento e risultato |
| --- | --- | --- | --- | --- |
| distribuzione 1 | revisione dell'applicazione 1 | RETAIN | Riuscito | CodeDeploy rileva i file nelle posizioni di destinazione che non sono stati distribuiti dalla distribuzione precedente. Questi file potrebbero essere stati inseriti intenzionalmente per includerli nella distribuzione corrente. Vengono tenuti e registrati come parte del pacchetto di distribuzione corrente. |
| distribuzione 2 | revisione dell'applicazione 2 | SOVRASCRIVI | Non riuscito | Durante il processo di distribuzione, CodeDeploy elimina tutti i file che fanno parte della precedente distribuzione riuscita. Questo include i file che sono stati conservati durante la distribuzione 1. Tuttavia, la distribuzione ha esito negativo per motivi non correlati. |
| distribuzione 3 | revisione dell'applicazione 1 | RETAIN | | Poiché il rollback automatico è abilitato per la distribuzione o il gruppo di distribuzione, CodeDeploy distribuisce l'ultima revisione dell'applicazione notoriamente funzionante, revisione dell'applicazione 1.Tuttavia, i file che si desidera conservare nella distribuzione 1 sono stati eliminati prima del fallimento della distribuzione 2 e non possono essere recuperati da. AWS CodeDeployÈ possibile aggiungerli all'istanza, se sono necessarie per la revisione dell'applicazione 1, oppure è possibile creare una nuova revisione dell'applicazione. |
# Distribuire un'applicazione in un account diverso AWS
Le organizzazioni dispongono in genere di più AWS account che utilizzano per scopi diversi (ad esempio, uno per le attività di amministrazione del sistema e un altro per le attività di sviluppo, test e produzione o uno associato agli ambienti di sviluppo e test e un altro associato all'ambiente di produzione).
Sebbene sia possibile eseguire operazioni correlate in account diversi, i gruppi di CodeDeploy distribuzione e le istanze Amazon EC2 su cui vengono distribuiti sono strettamente legati agli account con cui sono stati creati. Non è possibile, ad esempio, aggiungere un'istanza avviata con un account a un gruppo di distribuzione di un altro account.
Supponiamo che tu abbia due AWS account: il tuo account di sviluppo e il tuo account di produzione. e che utilizzi soprattutto l'account di sviluppo. Tuttavia vorresti iniziare a eseguire distribuzioni con l'account di produzione senza la necessità di un set completo di credenziali o senza dovere effettuare la disconnessione dall'account di sviluppo per connetterti a quello di produzione.
Dopo avere eseguito la procedura di configurazione tra più account, è possibile avviare distribuzioni che appartengono a un altro account dell'organizzazione senza la necessità di un set completo di credenziali. Puoi farlo, in parte, utilizzando una funzionalità fornita da AWS Security Token Service (AWS STS) che ti garantisce l'accesso temporaneo a quell'account.
## Passaggio 1: crea un bucket S3 in uno dei due account
In entrambi gli account, di sviluppo e di produzione:
+ Se non l'hai già fatto, crea un bucket Amazon S3 in cui verranno archiviate le revisioni dell'applicazione per l'account di produzione. Per informazioni, consulta [Creare un bucket in Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) S3. Puoi anche usare lo stesso bucket e le stesse versioni dell'applicazione per entrambi gli account, distribuendo nell'ambiente di produzione gli stessi file testati e verificati del tuo account di sviluppo.
## Fase 2: concedere le autorizzazioni del bucket Amazon S3 al profilo dell'istanza IAM dell'account di produzione
Se il bucket Amazon S3 creato nella fase 1 si trova nel tuo account di produzione, questo passaggio non è necessario. Il ruolo che assumerai in seguito sarà già dotato dell'accesso a questo bucket, in quanto anche questo si trova nell'account di produzione.
Se hai creato il bucket Amazon S3 nell'account di sviluppo, procedi come segue:
+ Nell'account di produzione, crea un profilo di istanza IAM. Per informazioni, consulta [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md).
**Nota**
Prendi nota dell'ARN per questo profilo di istanza IAM. Dovrai aggiungerlo alla policy per più bucket che creerai successivamente.
+ Nell'account di sviluppo, consenti l'accesso al bucket Amazon S3 che hai creato nell'account di sviluppo al profilo dell'istanza IAM che hai appena creato nel tuo account di produzione. Per informazioni, vedi [Esempio 2: Il proprietario del bucket concede le autorizzazioni per i bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html) tra account.
Osserva quanto segue nel completare la procedura necessaria per concedere autorizzazioni per il bucket multiaccount:
+ NelIa procedura guidata di esempio, l'account A rappresenta l'account di sviluppo, mentre l'account B rappresenta quello di produzione.
+ Quando [esegui le attività dell'account A (di sviluppo)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html#access-policies-walkthrough-cross-account-permissions-acctA-tasks), modifica la seguente policy del bucket per concedere le autorizzazioni multiaccount anziché utilizzare la policy di esempio fornita nella procedura guidata.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Cross-account permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/role-name"
},
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::bucket-name/*"
]
}
]
}
```
------
*account-id*rappresenta il numero di account dell'account di produzione in cui hai appena creato il profilo dell'istanza IAM.
*role-name*rappresenta il nome del profilo dell'istanza IAM che hai appena creato.
*bucket-name*rappresenta il nome del bucket creato nel passaggio 1. Assicurati di includere `/*` dopo il nome del bucket per fornire l'accesso a ogni file all'interno del bucket.
## Fase 3: Creare risorse e un ruolo per più account nell'account di produzione
Nell'account di produzione:
+ Crea CodeDeploy le tue risorse (applicazione, gruppo di distribuzione, configurazione di distribuzione, istanze Amazon EC2, profilo dell'istanza Amazon EC2, ruolo di servizio e così via) utilizzando le istruzioni contenute in questa guida.
+ Crea un ruolo aggiuntivo, un ruolo IAM per più account, che un utente del tuo account di sviluppo possa assumere per eseguire CodeDeploy operazioni in questo account di produzione.
Utilizza la [procedura dettagliata: delega l'accesso tra AWS account utilizzando i ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/walkthru_cross-account-with-roles.html) come guida per aiutarti a creare il ruolo tra account. Invece di aggiungere le autorizzazioni di esempio riportate nella procedura dettagliata al documento relativo alla policy, dovresti allegare al ruolo almeno le seguenti due policy fornite: AWS
+ `AmazonS3FullAccess`: necessaria solo se il bucket S3 si trova nell'account di sviluppo. Fornisce al presunto ruolo dell'account di produzione l'accesso completo ai servizi e alle risorse Amazon S3 nell'account di sviluppo, in cui è archiviata la revisione.
+ `AWSCodeDeployDeployerAccess`: consente a un utente di registrare e distribuire le revisioni.
Se desideri non solo avviare distribuzioni ma anche creare e gestire gruppi di distribuzione, aggiungi la policy `AWSCodeDeployFullAccess` anziché la policy `AWSCodeDeployDeployerAccess`. Per ulteriori informazioni sull'utilizzo delle policy gestite da IAM per concedere le autorizzazioni per le CodeDeploy attività, consulta. [AWS politiche gestite (predefinite) per CodeDeploy](managed-policies.md)
È possibile collegare policy aggiuntive per eseguire attività in altri servizi AWS durante l'utilizzo di questo ruolo multiaccount.
**Importante**
Durante la creazione del ruolo IAM per più account, prendi nota dei dettagli necessari per accedere all'account di produzione.
Per utilizzare il comando Console di gestione AWS per passare da un ruolo all'altro, dovrai fornire uno dei seguenti elementi:
Un URL per accedere all'account di produzione con le credenziali del ruolo assunto. Troverai l'URL nella pagina **Review (Revisione)** visualizzata alla fine del processo di creazione del ruolo multiaccount.
Il nome del ruolo multiaccount e l'alias o il numero di ID dell'account.
Per utilizzare il comando AWS CLI per cambiare ruolo, è necessario fornire quanto segue:
L'ARN del ruolo multiaccount che assumerai.
## Fase 4: caricare la revisione dell'applicazione nel bucket Amazon S3
Nell'account in cui hai creato il bucket Amazon S3:
+ Carica la revisione dell'applicazione nel bucket Amazon S3. Per informazioni, consulta [Invia una revisione CodeDeploy ad Amazon S3 (solo distribuzioni EC2/on-premise)](application-revisions-push.md).
## Fase 5: Assumi il ruolo di più account e distribuisci le applicazioni
Nell'account di sviluppo, puoi utilizzare AWS CLI o Console di gestione AWS per assumere il ruolo tra account diversi e avviare la distribuzione nell'account di produzione.
Per istruzioni su come utilizzare il Console di gestione AWS per cambiare ruolo e avviare le distribuzioni, consulta [Passare a un](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ruolo () e.Console di gestione AWS[Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)](deployments-create-console.md)
Per istruzioni su come utilizzare per assumere il AWS CLI ruolo tra account diversi e avviare le distribuzioni, consulta [Switching to](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-cli.html) an IAM role () e.AWS Command Line Interface[Crea un'implementazione della piattaforma di elaborazione (CLI) EC2/on-premise](deployments-create-cli.md)
[Per ulteriori informazioni sull'assunzione di un ruolo tramite AWS STS, consulta la [Guida per l'AWS Security Token Service utente e [assume-role [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html)nel Command Reference](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html).AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
**Argomento correlato:**
+ [CodeDeploy: distribuzione da un account di sviluppo a un account di produzione](https://aws.amazon.com/blogs/devops/aws-codedeploy-deploying-from-a-development-account-to-a-production-account/)
# Utilizzare l' CodeDeploy agente per convalidare un pacchetto di distribuzione su un computer locale
Utilizzando l' CodeDeploy agente, puoi distribuire contenuti su un'istanza a cui hai effettuato l'accesso. Ciò consente di verificare l'integrità di un file di specifiche dell'applicazione (AppSpec file) che si intende utilizzare in una distribuzione e del contenuto che si intende distribuire.
Non è necessario creare un'applicazione e un gruppo di distribuzione. Se desideri distribuire il contenuto archiviato sull'istanza locale, non hai nemmeno bisogno di un AWS account. Per i test più semplici, puoi eseguire il **codedeploy-local** comando, senza specificare alcuna opzione, in una directory che contiene il AppSpec file e il contenuto da distribuire. Lo strumento offre opzioni per altri test case.
Convalidando un pacchetto di distribuzione in un computer locale è possibile:
+ Testare l'integrità di una revisione dell'applicazione.
+ Verifica il contenuto di un AppSpec file.
+ Prova CodeDeploy per la prima volta con il codice dell'applicazione esistente.
+ Distribuire il contenuto in modo rapido quando si è già connessi a un'istanza.
Puoi utilizzare contenuti di distribuzione archiviati sull'istanza locale o in un tipo di repository remoto supportato (bucket Amazon S3 o repository pubblici). GitHub
## Prerequisiti
Prima di avviare una distribuzione locale, completa la procedura illustrata di seguito:
+ Crea o usa un tipo di istanza supportato dall'agente. CodeDeploy Per informazioni, consulta [Sistemi operativi supportati dall'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
+ Installa la versione 1.0.1.1352 o successiva dell'agente. CodeDeploy Per informazioni, consulta [Installa l' CodeDeploy agente](codedeploy-agent-operations-install.md).
+ Se stai distribuendo i tuoi contenuti da un bucket GitHub o da un repository Amazon S3, fornisci un utente con cui utilizzarli. CodeDeploy Per informazioni, consulta [Fase 1: Configurazione](getting-started-setting-up.md).
+ Se stai distribuendo la revisione dell'applicazione da un bucket Amazon S3, crea un bucket Amazon S3 nella regione in cui lavori e applica una policy per i bucket Amazon S3 al bucket. Questa policy concede alle istanze le autorizzazioni richieste per scaricare la revisione dell'applicazione.
Ad esempio, la seguente policy sui bucket di Amazon S3 consente a qualsiasi istanza Amazon EC2 con un profilo di istanza IAM collegato contenente l'ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` di essere scaricata da qualsiasi punto del bucket Amazon S3 denominato: `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"
]
}
}
]
}
```
La seguente policy sui bucket di Amazon S3 consente a qualsiasi istanza locale con un utente IAM associato contenente l'ARN di essere scaricata `arn:aws:iam::444455556666:user/CodeDeployUser` da qualsiasi punto del bucket Amazon S3 denominato: `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:user/CodeDeployUser"
]
}
}
]
}
```
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).
+ Se stai distribuendo la revisione dell'applicazione da un bucket GitHub o da un repository Amazon S3, configura un profilo di istanza IAM e collegalo all'istanza. Per informazioni, consulta [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md), [Crea un'istanza Amazon EC2 per CodeDeploy (AWS CLI o una console Amazon EC2)](instances-ec2-create.md) e [Crea un'istanza Amazon EC2 per CodeDeploy (modello)CloudFormation](instances-ec2-create-cloudformation-template.md).
+ Se stai distribuendo i tuoi contenuti da GitHub, crea un account e un GitHub archivio pubblico. [Per creare un GitHub account, consulta Partecipa. GitHub](https://github.com/join) Per creare un GitHub repository, consulta [Creare un repository](https://help.github.com/articles/create-a-repo/).
**Nota**
I repository privati attualmente non sono supportati. Se i tuoi contenuti sono archiviati in un GitHub repository privato, puoi scaricarli sull'istanza e utilizzare l'`--bundle-location`opzione per specificarne il percorso locale.
+ Prepara il contenuto (incluso un AppSpec file) che desideri distribuire sull'istanza e inseriscilo nell'istanza locale, nel tuo bucket Amazon S3 o nel tuo repository. GitHub Per informazioni, consulta [Utilizzo delle revisioni delle applicazioni per CodeDeploy](application-revisions.md).
+ Se desideri utilizzare valori diversi da quelli predefiniti per altre opzioni di configurazione, crea il file di configurazione e posizionalo nell'istanza (per istanze `/etc/codedeploy-agent/conf/codedeployagent.yml` Amazon Linux, RHEL o Ubuntu Server o `C:\ProgramData\Amazon\CodeDeploy\conf.yml` per istanze Windows Server). Per informazioni, consulta [CodeDeploy riferimento alla configurazione dell'agente](reference-agent-configuration.md).
**Nota**
Se utilizzi un file di configurazione su istanze Amazon Linux, RHEL o Ubuntu Server, devi:
Utilizzare le variabili `:root_dir:` e `:log_dir:` per specificare posizioni diverse da quelle predefinite per la cartella della directory dei log e la cartella principale della distribuzione.
Utilizzato `sudo` per eseguire i comandi CodeDeploy dell'agente.
## Crea una distribuzione locale
Nell'istanza in cui desideri creare la distribuzione locale, apri una sessione terminale (istanze Amazon Linux, RHEL o Ubuntu Server) o un prompt dei comandi (Windows Server) per eseguire i comandi dello strumento.
**Nota**
Il comando **codedeploy-local** viene installato nelle posizioni seguenti:
Su Amazon Linux, RHEL o Ubuntu Server:`/opt/codedeploy-agent/bin`.
Su Windows Server:`C:\ProgramData\Amazon\CodeDeploy\bin`.
** Sintassi del comando base **
```
codedeploy-local [options]
```
**Riepilogo**
```
codedeploy-local
[--bundle-location ]
[--type ]
[--file-exists-behavior ]
[--deployment-group ]
[--events ]
[--agent-configuration-file ]
[--appspec-filename ]
```
**Opzioni**
**-l**, **--bundle-location**
La posizione del bundle di revisione dell'applicazione. Se non specifichi un percorso, per impostazione predefinita lo strumento utilizza la directory di lavoro. Se specifichi un valore per `--bundle-location`, devi specificare anche un valore per `--type`.
Esempi di formato del percorso del bundle:
+ Istanza locale di Amazon Linux, RHEL o Ubuntu Server: `/path/to/local/bundle.tgz`
+ Istanza locale di Windows Server: `C:/path/to/local/bundle`
+ Bucket Amazon S3: `s3://amzn-s3-demo-bucket/bundle.tar`
+ GitHub archivio: `https://github.com/account-name/repository-name/`
**-t**, **--type**
Il formato del bundle di revisione dell'applicazione. I tipi supportati includono `tgz`, `tar`, `zip` e `directory`. Se non specifichi un tipo, lo strumento utilizza `directory` per impostazione predefinita. Se specifichi un valore per `--type`, devi specificare anche un valore per `--bundle-location`.
**-b****, -- file-exists-behavior**
Indica come vengono gestiti in una posizione di destinazione della distribuzione i file già esistenti che non facevano parte della distribuzione precedente. Le opzioni includono DISALLOW, OVERWRITE, RETAIN. Per ulteriori informazioni, consulta [fileExistsBehavior AWS CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html#CodeDeploy-CreateDeployment-request-fileExistsBehavior)*[API Reference.](https://docs.aws.amazon.com/codedeploy/latest/APIReference/)*
**-g**, **--deployment-group**
Il percorso della cartella di destinazione del contenuto da distribuire. Se non si specifica una cartella, lo strumento ne crea una denominata *default-local-deployment-group*all'interno della directory principale di distribuzione. Per ogni distribuzione locale creata, all'interno di questa cartella lo strumento crea una sottodirectory con nomi del tipo *d-98761234-local*.
**-e**, **--events**
Un set di hook di eventi override lifecycle che desideri eseguire, in ordine, anziché gli eventi elencati nel file. AppSpec È possibile specificare più hook separati da virgole. Puoi utilizzare questa opzione se:
+ Vuoi eseguire un set diverso di eventi senza dover aggiornare il file. AppSpec
+ Vuoi eseguire un singolo hook di eventi come eccezione al contenuto del AppSpec file, ad esempio`ApplicationStop`.
Se non specificate né **DownloadBundle****installate** gli eventi nell'elenco delle sostituzioni, questi verranno eseguiti prima di tutti gli hook di eventi specificati. Se includi **DownloadBundle**e **Install** nell'elenco delle `--events` opzioni, questi devono essere preceduti solo da eventi che normalmente vengono eseguiti prima di loro nelle distribuzioni. CodeDeploy Per informazioni, consulta [AppSpec sezione 'hooks'](reference-appspec-file-structure-hooks.md).
****-c, -- agent-configuration-file****
Posizione di un file di configurazione da utilizzare per la distribuzione, se archiviato in un percorso diverso da quello predefinito. Un file di configurazione specifica alternative rispetto ad altri valori e comportamenti predefiniti per una distribuzione.
Per impostazione predefinita, i file di configurazione vengono archiviati in `/etc/codedeploy-agent/conf/codedeployagent.yml` (istanze Amazon Linux, RHEL o Ubuntu Server) o `C:/ProgramData/Amazon/CodeDeploy/conf.yml` (Windows Server). Per ulteriori informazioni, consulta [CodeDeploy riferimento alla configurazione dell'agente](reference-agent-configuration.md).
****-A, --appspec-filename****
Il nome del file. AppSpec Per le distribuzioni locali, i valori accettati sono `appspec.yml` e. `appspec.yaml` Per impostazione predefinita, il AppSpec file viene chiamato. `appspec.yml`
**-h**, **--help**
Visualizza un riepilogo del contenuto della guida.
**-v**, **--version**
Visualizza il numero di versione dello strumento.
## Esempi
Di seguito vengono illustrati alcuni esempi di formati di comando validi.
```
codedeploy-local
```
```
codedeploy-local --bundle-location /path/to/local/bundle/directory
```
```
codedeploy-local --bundle-location C:/path/to/local/bundle.zip --type zip --deployment-group my-deployment-group
```
```
codedeploy-local --bundle-location /path/to/local/directory --type directory --deployment-group my-deployment-group
```
Distribuisci un pacchetto da Amazon S3:
```
codedeploy-local --bundle-location s3://amzn-s3-demo-bucket/bundle.tgz --type tgz
```
```
codedeploy-local --bundle-location s3://amzn-s3-demo-bucket/bundle.zip?versionId=1234&etag=47e8 --type zip --deployment-group my-deployment-group
```
Distribuisci un pacchetto da un archivio pubblico: GitHub
```
codedeploy-local --bundle-location https://github.com/awslabs/aws-codedeploy-sample-tomcat --type zip
```
```
codedeploy-local --bundle-location https://api.github.com/repos/awslabs/aws-codedeploy-sample-tomcat/zipball/master --type zip
```
```
codedeploy-local --bundle-location https://api.github.com/repos/awslabs/aws-codedeploy-sample-tomcat/zipball/HEAD --type zip
```
```
codedeploy-local --bundle-location https://api.github.com/repos/awslabs/aws-codedeploy-sample-tomcat/zipball/1a2b3c4d --type zip
```
Distribuire un pacchetto specificando più eventi del ciclo di vita:
```
codedeploy-local --bundle-location /path/to/local/bundle.tar --type tar --application-folder my-deployment --events DownloadBundle,Install,ApplicationStart,HealthCheck
```
Arresta un'applicazione precedentemente distribuita utilizzando l'evento del ciclo di vita: ApplicationStop
```
codedeploy-local --bundle-location /path/to/local/bundle.tgz --type tgz --deployment-group --events ApplicationStop
```
Effettuare la distribuzione utilizzando un ID del gruppo di distribuzione specifico:
```
codedeploy-local --bundle-location C:/path/to/local/bundle/directory --deployment-group 1234abcd-5dd1-4774-89c6-30b107ac5dca
```
```
codedeploy-local --bundle-location C:/path/to/local/bundle.zip --type zip --deployment-group 1234abcd-5dd1-4774-89c6-30b107ac5dca
```