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à.
# Risoluzione dei problemi CodeDeploy
Utilizza gli argomenti di questa sezione per risolvere i problemi e gli errori che potresti riscontrare durante l'utilizzo. CodeDeploy
**Nota**
Puoi identificare le cause di molti guasti di distribuzione rivedendo i file di log creati durante il processo di distribuzione. Per semplicità, consigliamo di utilizzare Amazon CloudWatch Logs per monitorare centralmente i file di registro anziché visualizzarli istanza per istanza. Per informazioni, consulta [Monitoraggio delle implementazioni con gli strumenti di Amazon CloudWatch](monitoring-cloudwatch.md).
**Topics**
+ [Risoluzione di problemi generali](troubleshooting-general.md)
+ [Risolvi i problemi relativi alla distribuzione di EC2/on-premise](troubleshooting-deployments.md)
+ [Risolvi i problemi di distribuzione di Amazon ECS](troubleshooting-ecs.md)
+ [Risolvi i problemi di implementazione di Lambda AWS](troubleshooting-deployments-lambda.md)
+ [Risoluzione dei problemi relativi ai gruppi di distribuzione](troubleshooting-deployment-groups.md)
+ [Risoluzione dei problemi relativi alle istanze](troubleshooting-ec2-instances.md)
+ [Risolvi i problemi relativi GitHub ai token](troubleshooting-github-token-issues.md)
+ [Risolvi i problemi relativi ad Amazon EC2 Auto Scaling](troubleshooting-auto-scaling.md)
+ [Codici di errore per AWS CodeDeploy](error-codes.md)
# Risoluzione di problemi generali
**Topics**
+ [Lista di controllo per la risoluzione di problemi generali](#troubleshooting-checklist)
+ [CodeDeploy le risorse di distribuzione sono supportate solo in alcune regioni AWS](#troubleshooting-supported-regions)
+ [Le procedure descritte in questa guida non corrispondono a quelle della CodeDeploy console](#troubleshooting-old-console)
+ [I ruoli IAM richiesti non sono disponibili](#troubleshooting-iam-cloudformation)
+ [L'utilizzo di alcuni editor di testo per creare AppSpec file e script di shell può causare il fallimento delle distribuzioni](#troubleshooting-text-editors)
+ [L'utilizzo di Finder in macOS per includere in un file compresso la revisione di un'applicazione può determinare l'esito negativo delle distribuzioni](#troubleshooting-bundle-with-finder)
## Lista di controllo per la risoluzione di problemi generali
È possibile utilizzare la seguente lista di controllo per la risoluzione dei problemi di distribuzione non riuscita.
1. Consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md) e [Visualizza i dettagli dell'istanza con CodeDeploy](instances-view-details.md) per determinare per quale motivo la distribuzione non è riuscita. Se non riesci a determinare la causa, esamina le voci di questo elenco di controllo.
1. Controlla se hai configurato correttamente le istanze:
+ L'istanza è stata lanciata con una coppia di key pair EC2 specificata? Per ulteriori informazioni, consulta [EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2-key-pairs.html) nella *Amazon EC2* User Guide.
+ Il profilo di istanza IAM corretto è collegato all'istanza? Per ulteriori informazioni, consultare [Configura un'istanza Amazon EC2 con cui lavorare CodeDeploy](instances-ec2-configure.md) e [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md).
+ All'istanza sono stati applicati tag? Per ulteriori informazioni, consulta [Lavorare con i tag nella console nella Guida](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console) per l'*utente di Amazon EC2*.
+ L' CodeDeploy agente è installato, aggiornato e in esecuzione sull'istanza? Per ulteriori informazioni, consulta [Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md). Per verificare quale versione dell'agente è installata, consulta[Determina la versione dell' CodeDeploy agente](codedeploy-agent-operations-version.md).
1. Controlla l'applicazione e le impostazioni del gruppo di distribuzione:
+ Per verificare le impostazioni dell'applicazione, consulta [Visualizza i dettagli dell'applicazione con CodeDeploy](applications-view-details.md).
+ Per verificare le impostazioni del gruppo di distribuzione, consulta [Visualizza i dettagli del gruppo di distribuzione con CodeDeploy](deployment-groups-view-details.md).
1. Conferma che la revisione dell'applicazione sia configurata correttamente:
+ Controllate il formato del AppSpec file. Per ulteriori informazioni, consultare [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md) e [CodeDeploy AppSpec riferimento al file](reference-appspec-file.md).
+ Controlla il tuo bucket o GitHub repository Amazon S3 per verificare che la revisione dell'applicazione sia nella posizione prevista.
+ Controlla i dettagli della revisione dell' CodeDeploy applicazione per assicurarti che sia registrata correttamente. Per informazioni, consulta [Visualizza i dettagli della revisione dell'applicazione con CodeDeploy](application-revisions-view-details.md).
+ Se esegui la distribuzione da Amazon S3, controlla il tuo bucket Amazon S3 per CodeDeploy verificare che siano state concesse le autorizzazioni per scaricare la revisione dell'applicazione. Per informazioni sulle policy del bucket, consulta la sezione [Prerequisiti di distribuzione](deployments-create-prerequisites.md).
+ Se stai eseguendo la distribuzione da GitHub, controlla il tuo GitHub repository per verificare che siano state concesse le autorizzazioni per scaricare la revisione CodeDeploy dell'applicazione. Per ulteriori informazioni, consultare [Crea una distribuzione con CodeDeploy](deployments-create.md) e [GitHub autenticazione con applicazioni in CodeDeploy](integrations-partners-github.md#behaviors-authentication).
1. Controlla se il ruolo del servizio è configurato correttamente. Per informazioni, consulta [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).
1. Conferma di aver seguito le fasi in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md) per:
+ Ha fornito a un utente le autorizzazioni appropriate.
+ Installare o aggiornare e configurare il AWS CLI.
+ Crea un profilo di istanza IAM e un ruolo di servizio.
Per ulteriori informazioni, consulta [Gestione delle identità e degli accessi per AWS CodeDeploy](security-iam.md).
1. Conferma di utilizzare la AWS CLI versione 1.6.1 o successiva. Per controllare la versione che hai installato, chiama **aws --version**.
Se ancora non riesci a risolvere i problemi di distribuzione non riuscita, esaminare gli altri problemi in questo argomento.
## CodeDeploy le risorse di distribuzione sono supportate solo in alcune regioni AWS
Se non vedi o non riesci ad accedere alle applicazioni, ai gruppi di distribuzione, alle istanze o ad altre risorse di distribuzione dalla console AWS CLI o dalla CodeDeploy console, assicurati di fare riferimento a una delle AWS regioni elencate in [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS*
Le istanze EC2 e i gruppi Amazon EC2 Auto Scaling utilizzati CodeDeploy nelle distribuzioni devono essere avviati e creati in una di queste regioni. AWS
Se utilizzi il, esegui il comando AWS CLI da. **aws configure** AWS CLI Quindi puoi visualizzare e impostare la tua AWS regione predefinita.
Se usi la CodeDeploy console, nella barra di navigazione, dal selettore della regione, scegli una delle AWS regioni supportate.
**Importante**
Per utilizzare i servizi nella regione Cina (Pechino) o nella regione Cina (Ningxia), è necessario disporre di un account e delle credenziali per tali aree. Gli account e le credenziali di altre AWS regioni non funzionano per le regioni di Pechino e Ningxia e viceversa.
Le informazioni su alcune risorse per le regioni della Cina, come i nomi dei bucket del CodeDeploy Resource Kit e le procedure di installazione degli CodeDeploy agenti, non sono incluse in questa edizione della *Guida per l'CodeDeploy utente*.
Per ulteriori informazioni:
[CodeDeploy](http://docs.amazonaws.cn/en_us/aws/latest/userguide/codedeploy.html)in *[Guida introduttiva AWS nella regione Cina (Pechino)](http://docs.amazonaws.cn/en_us/aws/latest/userguide/introduction.html)*
*CodeDeploy Guida per l'utente per le regioni della Cina* ([versione inglese](http://docs.amazonaws.cn/en_us/codedeploy/latest/userguide/welcome.html) \$1 [versione cinese](http://docs.amazonaws.cn/codedeploy/latest/userguide/welcome.html))
## Le procedure descritte in questa guida non corrispondono a quelle della CodeDeploy console
Le procedure in questa guida sono scritte in base al nuovo progetto di console. Tuttavia molti dei concetti e delle procedure di base in questa guida si applicano anche alla versione precedente della console. Per accedere alla guida nella nuova console, scegli l'icona delle informazioni.
## I ruoli IAM richiesti non sono disponibili
Se ti affidi a un profilo di istanza IAM o a un ruolo di servizio creato come parte di uno AWS CloudFormation stack, se elimini lo stack, vengono eliminati anche tutti i ruoli IAM. Questo potrebbe essere il motivo per cui il ruolo IAM non viene più visualizzato nella console IAM e CodeDeploy non funziona più come previsto. Per risolvere questo problema, devi ricreare manualmente il ruolo IAM eliminato.
## L'utilizzo di alcuni editor di testo per creare AppSpec file e script di shell può causare il fallimento delle distribuzioni
Alcuni editor di testo introducono caratteri non conformi e non stampabili nei file. Se utilizzi editor di testo per creare o modificare AppSpec file o file di script di shell da eseguire su istanze Amazon Linux, Ubuntu Server o RHEL, qualsiasi distribuzione basata su questi file potrebbe fallire. Quando CodeDeploy utilizza questi file durante una distribuzione, la presenza di questi caratteri può portare a errori di convalida dei hard-to-troubleshoot AppSpec file e errori di esecuzione degli script.
**Nella CodeDeploy console, nella pagina dei dettagli dell'evento per la distribuzione, scegli Visualizza registri.** (Oppure puoi usare il AWS CLI per chiamare il [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html)comando.) Cerca gli errori, ad esempio `invalid character`, `command not found` o `file not found`.
Per risolvere questo problema, è consigliabile attenersi alle seguenti indicazioni:
+ Non utilizzate editor di testo che introducono caratteri non stampabili, come i caratteri di ritorno (`^M`caratteri) nei AppSpec file e nei file di script di shell.
+ Utilizzate editor di testo che visualizzano caratteri non stampabili, come i riage return nei file e i AppSpec file di shell script, in modo da poter trovare e rimuovere tutti i caratteri che potrebbero essere introdotti. Per esempi di questi tipi di editor di testo, esegui una ricerca su Internet dei termini "editor di testo che mostrano ritorni a capo".
+ Usa editor di testo in esecuzione su istanze Amazon Linux, Ubuntu Server o RHEL per creare file di script di shell da eseguire su istanze Amazon Linux, Ubuntu Server o RHEL. Per esempi di questi tipi di editor di testo, esegui una ricerca su Internet dei termini "editor script shell Linux".
+ Se devi usare un editor di testo in Windows o macOS per creare file di script di shell da eseguire su istanze Amazon Linux, Ubuntu Server o RHEL, usa un programma o un'utilità che converta il testo in formato Windows o macOS in formato Unix. Per esempi di questi programmi e utilità, esegui una ricerca su Internet dei termini "da DOS a UNIX" o "da Mac a UNIX". Assicurati di testare i file di script shell convertiti sui sistemi operativi di destinazione.
## L'utilizzo di Finder in macOS per includere in un file compresso la revisione di un'applicazione può determinare l'esito negativo delle distribuzioni
Le distribuzioni potrebbero non riuscire se si utilizza l'applicazione dell'interfaccia grafica utente (GUI) Finder su un Mac per raggruppare (comprimere) un AppSpec file e i file e gli script correlati in un file di archivio di revisione dell'applicazione (.zip). Ciò si verifica perché Finder crea una cartella `__MACOSX` intermedia nel file.zip e vi colloca al suo interno i file dei componenti. CodeDeploy non è in grado di individuare i file dei componenti, per cui la distribuzione ha esito negativo.
Per risolvere questo problema, ti consigliamo di utilizzare il comando AWS CLI to call the [push, che comprime i file dei componenti](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) nella struttura prevista. In alternativa, puoi utilizzare Terminal anziché la GUI per comprimere i file dei componenti in formato zip. Terminal non crea una cartella `__MACOSX` intermedia.
# Risolvi i problemi relativi alla distribuzione di EC2/on-premise
**Topics**
+ [CodeDeploy errore relativo alle credenziali mancanti del plugin CommandPoller](#troubleshooting-agent-commandpoller-error)
+ [La distribuzione non riesce con il messaggio «Convalida del PKCS7 messaggio firmato non riuscita»](#troubleshooting-deployments-agent-SHA-256)
+ [La distribuzione o la ridistribuzione degli stessi file alle stesse posizioni delle istanze avrà esito negativo e mostrerà l'errore "La distribuzione non è riuscita a causa di un file specificato già esistente in questa posizione"](#troubleshooting-same-files-different-app-name)
+ [I percorsi di file lunghi causano errori del tipo «Nessun file o directory di questo tipo»](#troubleshooting-long-file-paths)
+ [I processi di lunga durata possono compromettere la riuscita delle distribuzioni](#troubleshooting-long-running-processes)
+ [Risoluzione dei problemi relativi a un evento AllowTraffic del ciclo di vita non riuscito senza che sia stato riportato alcun errore nei log di distribuzione](#troubleshooting-deployments-allowtraffic-no-logs)
+ [Risoluzione dei problemi relativi a un evento non riuscito o ApplicationStop AfterBlockTraffic relativo al BeforeBlockTraffic ciclo di vita dell'implementazione](#troubleshooting-deployments-lifecycle-event-failures)
+ [Risoluzione dei problemi relativi a un evento del ciclo di vita di DownloadBundle distribuzione non riuscito con UnknownError: not open-for reading](#troubleshooting-deployments-downloadbundle)
+ [Risoluzione dei problemi relativi a tutti gli eventi del ciclo di vita ignorati](#troubleshooting-skipped-lifecycle-events)
+ [Per impostazione predefinita, PowerShell gli script di Windows non riescono a utilizzare la versione a 64 bit di Windows PowerShell](#troubleshooting-deployments-powershell)
**Nota**
Le cause di molti guasti di distribuzione possono essere identificate rivedendo i file di log creati durante il processo di distribuzione. Per semplicità, consigliamo di utilizzare Amazon CloudWatch Logs per monitorare centralmente i file di registro anziché visualizzarli istanza per istanza. Per informazioni, consulta [View CodeDeploy Logs in CloudWatch Logs Console](https://aws.amazon.com/blogs/devops/view-aws-codedeploy-logs-in-amazon-cloudwatch-console/).
**Suggerimento**
*Per un runbook che automatizza molte attività di risoluzione dei problemi relative alle distribuzioni EC2/on-premise, consulta il riferimento al runbook di riferimento di [AWSSupport-TroubleshootCodeDeploy](https://docs.aws.amazon.com/systems-manager-automation-runbooks/latest/userguide/automation-awssupport-troubleshootcodedeploy.html)Systems Manager Automation.AWS *
## CodeDeploy errore relativo alle credenziali mancanti del plugin CommandPoller
Se si verifica un errore simile a `InstanceAgent::Plugins::CodeDeployPlugin::CommandPoller: Missing credentials - please check if this instance was started with an IAM instance profile`, il motivo potrebbe essere uno dei seguenti:
+ L'istanza su cui stai eseguendo la distribuzione non ha un profilo di istanza IAM associato.
+ Il profilo dell'istanza IAM non dispone delle autorizzazioni corrette configurate.
Un profilo di istanza IAM concede all' CodeDeploy agente l'autorizzazione a comunicare CodeDeploy e scaricare la revisione da Amazon S3. Per le istanze EC2, consulta [Gestione delle identità e degli accessi per AWS CodeDeploy](security-iam.md). Per le istanze locali, consulta [Utilizzo di istanze locali per CodeDeploy](instances-on-premises.md).
## La distribuzione non riesce con il messaggio «Convalida del PKCS7 messaggio firmato non riuscita»
Questo messaggio di errore indica che l'istanza sta eseguendo una versione dell' CodeDeploy agente che supporta solo l'algoritmo hash SHA-1. Il supporto per l'algoritmo hash SHA-2 è stato introdotto nella versione 1.0.1.854 dell'agente, rilasciata a novembre 2015. CodeDeploy A partire dal 17 ottobre 2016, le distribuzioni non riescono se viene installata una versione dell'agente precedente alla 1.0.1.854. CodeDeploy Per ulteriori informazioni, consulta per [passare AWS all'algoritmo SHA256 hash per i certificati SSL](https://aws.amazon.com/security/security-bulletins/aws-to-switch-to-sha256-hash-algorithm-for-ssl-certificates/), [NOTA: CodeDeploy Ritiro](https://forums.aws.amazon.com/thread.jspa?threadID=223319) degli agenti host precedenti alla versione 1.0.1.85 e. [Aggiorna l'agente CodeDeploy](codedeploy-agent-operations-update.md)
## La distribuzione o la ridistribuzione degli stessi file alle stesse posizioni delle istanze avrà esito negativo e mostrerà l'errore "La distribuzione non è riuscita a causa di un file specificato già esistente in questa posizione"
Quando si CodeDeploy tenta di distribuire un file su un'istanza ma un file con lo stesso nome esiste già nella posizione di destinazione specificata, la distribuzione su quell'istanza potrebbe non riuscire. Potresti ricevere il messaggio di errore «La distribuzione non è riuscita perché un file specificato esiste già in questa posizione:*location-name*» Ciò si verifica perché, durante ciascuna distribuzione, CodeDeploy prima elimina tutti i file dalla distribuzione precedente, che sono elencati in un file di log di pulizia. Se nelle cartelle di installazione di destinazione sono presenti file che non sono elencati in questo file di pulizia, l' CodeDeploy agente per impostazione predefinita lo interpreta come un errore e fallisce la distribuzione.
**Nota**
Nelle istanze di Amazon Linux, RHEL e Ubuntu Server, il file di pulizia si trova in. `/opt/codedeploy-agent/deployment-root/deployment-instructions/` Nelle istanze di Windows Server, la posizione è. `C:\ProgramData\Amazon\CodeDeploy\deployment-instructions\`
Il modo più semplice per evitare questo errore è specificare un'opzione diversa dal comportamento predefinito per l'esito negativo della distribuzione. Per ciascuna distribuzione, è possibile scegliere se far sì che la distribuzione abbia esito negativo, sovrascrivere i file non inclusi nel file di pulizia o conservare i file già presenti nell'istanza.
L'opzione di sovrascrittura è utile, ad esempio, se collochi manualmente un file in un'istanza dopo l'ultima distribuzione e poi aggiungi un file con lo stesso nome nella successiva revisione dell'applicazione.
Potresti scegliere l'opzione di conservazione per i file nell'istanza che desideri inserire nella successiva distribuzione senza doverli aggiungere al pacchetto della revisione dell'applicazione. L'opzione retention è utile anche se i file dell'applicazione si trovano già nell'ambiente di produzione e si desidera distribuirli utilizzando CodeDeploy per la prima volta. Per ulteriori informazioni, consultare [Crea una distribuzione della piattaforma di elaborazione EC2/on-premise (console)](deployments-create-console.md) e [Comportamento di rollback con il contenuto esistente](deployments-rollback-and-redeploy.md#deployments-rollback-and-redeploy-content-options).
### Risolvere i problemi di distribuzione `The deployment failed because a specified file already exists at this location`
Se scegli di non specificare un'opzione per sovrascrivere o conservare i contenuti che CodeDeploy rileva nelle tue posizioni di distribuzione di destinazione (o se non specifichi alcuna opzione di distribuzione per la gestione dei contenuti esistenti in un comando programmatico), puoi scegliere di eseguire la risoluzione dell'errore.
Le informazioni seguenti si applicano solo se scegli di non conservare o sovrascrivere i contenuti.
Se si tenta di ridistribuire file con gli stessi nomi e posizioni, è più probabile che la ridistribuzione abbia successo se si specifica il nome dell'applicazione e il gruppo di distribuzione con lo stesso ID del gruppo di distribuzione sottostante utilizzato in precedenza. CodeDeploy utilizza l'ID del gruppo di distribuzione sottostante per identificare i file da rimuovere prima di una ridistribuzione.
La distribuzione di nuovi file o la ridistribuzione degli stessi file nelle stesse posizioni sulle istanze può avere esito negativo per questi motivi:
+ Hai specificato un nome dell'applicazione diverso per una ridistribuzione della stessa revisione alle stesse istanze. La ridistribuzione ha esito negativo perché, anche se il nome del gruppo di distribuzione è lo stesso, l'uso di un nome dell'applicazione diverso comporta l'utilizzo di un ID gruppo di distribuzione sottostante differente.
+ Hai eliminato e ricreato un gruppo di distribuzione per un'applicazione e poi hai tentato di ridistribuire la stessa revisione al gruppo di distribuzione. La ridistribuzione non riesce perché, anche se il nome del gruppo di distribuzione è lo stesso, CodeDeploy fa riferimento a un ID del gruppo di distribuzione sottostante diverso.
+ Hai eliminato un'applicazione e un gruppo di distribuzione in CodeDeploy, quindi hai creato una nuova applicazione e un gruppo di distribuzione con gli stessi nomi di quelli eliminati. Dopodiché hai tentato di ridistribuire al nuovo gruppo di distribuzione una revisione che era stata distribuita al gruppo di distribuzione precedente con lo stesso nome. La ridistribuzione non riesce perché, anche se i nomi dell'applicazione e del gruppo di distribuzione sono gli stessi, fa CodeDeploy comunque riferimento all'ID del gruppo di distribuzione eliminato.
+ Hai distribuito una revisione a un gruppo di distribuzione e poi hai distribuito la stessa revisione a un altro gruppo di distribuzione per le stesse istanze. La seconda distribuzione ha esito negativo perché CodeDeploy fa riferimento a un ID gruppo di distribuzione sottostante differente.
+ Hai distribuito una revisione a un gruppo di distribuzione e poi hai distribuito un'altra revisione a un altro gruppo di distribuzione per le stesse istanze. Vi è almeno un file con lo stesso nome e nella stessa posizione che il secondo gruppo di distribuzione cerca di distribuire. La seconda distribuzione non riesce perché CodeDeploy non rimuove il file esistente prima dell'inizio della seconda distribuzione. Entrambe le distribuzioni > fanno riferimento a gruppi di distribuzione diversi. IDs
+ Hai distribuito una revisione in CodeDeploy, ma esiste almeno un file con lo stesso nome e nella stessa posizione. La distribuzione non riesce perché, per impostazione predefinita, CodeDeploy non rimuove il file esistente prima dell'inizio della distribuzione.
Per risolvere queste situazioni, procedi in uno dei seguenti modi:
+ Rimuovi i file dalle posizioni e dalle istanze in cui erano stati distribuiti in precedenza e prova a eseguire nuovamente la distribuzione.
+ Nel AppSpec file della revisione, negli eventi del ciclo di vita della BeforeInstall distribuzione ApplicationStop o della distribuzione, specifica uno script personalizzato per eliminare i file in tutte le posizioni che corrispondono ai file che la revisione sta per installare.
+ Distribuisci o ridistribuisci i file a posizioni o istanze che non erano parte di distribuzioni precedenti.
+ Prima di eliminare un'applicazione o un gruppo di distribuzione, distribuite una revisione che contenga un AppSpec file che specifichi l'assenza di file da copiare nelle istanze. Per la distribuzione, specifica il nome dell'applicazione e il nome del gruppo di distribuzione che utilizzano la stessa applicazione e lo stesso gruppo di distribuzione sottostanti di IDs quelli che stai per eliminare. (È possibile utilizzare il [get-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-group.html)comando per recuperare l'ID del gruppo di distribuzione.) CodeDeployutilizza l'ID e il AppSpec file del gruppo di distribuzione sottostanti per rimuovere tutti i file installati nella precedente distribuzione riuscita.
## I percorsi di file lunghi causano errori del tipo «Nessun file o directory di questo tipo»
Per le distribuzioni su istanze di Windows, se nella sezione file del file appspec.yml è presente un percorso di oltre 260 caratteri, è possibile che le distribuzioni non riescano con un errore simile al seguente:
`No such file or directory @ dir_s_mkdir - C:\your-long-file-path`
[Questo errore si verifica perché Windows per impostazione predefinita non consente percorsi di file superiori a 260 caratteri, come dettagliato nella documentazione Microsoft.](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell#enable-long-paths-in-windows-10-version-1607-and-later)
Per le versioni CodeDeploy dell'agente 1.4.0 o successive, è possibile abilitare i percorsi di file lunghi in due modi, a seconda del processo di installazione dell'agente:
Se l' CodeDeploy agente non è ancora stato installato:
1. Sul computer in cui intendi installare l' CodeDeploy agente, abilita la chiave di registro di `LongPathsEnabled` Windows utilizzando questo comando:
```
New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem"
-Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force
```
1. Installa l' CodeDeploy agente. Per ulteriori informazioni, consulta [Installa l' CodeDeploy agente](codedeploy-agent-operations-install.md).
Se l' CodeDeploy agente è già stato installato:
1. Sul computer dell' CodeDeploy agente, abilita la chiave di registro di `LongPathsEnabled` Windows utilizzando questo comando:
```
New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem"
-Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force
```
1. Riavviare l' CodeDeploy agente per rendere effettiva la modifica della chiave di registro. Per riavviare l'agente, utilizzate questo comando:
```
powershell.exe -Command Restart-Service -Name codedeployagent
```
## I processi di lunga durata possono compromettere la riuscita delle distribuzioni
Per le distribuzioni su istanze Amazon Linux, Ubuntu Server e RHEL, se disponi di uno script di distribuzione che avvia un processo di lunga durata, CodeDeploy potresti attendere a lungo l'evento del ciclo di vita della distribuzione e poi fallire la distribuzione. Ciò accade perché, se il processo viene eseguito per un periodo di tempo maggiore rispetto a quello previsto per i processi in primo piano e in background di quell'evento, CodeDeploy si interrompe e la distribuzione non riesce, anche se il processo viene comunque eseguito come previsto.
Ad esempio, una revisione dell'applicazione contiene due file nella propria radice, `after-install.sh` e `sleep.sh`. Il file contiene le seguenti istruzioni: AppSpec
```
version: 0.0
os: linux
files:
- source: ./sleep.sh
destination: /tmp
hooks:
AfterInstall:
- location: after-install.sh
timeout: 60
```
Il `after-install.sh` file viene eseguito durante l'evento del ciclo di vita AfterInstall dell'applicazione. Di seguito sono descritti i contenuti:
```
#!/bin/bash
/tmp/sleep.sh
```
Il file `sleep.sh` include il contenuto seguente, che sospende l'esecuzione del programma per tre minuti (180 secondi), simulando un processo di lunga durata:
```
#!/bin/bash
sleep 180
```
In caso di `after-install.sh` chiamata`sleep.sh`, viene `sleep.sh` avviato ed eseguito per tre minuti (180 secondi), ovvero due minuti (120 secondi) dopo l'orario CodeDeploy previsto `sleep.sh` (e, per relazione,`after-install.sh`) l'interruzione dell'esecuzione. Dopo il timeout di un minuto (60 secondi), CodeDeploy interrompe e fallisce la distribuzione all'evento del ciclo di vita AfterInstall dell'applicazione, anche se `sleep.sh` continua a funzionare come previsto. Viene visualizzato l'errore seguente:
`Script at specified location: after-install.sh failed to complete in 60 seconds`.
Non è sufficiente aggiungere una e commerciale (`&`) in `after-install.sh` per eseguire `sleep.sh` in background.
```
#!/bin/bash
# Do not do this.
/tmp/sleep.sh &
```
In questo modo è possibile lasciare la distribuzione in sospeso fino al periodo di timeout predefinito di un'ora per l'evento del ciclo di vita dell'implementazione, dopodiché CodeDeploy interrompe e fallisce la distribuzione in occasione dell'evento del ciclo di vita dell'applicazione come in precedenza. AfterInstall
In`after-install.sh`, chiama `sleep.sh` come segue, il che consente CodeDeploy di continuare dopo l'avvio del processo:
```
#!/bin/bash
/tmp/sleep.sh > /dev/null 2> /dev/null < /dev/null &
```
Nella chiamata precedente `sleep.sh` è il nome del processo la cui esecuzione deve essere avviata in background, con il reindirizzamento di stdout, stderr e stdin a `/dev/null`.
## Risoluzione dei problemi relativi a un evento AllowTraffic del ciclo di vita non riuscito senza che sia stato riportato alcun errore nei log di distribuzione
In alcuni casi, una blue/green distribuzione non riesce durante l'evento del AllowTraffic ciclo di vita, ma i registri di distribuzione non indicano la causa dell'errore.
Questo errore è in genere dovuto a controlli di integrità configurati in modo errato in Elastic Load Balancing for the Classic Load Balancer, Application Load Balancer o Network Load Balancer utilizzati per gestire il traffico per il gruppo di distribuzione.
Per risolvere il problema, esamina e correggi eventuali errori nella configurazione del controllo dello stato per il sistema di bilanciamento del carico.
Per i Classic Load Balancer, consulta Configure [Health Checks](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-healthchecks.html) nella *User Guide for Classic Load Balancers* e [ConfigureHealthCheck](https://docs.aws.amazon.com/elasticloadbalancing/2012-06-01/APIReference/API_ConfigureHealthCheck.html)nella versione di riferimento dell'API *Elastic Load Balancing 2012-06-01*.
Per gli Application Load Balancer, consulta [Health Checks for Your Target Groups](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/target-group-health-checks.html) nella *User Guide for Application Load* Balancers.
Per i Network Load Balancer, consulta [Health Checks for Your Target Groups](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/target-group-health-checks.html) nella *Network Load Balancer* User Guide.
## Risoluzione dei problemi relativi a un evento non riuscito o ApplicationStop AfterBlockTraffic relativo al BeforeBlockTraffic ciclo di vita dell'implementazione
Durante una distribuzione, l' CodeDeploy agente esegue gli script specificati per ApplicationStop e BeforeBlockTraffic contenuti AfterBlockTraffic nel AppSpec file della precedente distribuzione riuscita. (Tutti gli altri script vengono eseguiti dal AppSpec file nella distribuzione corrente.) Se uno di questi script contiene un errore e non viene eseguito correttamente, è possibile che la distribuzione non riesca.
Le possibili cause di questa situazione includono:
+ L' CodeDeploy agente trova il `deployment-group-id_last_successful_install` file nella posizione corretta, ma la posizione elencata nel `deployment-group-id_last_successful_install` file non esiste.
**Nelle istanze Amazon Linux, Ubuntu Server e RHEL**, questo file deve esistere in. `/opt/codedeploy-agent/deployment-root/deployment-instructions`
**Nelle istanze di Windows Server**, questo file deve essere archiviato nella cartella. `C:\ProgramData\Amazon\CodeDeploy\deployment-instructions`
+ Nella posizione elencata nel `deployment-group-id_last_successful_install` file, il AppSpec file non è valido o gli script non vengono eseguiti correttamente.
+ Lo script contiene un errore che non può essere corretto, pertanto non verrà mai eseguito correttamente.
Usa la CodeDeploy console per indagare sul motivo per cui una distribuzione potrebbe non essere riuscita durante uno di questi eventi. Nella pagina dei dettagli per la distribuzione scegliere **View events (Visualizza eventi)**. Nella pagina dei dettagli dell'istanza, nella **AfterBlockTraffic**riga **ApplicationStop**BeforeBlockTraffic****, o, scegli **Visualizza registri.** Oppure usa AWS CLI per chiamare il [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html)comando.
Se la causa dell'errore è uno script dell'ultima distribuzione riuscita che non viene mai eseguito correttamente, crea una distribuzione e specifica che gli AfterBlockTraffic errori ApplicationStop BeforeBlockTraffic, e devono essere ignorati. Ci sono due modi per effettuare questa operazione:
+ Usa la CodeDeploy console per creare una distribuzione. Nella pagina **Crea distribuzione**, in **Errore dell'evento ApplicationStop del ciclo** di vita, scegli **Non interrompere la distribuzione su un'istanza se questo evento del ciclo di vita sull'istanza fallisce**.
+ Usa il AWS CLI per chiamare il **[create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html)** comando e includi l'opzione. `--ignore-application-stop-failures`
Quando si distribuisce nuovamente la revisione dell'applicazione, la distribuzione continua anche se uno di questi tre eventi del ciclo di vita non va a buon fine. Se la nuova revisione include script fissi per quegli eventi del ciclo di vita, è possibile che le distribuzioni future riescano senza applicare questa correzione.
## Risoluzione dei problemi relativi a un evento del ciclo di vita di DownloadBundle distribuzione non riuscito con UnknownError: not open-for reading
Se stai tentando di distribuire una revisione dell'applicazione da Amazon S3 e la distribuzione non riesce durante l'evento del ciclo di vita DownloadBundle della distribuzione con l'errore: `UnknownError: not opened for reading`
+ Si è verificato un errore interno del servizio Amazon S3. Distribuisci nuovamente la revisione dell'applicazione.
+ Il profilo dell'istanza IAM sulla tua istanza EC2 non dispone delle autorizzazioni per accedere alla revisione dell'applicazione in Amazon S3. Per informazioni sulle policy relative ai bucket di Amazon S3, consulta e. [Invia una revisione CodeDeploy ad Amazon S3 (solo distribuzioni EC2/on-premise)](application-revisions-push.md) [Prerequisiti di distribuzione](deployments-create-prerequisites.md)
+ Le istanze in cui esegui la distribuzione sono associate a una AWS regione (ad esempio, Stati Uniti occidentali (Oregon)), ma il bucket Amazon S3 che contiene la revisione dell'applicazione è associato a un'altra AWS regione (ad esempio, Stati Uniti orientali (Virginia settentrionale)). Assicurati che la revisione dell'applicazione si trovi in un bucket Amazon S3 associato alla AWS stessa regione delle istanze.
Nella pagina dei dettagli degli eventi per la distribuzione, nella riga **Download bundle (Scarica bundle)**, scegliere **View logs (Visualizza log)**. Oppure usa per chiamare il comando AWS CLI . [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) Se si verifica, l'errore deve essere indicato nell'output con il codice di errore `UnknownError` e il messaggio di errore `not opened for reading`.
Per stabilire il motivo di questo errore:
1. Abilitare la registrazione in rete su almeno una delle istanze, quindi distribuire nuovamente la revisione dell'applicazione.
1. Esaminare il file di registrazione in rete per trovare l'errore. I messaggi di errore più comuni per questo problema includono la frase "access denied" (accesso negato).
1. Dopo avere esaminato i file di log, è consigliabile disabilitare la registrazione in rete per ridurre la dimensione del file di log e la quantità di informazioni sensibili che in futuro potrebbero comparire nell'output in testo normale nell'istanza.
Per informazioni su come trovare il file di registrazione dei cavi e abilitare e disabilitare il cablaggio, vedere `:log_aws_wire:` nella guida di riferimento alla [configurazione CodeDeploy dell'agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-agent-configuration.html).
## Risoluzione dei problemi relativi a tutti gli eventi del ciclo di vita ignorati
Se tutti gli eventi del ciclo di vita di una distribuzione EC2 o locale vengono ignorati, potresti ricevere un errore simile a. `The overall deployment failed because too many individual instances failed deployment, too few healthy instances are available for deployment, or some instances in your deployment group are experiencing problems. (Error code: HEALTH_CONSTRAINTS)` Di seguito sono elencate alcune possibili cause e soluzioni:
+ L' CodeDeploy agente potrebbe non essere installato o in esecuzione sull'istanza. Per determinare se l' CodeDeploy agente è in esecuzione:
+ Per il server Amazon Linux RHEL o Ubuntu, esegui:
```
systemctl status codedeploy-agent
```
+ Per Windows, esegui:
```
powershell.exe -Command Get-Service -Name CodeDeployagent
```
Se l' CodeDeploy agente non è installato o non è in esecuzione, vedere[Verifica che l' CodeDeploy agente sia in esecuzione](codedeploy-agent-operations-verify.md).
L'istanza potrebbe non essere in grado di raggiungere l'endpoint pubblico CodeDeploy o Amazon S3 utilizzando la porta 443. Provare con una delle seguenti operazioni:
+ Assegna un indirizzo IP pubblico all'istanza e utilizza la tabella di routing per consentire l'accesso a Internet. Verifica che il gruppo di sicurezza associato all'istanza consenta l'accesso in uscita sulla porta 443 (HTTPS). Per ulteriori informazioni, consulta [Protocollo di comunicazione e porta per l'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-outbound-port).
+ Se un'istanza viene assegnata in una sottorete privata, utilizza un gateway NAT anziché un gateway Internet nella tabella di routing. Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html).
+ Il ruolo di servizio per CodeDeploy potrebbe non avere le autorizzazioni richieste. Per configurare un ruolo del servizio CodeDeploy, consulta [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).
+ Se utilizzate un proxy HTTP, assicuratevi che sia specificato nell'`:proxy_uri:`impostazione del file di configurazione dell' CodeDeploy agente. Per ulteriori informazioni, consulta [CodeDeploy riferimento alla configurazione dell'agente](reference-agent-configuration.md).
+ La data e l'ora dell'istanza di distribuzione potrebbero non corrispondere alla data e all'ora della richiesta di distribuzione. Cerca un errore simile a quello presente `Cannot reach InstanceService: Aws::CodeDeployCommand::Errors::InvalidSignatureException - Signature expired` nel file di registro CodeDeploy dell'agente. Se l'errore è presente, segui i passaggi descritti in [Risoluzione degli errori di distribuzione «InvalidSignatureException — Firma scaduta: [ora] è precedente a [ora]»](troubleshooting-ec2-instances.md#troubleshooting-instance-time-failures). Per ulteriori informazioni, consulta [Visualizzazione dei dati di registro per le distribuzioni CodeDeploy EC2/on-premise](deployments-view-logs.md).
+ L' CodeDeploy agente potrebbe smettere di funzionare perché un'istanza sta esaurendo la memoria o lo spazio su disco rigido. Prova a ridurre il numero di distribuzioni archiviate sulla tua istanza aggiornando l'`max_revisions`impostazione nella configurazione dell'agente. CodeDeploy Se esegui questa operazione per un'istanza EC2 e il problema persiste, prendi in considerazione l'utilizzo di un'istanza più grande. Ad esempio, se il tipo di istanza è `t2.small`, prova a usare un'stanza `t2.medium`. Per ulteriori informazioni, consulta [File installati dall'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-install-files)[CodeDeploy riferimento alla configurazione dell'agente](reference-agent-configuration.md), e Tipi di [istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html).
+ L'istanza su cui stai eseguendo la distribuzione potrebbe non avere un profilo di istanza IAM collegato o potrebbe avere un profilo di istanza IAM collegato che non dispone delle autorizzazioni richieste.
+ Se un profilo di istanza IAM non è collegato alla tua istanza, creane uno con le autorizzazioni richieste e poi collegalo.
+ Se un profilo di istanza IAM è già collegato alla tua istanza, assicurati che disponga delle autorizzazioni richieste.
Dopo aver verificato che il profilo di istanza collegato è configurato con le autorizzazioni richieste, riavvia l'istanza. Per ulteriori informazioni, consulta [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md) [IAM Roles for Amazon EC2 nella Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-EC2.html) *User Guide*.
## Per impostazione predefinita, PowerShell gli script di Windows non riescono a utilizzare la versione a 64 bit di Windows PowerShell
Se uno PowerShell script di Windows eseguito come parte di una distribuzione si basa sulla funzionalità a 64 bit (ad esempio, perché consuma più memoria di quella consentita da un'applicazione a 32 bit o chiama librerie offerte solo in una versione a 64 bit), lo script potrebbe bloccarsi o non essere eseguito come previsto. Questo perché, per impostazione predefinita, CodeDeploy utilizza la versione a 32 bit di Windows PowerShell per eseguire PowerShell script Windows che fanno parte della revisione di un'applicazione.
Aggiungi codice come il seguente all'inizio di qualsiasi script che deve essere eseguito con la versione a 64 bit di Windows: PowerShell
```
# Are you running in 32-bit mode?
# (\SysWOW64\ = 32-bit mode)
if ($PSHOME -like "*SysWOW64*")
{
Write-Warning "Restarting this script under 64-bit Windows PowerShell."
# Restart this script under 64-bit Windows PowerShell.
# (\SysNative\ redirects to \System32\ for 64-bit mode)
& (Join-Path ($PSHOME -replace "SysWOW64", "SysNative") powershell.exe) -File `
(Join-Path $PSScriptRoot $MyInvocation.MyCommand) @args
# Exit 32-bit script.
Exit $LastExitCode
}
# Was restart successful?
Write-Warning "Hello from $PSHOME"
Write-Warning " (\SysWOW64\ = 32-bit mode, \System32\ = 64-bit mode)"
Write-Warning "Original arguments (if any): $args"
# Your 64-bit script code follows here...
# ...
```
Sebbene le informazioni sul percorso dei file contenute in questo codice possano sembrare controintuitive, Windows a 32 bit PowerShell utilizza un percorso come:
`c:\Windows\SysWOW64\WindowsPowerShell\v1.0\powershell.exe`
Windows a 64 bit PowerShell utilizza un percorso come:
`c:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe`
# Risolvi i problemi di distribuzione di Amazon ECS
**Topics**
+ [Si verifica un timeout durante l'attesa del set di attività sostitutivo](#troubleshooting-ecs-timeout)
+ [Si verifica un timeout durante l'attesa del proseguimento della notifica](#troubleshooting-ecs-timeout-notif)
+ [Il ruolo IAM non dispone di autorizzazioni sufficienti](#troubleshooting-ecs-iam)
+ [La distribuzione è scaduta in attesa di una richiamata dello stato](#troubleshooting-ecs-timeout-callback)
+ [L'implementazione non è riuscita perché una o più funzioni di convalida degli eventi del ciclo di vita non sono riuscite](#troubleshooting-ecs-lifecycle)
+ [L'ELB non può essere aggiornato a causa del seguente errore: Il gruppo target del taskset primario deve essere dietro il listener](#troubleshooting-ecs-elb)
+ [La mia implementazione a volte fallisce quando utilizzo Auto Scaling](#troubleshooting-ecs-auto-scaling)
+ [Solo ALB supporta il routing graduale del traffico, utilizza invece il routing AllAtOnce del traffico quando utilizzi il gruppo Deployment create/update](#troubleshooting-ecs-lb)
+ [Anche se la mia implementazione è riuscita, il set di attività sostitutivo non supera i controlli di integrità di Elastic Load Balancing e la mia applicazione è inattiva](#troubleshooting-ecs-task-set-stability)
+ [Posso collegare più sistemi di bilanciamento del carico a un gruppo di distribuzione?](#troubleshooting-ecs-lb-multi)
+ [Posso eseguire distribuzioni CodeDeploy blu/verdi senza un sistema di bilanciamento del carico?](#troubleshooting-ecs-lb-bg)
+ [Come posso aggiornare il mio servizio Amazon ECS con nuove informazioni durante una distribuzione?](#troubleshooting-ecs-exec)
## Si verifica un timeout durante l'attesa del set di attività sostitutivo
**Problema**: viene visualizzato il seguente messaggio di errore durante la distribuzione dell'applicazione Amazon ECS utilizzando: CodeDeploy
`The deployment timed out while waiting for the replacement task set to become healthy. This time out period is 60 minutes.`
**Possibile causa**: questo errore può verificarsi in caso di errore nel file di definizione delle attività o in altri file relativi alla distribuzione. Ad esempio, se c'è un errore di battitura nel `image` campo del file di definizione dell'attività, Amazon ECS cercherà di recuperare l'immagine del contenitore sbagliata e fallirà continuamente, causando questo errore.
**Possibili correzioni e passaggi successivi**:
+ Correggi gli errori tipografici e i problemi di configurazione nel file di definizione delle attività e in altri file.
+ Controlla l'evento relativo al servizio Amazon ECS e scopri perché le attività di sostituzione non stanno diventando salutari. Per ulteriori informazioni sugli eventi di Amazon ECS, consulta gli eventi di [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_cwe_events.html) nella *Amazon Elastic Container Service Developer Guide*.
+ Consulta la sezione [sulla risoluzione dei problemi di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/troubleshooting.html) nella *Amazon Elastic Container Service Developer Guide* per gli errori relativi ai messaggi dell'evento.
## Si verifica un timeout durante l'attesa del proseguimento della notifica
**Problema**: viene visualizzato il seguente messaggio di errore durante la distribuzione dell'applicazione Amazon ECS utilizzando: CodeDeploy
`The deployment timed out while waiting for a notification to continue. This time out period is n minutes.`
**Causa possibile**: questo errore potrebbe verificarsi se hai specificato un tempo di attesa nel campo **Specificare quando reindirizzare il traffico quando hai creato il gruppo di distribuzione, ma la distribuzione non è potuta** terminare prima della scadenza del tempo di attesa.
**Possibili correzioni e passaggi successivi**:
+ Nel gruppo di distribuzione, imposta **Specificare quando reindirizzare il traffico** a un periodo di tempo maggiore e ridistribuire. Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione per una distribuzione Amazon ECS (console)](deployment-groups-create-ecs.md).
+ **Nel gruppo di distribuzione, modifica **Specificare quando reindirizzare il traffico in Reindirizzare immediatamente il traffico e ridistribuire**.** Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione per una distribuzione Amazon ECS (console)](deployment-groups-create-ecs.md).
+ Ridistribuisci e quindi esegui il comando con l'opzione impostata su. [https://docs.aws.amazon.com/cli/latest/reference/deploy/continue-deployment.html](https://docs.aws.amazon.com/cli/latest/reference/deploy/continue-deployment.html) AWS CLI `--deployment-wait-type``READY_WAIT` Assicuratevi di eseguire questo comando *prima* della scadenza dell'orario specificato in **Specificare quando reindirizzare il traffico**.
## Il ruolo IAM non dispone di autorizzazioni sufficienti
**Problema**: viene visualizzato il seguente messaggio di errore durante la distribuzione dell'applicazione Amazon ECS utilizzando: CodeDeploy
`The IAM role role-arn does not give you permission to perform operations in the following AWS service: AWSLambda.`
**Causa possibile**: questo errore potrebbe verificarsi se hai specificato una funzione Lambda nella [`Hooks`sezione del AppSpec file](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs), ma non hai dato l' CodeDeploy autorizzazione al servizio Lambda.
**Correzione possibile**: aggiungere l'`lambda:InvokeFunction`autorizzazione al ruolo di CodeDeploy servizio. Per aggiungere questa autorizzazione, aggiungi una delle seguenti politiche AWS gestite al ruolo: **AWSCodeDeployRoleForECS** oppure**AWSCodeDeployRoleForECSLimited**. Per informazioni su queste politiche e su come aggiungerle al ruolo di CodeDeploy servizio, consulta[Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).
## La distribuzione è scaduta in attesa di una richiamata dello stato
**Problema**: viene visualizzato il seguente messaggio di errore durante la distribuzione dell'applicazione Amazon ECS utilizzando: CodeDeploy
`The deployment timed out while waiting for a status callback. CodeDeploy expects a status callback within one hour after a deployment hook is invoked.`
**Possibile causa**: questo errore potrebbe verificarsi se hai specificato una funzione Lambda nella [`Hooks`sezione del AppSpec file](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs), ma la funzione Lambda non è in grado di chiamare l'`PutLifecycleEventHookExecutionStatus`API necessaria per restituire uno `Succeeded` stato or. `Failed` CodeDeploy
**Possibili correzioni e passaggi successivi**:
+ Aggiungi l'`codedeploy:putlifecycleEventHookExecutionStatus`autorizzazione al ruolo di esecuzione Lambda utilizzato dalla funzione Lambda che hai specificato nel file. AppSpec Questa autorizzazione concede alla funzione Lambda la possibilità di restituire uno stato `Succeeded` di `Failed` o a. CodeDeploy *Per ulteriori informazioni sul ruolo di esecuzione Lambda, consulta Ruolo di esecuzione [Lambda nella Guida per l'](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html)utente.AWS Lambda *
+ Controlla il codice della funzione Lambda e i log di esecuzione per assicurarti che la funzione Lambda stia chiamando l'`PutLifecycleEventHookExecutionStatus`API per CodeDeploy sapere se il test di convalida CodeDeploy del ciclo di vita è o meno. `Succeeded` `Failed` *Per informazioni sull'API, consulta l'`putlifecycleEventHookExecutionStatus`API Reference. [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)AWS CodeDeploy * Per informazioni sui log di esecuzione Lambda, consulta Accedere ai log di [Amazon CloudWatch ](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) per. AWS Lambda
## L'implementazione non è riuscita perché una o più funzioni di convalida degli eventi del ciclo di vita non sono riuscite
**Problema**: viene visualizzato il seguente messaggio di errore durante la distribuzione dell'applicazione Amazon ECS utilizzando: CodeDeploy
`The deployment failed because one or more of the lifecycle event validation functions failed.`
**Causa possibile**: questo errore potrebbe verificarsi se hai specificato una funzione Lambda nella [`Hooks`sezione del AppSpec file](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs), ma la funzione Lambda è tornata `Failed` a CodeDeploy quando è stata chiamata. `PutLifecycleEventHookExecutionStatus` Questo errore indica CodeDeploy che il test di convalida del ciclo di vita non è riuscito.
**Possibile passaggio successivo**: controlla i log di esecuzione di Lambda per scoprire perché il codice del test di convalida non funziona. Per informazioni sui log di esecuzione Lambda, consulta Accedere ai log di [Amazon CloudWatch ](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) per. AWS Lambda
## L'ELB non può essere aggiornato a causa del seguente errore: Il gruppo target del taskset primario deve essere dietro il listener
**Problema**: viene visualizzato il seguente messaggio di errore durante la distribuzione dell'applicazione Amazon ECS utilizzando: CodeDeploy
`The ELB could not be updated due to the following error: Primary taskset target group must be behind listener`
**Possibile causa**: questo errore può verificarsi se hai configurato un listener di test opzionale e questo è configurato con un gruppo target errato. Per ulteriori informazioni sul test listener in CodeDeploy, vedere [Prima di iniziare una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-prerequisites-ecs) e. [Cosa succede durante una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-what-happens) Per ulteriori informazioni sui set di attività, consulta il *riferimento [TaskSet](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TaskSet.html)all'API di Amazon Elastic Container Service* e [describe-task-set](https://docs.aws.amazon.com/cli/latest/reference/ecs/describe-task-set.html)la sezione Amazon ECS del *AWS CLI Command Reference*.
**Possibile soluzione**: assicurati che il listener di produzione e il listener di test di Elastic Load Balancing puntino entrambi al gruppo target che attualmente serve i tuoi carichi di lavoro. Esistono tre punti da controllare:
+ In Amazon EC2, nelle impostazioni dei **listener** e delle regole del sistema di bilanciamento del carico. *Per ulteriori informazioni, consulta [Listeners for your Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html) nella *User Guide for Application Load Balancers o Listeners for your Network Load Balancers* [nella User Guide for Network Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-listeners.html).*
+ In Amazon ECS, nel tuo cluster, nella configurazione di **rete** del tuo servizio. Per ulteriori informazioni, consulta le considerazioni su [Application Load Balancer e Network Load Balancer](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/load-balancer-types.html#alb-considerations) nella *Amazon Elastic Container Service Developer* Guide.
+ In CodeDeploy, nelle impostazioni del gruppo di distribuzione. Per ulteriori informazioni, consulta [Crea un gruppo di distribuzione per una distribuzione Amazon ECS (console)](deployment-groups-create-ecs.md).
## La mia implementazione a volte fallisce quando utilizzo Auto Scaling
**Problema**: state utilizzando Auto Scaling con CodeDeploy e notate che le vostre implementazioni a volte falliscono. Per ulteriori informazioni sui sintomi di questo problema, consulta l'argomento «[Per i servizi configurati per utilizzare il service auto scaling e il tipo di blue/green distribuzione, l'auto scaling non è bloccato durante una distribuzione ma la distribuzione potrebbe non riuscire in alcune circostanze](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html#deployment-type-bluegreen-considerations)» nella *Amazon Elastic Container Service* Developer Guide.
**Possibile causa**: questo problema potrebbe verificarsi in caso di conflitto tra CodeDeploy i processi di Auto Scaling.
**Possibile correzione**: sospendere e riprendere i processi di Auto Scaling durante la distribuzione utilizzando CodeDeploy l'API (o `RegisterScalableTarget` il `register-scalable-target` AWS CLI comando corrispondente). Per ulteriori informazioni, vedere [Suspend and resume scaling for Application Auto Scaling nella Application Auto](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-suspend-resume-scaling.html) Scaling User *Guide*.
**Nota**
CodeDeploy non posso chiamare direttamente. `RegisterScaleableTarget` Per utilizzare questa API, devi configurare CodeDeploy l'invio di una notifica o di un evento ad Amazon Simple Notification Service (o Amazon CloudWatch). È quindi necessario configurare Amazon SNS (or CloudWatch) per chiamare una funzione Lambda e configurare la funzione Lambda per chiamare l'API. `RegisterScalableTarget` L'`RegisterScalableTarget`API deve essere chiamata con il `SuspendedState` parametro impostato su per `true` sospendere le operazioni di Auto Scaling `false` e per riprenderle.
La notifica o l'evento CodeDeploy inviato deve verificarsi all'avvio di una distribuzione (per attivare le operazioni di sospensione di Auto Scaling) o quando una distribuzione ha esito positivo, fallisce o si interrompe (per attivare le operazioni di ripristino di Auto Scaling).
Per informazioni su come configurare la generazione CodeDeploy di notifiche o CloudWatch eventi Amazon SNS, consulta. e[Monitoraggio delle distribuzioni con Amazon Events CloudWatch](monitoring-cloudwatch-events.md). [Monitoraggio delle distribuzioni con le notifiche degli eventi di Amazon SNS](monitoring-sns-event-notifications.md)
## Solo ALB supporta il routing graduale del traffico, utilizza invece il routing AllAtOnce del traffico quando utilizzi il gruppo Deployment create/update
**Problema**: durante la creazione o l'aggiornamento di un gruppo di distribuzione viene visualizzato il seguente messaggio di errore in: CodeDeploy
`Only ALB supports gradual traffic routing, use AllAtOnce Traffic routing instead when you create/update Deployment group.`
**Causa possibile**: questo errore potrebbe verificarsi se si utilizza un Network Load Balancer e si tenta di utilizzare una configurazione di distribuzione predefinita diversa da. `CodeDeployDefault.ECSAllAtOnce`
**Possibili soluzioni.**
+ Modifica la configurazione di distribuzione predefinita in. `CodeDeployDefault.ECSAllAtOnce` Questa è l'unica configurazione di distribuzione predefinita supportata da Network Load Balancers.
Per ulteriori informazioni sulle configurazioni di distribuzione predefinite, vedere. [Configurazioni di distribuzione predefinite per una piattaforma di calcolo Amazon ECS](deployment-configurations.md#deployment-configurations-predefined-ecs)
+ Cambia il tuo load balancer in un Application Load Balancer. Gli Application Load Balancer supportano tutte le configurazioni di distribuzione predefinite. Per ulteriori informazioni sulla creazione di un Application Load Balancer, vedere. [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)
## Anche se la mia implementazione è riuscita, il set di attività sostitutivo non supera i controlli di integrità di Elastic Load Balancing e la mia applicazione è inattiva
**Problema**: anche se CodeDeploy indica che la mia distribuzione è riuscita, il set di attività sostitutivo non supera i controlli di integrità di Elastic Load Balancing e la mia applicazione è inattiva.
**Possibile causa**: questo problema potrebbe verificarsi se hai eseguito una CodeDeploy all-at-once distribuzione e il set di attività sostitutivo (verde) contiene codice errato che causa il fallimento dei controlli di integrità di Elastic Load Balancing. Con la configurazione di all-at-once distribuzione, i controlli di integrità del load balancer iniziano a essere eseguiti sul set di attività sostitutivo *dopo* che il traffico è stato spostato su di esso (ovvero, *dopo* che si verifica l'evento CodeDeploy del `AllowTraffic` ciclo di vita). Ecco perché, dopo lo spostamento del traffico, i controlli dello stato di salute dell'operazione sostitutiva impostata non funzioneranno, ma non prima. Per informazioni sugli eventi del ciclo di vita generati, consulta. CodeDeploy [Cosa succede durante una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-what-happens)
**Possibili soluzioni.**
+ Modificate la configurazione di distribuzione da canaria all-at-once a lineare. *In una configurazione canaria o lineare, i controlli di integrità del sistema di bilanciamento del carico iniziano a essere eseguiti sul set di attività sostitutivo durante l' CodeDeploy installazione dell'applicazione nell'ambiente sostitutivo e *prima che il traffico venga* spostato (ovvero durante l'evento del `Install` ciclo di vita e prima dell'evento).* `AllowTraffic` Consentendo l'esecuzione dei controlli durante l'installazione dell'applicazione ma prima che il traffico venga spostato, verrà rilevato un codice applicativo errato che causerà errori di distribuzione prima che l'applicazione diventi disponibile al pubblico.
Per informazioni su come configurare le distribuzioni canarie o lineari, vedere. [Modifica le impostazioni del gruppo di distribuzione con CodeDeploy](deployment-groups-edit.md)
Per informazioni sugli eventi CodeDeploy del ciclo di vita che si verificano durante una distribuzione Amazon ECS, consulta. [Cosa succede durante una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-what-happens)
**Nota**
Le configurazioni di distribuzione canarie e lineari sono supportate solo con Application Load Balancers.
+ Se desideri mantenere la configurazione di all-at-once distribuzione, configura un listener di test e controlla lo stato di integrità del set di attività sostitutivo con il lifecycle hook. `BeforeAllowTraffic` Per ulteriori informazioni, consulta [Elenco di eventi del ciclo di vita per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs).
## Posso collegare più sistemi di bilanciamento del carico a un gruppo di distribuzione?
No. Se desideri utilizzare più Application Load Balancer o Network Load Balancer, utilizza gli aggiornamenti periodici di Amazon ECS anziché le distribuzioni blu/verdi. CodeDeploy Per ulteriori informazioni sugli aggiornamenti periodici, consulta [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/userguide/deployment-type-ecs.html) nella *Amazon Elastic Container Service Developer Guide*. Per ulteriori informazioni sull'utilizzo di più sistemi di bilanciamento del carico con Amazon ECS, consulta [Registrazione di più gruppi target con un servizio nella](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html) *Amazon Elastic Container* Service Developer Guide.
## Posso eseguire distribuzioni CodeDeploy blu/verdi senza un sistema di bilanciamento del carico?
No, non è possibile eseguire distribuzioni CodeDeploy blu/verdi senza un sistema di bilanciamento del carico. Se non riesci a utilizzare un sistema di bilanciamento del carico, utilizza invece la funzionalità di aggiornamento progressivo di Amazon ECS. Per ulteriori informazioni sugli aggiornamenti progressivi di Amazon ECS, consulta [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/userguide/deployment-type-ecs.html) nella *Amazon Elastic Container Service Developer Guide*.
## Come posso aggiornare il mio servizio Amazon ECS con nuove informazioni durante una distribuzione?
Per fare in modo che il servizio Amazon ECS venga CodeDeploy aggiornato con un nuovo parametro mentre esegue una distribuzione, specifica il parametro nella `resources` sezione del AppSpec file. Sono supportati solo alcuni parametri di Amazon ECS CodeDeploy, come i parametri del file di definizione delle attività e del nome del contenitore. Per un elenco completo dei parametri Amazon ECS che CodeDeploy possono essere aggiornati, consulta[AppSpec sezione «risorse» per le distribuzioni di Amazon ECS](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs).
**Nota**
Se devi aggiornare il tuo servizio Amazon ECS con un parametro non supportato da CodeDeploy, completa queste attività:
Chiama l'`UpdateService`API di Amazon ECS con il parametro che desideri aggiornare. Per un elenco completo dei parametri che possono essere aggiornati, consulta [UpdateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_UpdateService.html)*Amazon Elastic Container Service API Reference*.
Per applicare la modifica alle attività, crea una nuova blue/green distribuzione Amazon ECS. Per ulteriori informazioni, consulta [Crea un'implementazione di Amazon ECS Compute Platform (console)](deployments-create-console-ecs.md).
# Risolvi i problemi di implementazione di Lambda AWS
**Topics**
+ [AWS Lambda le distribuzioni falliscono dopo l'interruzione manuale di una distribuzione Lambda che non dispone di rollback configurati](#troubleshooting-manually-stopped-lambda-deployment)
## AWS Lambda le distribuzioni falliscono dopo l'interruzione manuale di una distribuzione Lambda che non dispone di rollback configurati
In alcuni casi, l'alias di una funzione Lambda specificato in una distribuzione potrebbe fare riferimento a due diverse versioni della funzione. Il risultato è che i tentativi successivi di implementare la funzione Lambda falliscono. Una distribuzione Lambda può entrare in questo stato quando non ha i rollback configurati e viene interrotta manualmente. Per procedere, usa la AWS Lambda console per assicurarti che la funzione non sia configurata per spostare il traffico tra due versioni:
1. Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di sinistra scegliere **Functions (Funzioni)**.
1. Seleziona il nome della funzione Lambda presente nella tua CodeDeploy distribuzione.
1. **Da **Alias**, scegli l'alias utilizzato nella CodeDeploy distribuzione, quindi scegli Modifica.**
1. Da **Alias ponderato, scegli**. **none** In questo modo si garantisce che l'alias non sia configurato per spostare una percentuale, o ponderazione, di traffico in più di una versione. Annotare la versione selezionata in **Versione**.
1. Scegli **Save** (Salva).
1. Apri la CodeDeploy console e prova a distribuire la versione visualizzata nel menu a discesa nel passaggio 5.
# Risoluzione dei problemi relativi ai gruppi di distribuzione
## Il tagging di un'istanza come parte di un gruppo di distribuzione non comporta automaticamente la distribuzione dell'applicazione nella nuova istanza
CodeDeploy non distribuisce automaticamente l'applicazione su un'istanza con nuovi tag. È necessario creare una nuova distribuzione nel gruppo di distribuzione.
Puoi utilizzarlo CodeDeploy per abilitare le distribuzioni automatiche su nuove istanze EC2 nei gruppi Amazon EC2 Auto Scaling. Per ulteriori informazioni, consulta [Integrazione CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
# Risoluzione dei problemi relativi alle istanze
**Topics**
+ [I tag devono essere impostati correttamente](#troubleshooting-EC2-tags)
+ [AWS CodeDeploy l'agente deve essere installato e in esecuzione sulle istanze](#troubleshooting-sds-agent)
+ [Quando un'istanza viene terminata durante una distribuzione, la distribuzione continua senza errori per un'ora](#troubleshooting-one-hour-timeout)
+ [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](#troubleshooting-deploy-failures)
+ [Crea un nuovo file di CodeDeploy registro se è stato eliminato accidentalmente](#troubleshooting-create-new-log-file)
+ [Risoluzione degli errori di distribuzione «InvalidSignatureException — Firma scaduta: [ora] è precedente a [ora]»](#troubleshooting-instance-time-failures)
## I tag devono essere impostati correttamente
Utilizza il comando [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) per verificare che le istanze utilizzate per una distribuzione siano contrassegnate correttamente. Se nell'output manca un'istanza EC2, utilizza la console EC2 per confermare che i tag sono stati impostati sull'istanza. Per ulteriori informazioni, consulta [Lavorare con i tag nella console](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console) nella Guida per l'*utente di Amazon EC2*.
**Nota**
Se tagghi un'istanza e la utilizzi immediatamente CodeDeploy per distribuirvi un'applicazione, l'istanza potrebbe non essere inclusa nella distribuzione. Questo perché possono essere necessari diversi minuti prima di CodeDeploy poter leggere i tag. Consigliamo di attendere almeno cinque minuti prima di provare a eseguire la distribuzione in un'istanza dopo averla contrassegnata.
## AWS CodeDeploy l'agente deve essere installato e in esecuzione sulle istanze
Per verificare che l' CodeDeploy agente sia installato e in esecuzione su un'istanza, vedere[Verifica che l' CodeDeploy agente sia in esecuzione](codedeploy-agent-operations-verify.md).
Per installare, disinstallare o reinstallare l' CodeDeploy agente, consulta[Installa l' CodeDeploy agente](codedeploy-agent-operations-install.md).
## Quando un'istanza viene terminata durante una distribuzione, la distribuzione continua senza errori per un'ora
CodeDeploy offre una finestra di un'ora per il completamento di ogni evento del ciclo di vita della distribuzione. Ciò consente ampio margine per l'esecuzione di script di lunga durata.
Se gli script non vengono eseguiti fino al completamento mentre è in corso un evento del ciclo di vita (ad esempio, se un'istanza viene terminata o l' CodeDeploy agente viene chiuso), potrebbe essere necessaria fino a un'ora prima che lo stato della distribuzione venga visualizzato come Non riuscito. Ciò accade anche se il periodo di timeout specificato nello script è inferiore a un'ora. Questo perché quando l'istanza viene terminata, l' CodeDeploy agente si spegne e non può elaborare altri script.
Se invece un'istanza viene terminata tra un evento e l'altro del ciclo di vita, o prima che inizi la prima fase dell'evento del ciclo di vita, il timeout si verifica dopo soli cinque minuti.
## Analisi dei file di log per individuare gli errori di distribuzione nelle istanze
Se lo stato di un'istanza nella distribuzione è diverso da `Succeeded`, è possibile esaminare i dati del file di log di distribuzione per identificare il problema. Per informazioni su come accedere ai dati del log di distribuzione, consulta [Visualizzazione dei dati di registro per le distribuzioni CodeDeploy EC2/on-premise](deployments-view-logs.md).
## Crea un nuovo file di CodeDeploy registro se è stato eliminato accidentalmente
Se si elimina accidentalmente il file di registro di distribuzione su un'istanza, CodeDeploy non crea un file di registro sostitutivo. Per creare un nuovo file di log, effettua l'accesso all'istanza ed esegui i comandi illustrati di seguito:
**Per un'istanza Amazon Linux, Ubuntu Server o RHEL**, esegui questi comandi in questo ordine, uno alla volta:
```
systemctl stop codedeploy-agent
```
```
systemctl start codedeploy-agent
```
**Per un'istanza di Windows Server**:
```
powershell.exe -Command Restart-Service -Name codedeployagent
```
## Risoluzione degli errori di distribuzione «InvalidSignatureException — Firma scaduta: [ora] è precedente a [ora]»
CodeDeploy richiede riferimenti temporali accurati per eseguire le sue operazioni. Se la data e l'ora sull'istanza non sono impostate correttamente, potrebbero non corrispondere alla data di firma della richiesta di distribuzione, che viene CodeDeploy respinta.
Per evitare errori di distribuzione dovuti a impostazioni errate di data e ora, consulta i seguenti argomenti:
+ [Impostazione dell'orario di un'istanza Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/set-time.html)
+ [Impostazione dell'orario di un'istanza Windows](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/windows-set-time.html)
# Risolvi i problemi relativi GitHub ai token
## Token non valido GitHub OAuth
CodeDeploy le applicazioni create dopo giugno 2017 utilizzano GitHub OAuth token per ogni AWS regione. L'uso di token legati a AWS regioni specifiche offre un maggiore controllo su quali CodeDeploy applicazioni hanno accesso a un GitHub repository.
Se ricevi un errore relativo al GitHub token, potresti avere un token più vecchio che ora non è valido.
**Per correggere un token non valido GitHub OAuth **
1. Rimuovi il vecchio token utilizzando uno dei seguenti metodi:
+ Per rimuovere il vecchio token utilizzando l'API, usa [ DeleteGitHubAccountToken](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_DeleteGitHubAccountToken.html).
+ Per rimuovere il vecchio token utilizzando AWS Command Line Interface:
1. Vai al computer in cui si trova il token.
1. Assicurati che AWS CLI sia installato su questo computer. Per le istruzioni di installazione, vedere [Installazione, aggiornamento e disinstallazione di AWS CLI nella](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) Guida per l'*AWS Command Line Interface utente*
1. Immettete il seguente comando sul computer in cui risiede il token:
**aws delete-git-hub-account-token**
[Per i dettagli sulla sintassi del comando, vedi delete-git-hub-account -token.](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-git-hub-account-token.html)
1. Aggiungi un nuovo OAuth token. Per ulteriori informazioni, consulta [Integrazione con CodeDeploy GitHub](integrations-partners-github.md).
## È stato superato il numero massimo di GitHub OAuth token
Quando si crea una CodeDeploy distribuzione, il numero massimo di GitHub token consentiti è 10. Se ricevi un errore relativo ai GitHub OAuth token, assicurati di avere 10 token o meno. In presenza di più di 10 token, i primi token creati non sono validi. Ad esempio, se hai 11 token, il primo token creato non è valido. Se hai 12 token, i primi due token creati non sono validi. Per informazioni sull'utilizzo dell' CodeDeploy API per rimuovere i vecchi token, consulta. [ DeleteGitHubAccountToken](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_DeleteGitHubAccountToken.html)
# Risolvi i problemi relativi ad Amazon EC2 Auto Scaling
**Topics**
+ [Risoluzione dei problemi generali di Amazon EC2 Auto Scaling](#troubleshooting-auto-scaling-general)
+ ["CodeDeployRole non ti dà il permesso di eseguire operazioni nel seguente AWS servizio: AmazonAutoScaling" error](#troubleshooting-auto-scaling-permissions-error)
+ [Le istanze in un gruppo Amazon EC2 Auto Scaling vengono continuamente fornite e terminate prima di poter implementare una revisione](#troubleshooting-auto-scaling-provision-termination-loop)
+ [L'interruzione o il riavvio di un'istanza di Amazon EC2 Auto Scaling potrebbe causare il fallimento delle distribuzioni](#troubleshooting-auto-scaling-reboot)
+ [Evita di associare più gruppi di distribuzione a un singolo gruppo Amazon EC2 Auto Scaling](#troubleshooting-multiple-depgroups)
+ [Le istanze EC2 in un gruppo Amazon EC2 Auto Scaling non vengono avviate e ricevono l'errore «Heartbeat Timeout»](#troubleshooting-auto-scaling-heartbeat)
+ [I collegamenti non corrispondenti al ciclo di vita di Amazon EC2 Auto Scaling potrebbero causare l'interruzione o il fallimento delle distribuzioni automatiche nei gruppi di Amazon EC2 Auto Scaling](#troubleshooting-auto-scaling-hooks)
+ [Errore «La distribuzione non è riuscita perché non è stata trovata alcuna istanza per il tuo gruppo di distribuzione»](#troubleshooting-deployment-failed-because-no-instances-found)
## Risoluzione dei problemi generali di Amazon EC2 Auto Scaling
Le distribuzioni su istanze EC2 in un gruppo Amazon EC2 Auto Scaling possono fallire per i seguenti motivi:
+ **Amazon EC2 Auto Scaling avvia e chiude continuamente le istanze EC2.** Se CodeDeploy non è possibile distribuire automaticamente la revisione dell'applicazione, Amazon EC2 Auto Scaling avvia e termina continuamente le istanze EC2.
Dissocia il gruppo Amazon EC2 Auto Scaling dal gruppo di distribuzione o modifica CodeDeploy la configurazione del gruppo Amazon EC2 Auto Scaling in modo che il numero desiderato di istanze corrisponda al numero attuale di istanze (impedendo così ad Amazon EC2 Auto Scaling di lanciare altre istanze EC2). Per ulteriori informazioni, consulta [Modifica le impostazioni del gruppo di distribuzione con CodeDeploy](deployment-groups-edit.md) la sezione [Manual Scaling for Amazon EC2](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-manual-scaling.html) Auto Scaling.
+ **L' CodeDeploy agente non risponde.** L' CodeDeploy agente potrebbe non essere installato se gli script di inizializzazione (ad esempio, gli script cloud-init) eseguiti immediatamente dopo l'avvio o l'avvio di un'istanza EC2 impiegano più di un'ora per essere eseguiti. CodeDeploy dispone di un timeout di un'ora per consentire all'agente di rispondere alle distribuzioni in sospeso. CodeDeploy Per risolvere il problema, sposta gli script di inizializzazione nella revisione dell'applicazione CodeDeploy.
+ **Un'istanza EC2 in un gruppo Amazon EC2 Auto Scaling si riavvia durante una distribuzione.** L'implementazione può fallire se un'istanza EC2 viene riavviata durante una distribuzione o se l' CodeDeploy agente viene spento durante l'elaborazione di un comando di distribuzione. Per ulteriori informazioni, consulta [L'interruzione o il riavvio di un'istanza di Amazon EC2 Auto Scaling potrebbe causare il fallimento delle distribuzioni](#troubleshooting-auto-scaling-reboot).
+ **Più revisioni delle applicazioni vengono distribuite contemporaneamente sulla stessa istanza EC2 in un gruppo Amazon EC2 Auto Scaling.** La distribuzione contemporanea di più revisioni di applicazioni sulla stessa istanza EC2 in un gruppo Amazon EC2 Auto Scaling può fallire se una delle distribuzioni ha script che vengono eseguiti per più di qualche minuto. Non distribuire più revisioni di applicazioni sulle stesse istanze EC2 in un gruppo Amazon EC2 Auto Scaling.
+ **Una distribuzione non riesce per le nuove istanze EC2 lanciate come parte di un gruppo Amazon EC2 Auto Scaling.** In questo scenario, l'esecuzione degli script in una distribuzione può impedire il lancio di istanze EC2 nel gruppo Amazon EC2 Auto Scaling. (È possibile che altre istanze EC2 nel gruppo Amazon EC2 Auto Scaling funzionino normalmente.) Per risolvere questo problema, assicurati che tutti gli altri script vengano completati per primi:
+ **CodeDeploy l'agente non è incluso nell'AMI**: se usi il **cfn-init** comando per installare l' CodeDeploy agente mentre avvii una nuova istanza, posiziona lo script di installazione dell'agente alla fine della `cfn-init` sezione del CloudFormation modello.
+ **CodeDeploy l'agente è incluso nell'AMI**: configura l'AMI in modo che l'agente si trovi in uno `Stopped` stato al momento della creazione dell'istanza, quindi includi uno script per l'avvio dell'agente come passaggio finale nella tua libreria di `cfn-init` script.
## "CodeDeployRole non ti dà il permesso di eseguire operazioni nel seguente AWS servizio: AmazonAutoScaling" error
Le distribuzioni che utilizzano un gruppo Auto Scaling creato con un modello di avvio richiedono le seguenti autorizzazioni. Queste si aggiungono alle autorizzazioni concesse dalla politica gestita. `AWSCodeDeployRole` AWS
+ `EC2:RunInstances`
+ `EC2:CreateTags`
+ `iam:PassRole`
Potresti ricevere questo errore se non disponi di queste autorizzazioni. Per ulteriori informazioni[Tutorial: CodeDeploy Da utilizzare per distribuire un'applicazione in un gruppo di Auto Scaling](tutorials-auto-scaling-group.md), consulta [Creazione di un modello di lancio per un gruppo di Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html) e [Autorizzazioni](https://docs.aws.amazon.com/autoscaling/ec2/userguide/launch-templates.html#launch-templates-permissions) nella Guida per l'utente di *Amazon EC2 Auto Scaling*.
## Le istanze in un gruppo Amazon EC2 Auto Scaling vengono continuamente fornite e terminate prima di poter implementare una revisione
In alcuni casi, un errore può impedire una corretta implementazione su nuove istanze di cui è stato effettuato il provisioning in un gruppo Amazon EC2 Auto Scaling. Ciò compromette la riuscita delle distribuzioni e l'integrità delle istanze. Poiché non è possibile eseguire o completare la distribuzione, le istanze vengono terminate subito dopo essere state create. La configurazione del gruppo Amazon EC2 Auto Scaling determina quindi il provisioning di un altro batch di istanze per cercare di soddisfare il requisito minimo di host integri. Anche questo batch viene terminato e il ciclo continua.
Tra le cause possibili sono incluse:
+ Controlli di integrità del gruppo Amazon EC2 Auto Scaling non riusciti.
+ Un errore nella revisione dell'applicazione.
Per risolvere il problema, esegui queste fasi:
1. Crea manualmente un'istanza EC2 che non fa parte del gruppo Amazon EC2 Auto Scaling. Contrassegna l'istanza con un tag di istanza EC2 univoco.
1. Aggiungi la nuova istanza al gruppo di distribuzione interessato.
1. Distribuisci una nuova revisione dell'applicazione senza errori nel gruppo di distribuzione.
Ciò richiede al gruppo Amazon EC2 Auto Scaling di distribuire la revisione dell'applicazione su istanze future nel gruppo Amazon EC2 Auto Scaling.
**Nota**
Dopo aver confermato che le distribuzioni hanno avuto esito positivo, elimina l'istanza che hai creato per evitare addebiti continui sul tuo account. AWS
## L'interruzione o il riavvio di un'istanza di Amazon EC2 Auto Scaling potrebbe causare il fallimento delle distribuzioni
Se un'istanza EC2 viene avviata tramite Amazon EC2 Auto Scaling e l'istanza viene quindi terminata o riavviata, le distribuzioni su quell'istanza potrebbero non riuscire per i seguenti motivi:
+ Durante una distribuzione in corso, un evento di scalabilità in entrata o qualsiasi altro evento di terminazione causa il distacco dell'istanza dal gruppo Amazon EC2 Auto Scaling e quindi la sua chiusura. Poiché la distribuzione non può essere completata, ha esito negativo.
+ L'istanza viene riavviata, ma l'avvio richiede più di cinque minuti. CodeDeploy considera questo come un timeout. Il servizio non è quindi in grado di completare nessuna distribuzione, corrente o futura, nell'istanza.
Per risolvere questo problema:
+ In generale, accertati che tutte le distribuzioni siano state completate prima che l'istanza venga terminata o riavviata. Assicurati che tutte le distribuzioni vengano avviate dopo l'avvio o il riavvio dell'istanza.
+ Le distribuzioni possono avere esito negativo se si specifica un'Amazon Machine Image (AMI) basata su Windows Server per una configurazione Amazon EC2 Auto Scaling e si utilizza il servizio EC2 Config per impostare il nome del computer dell'istanza. Per risolvere questo problema, nell'AMI di base di Windows Server, nella scheda **Generale** delle **proprietà del servizio EC2**, deseleziona **Imposta nome computer**. Dopo aver deselezionato questa casella di controllo, questo comportamento viene disabilitato per tutte le nuove istanze di Windows Server Amazon EC2 Auto Scaling avviate con quell'AMI di base di Windows Server. Per le istanze Windows Server Amazon EC2 Auto Scaling su cui questo comportamento è abilitato, non è necessario deselezionare questa casella di controllo. È sufficiente ridistribuire nelle istanze le distribuzioni non riuscite dopo averle riavviate.
## Evita di associare più gruppi di distribuzione a un singolo gruppo Amazon EC2 Auto Scaling
Come best practice, dovresti associare un solo gruppo di distribuzione a ciascun gruppo Amazon EC2 Auto Scaling.
Questo perché se Amazon EC2 Auto Scaling ridimensiona un'istanza con hook associati a più gruppi di distribuzione, invia notifiche per tutti gli hook contemporaneamente. In questo modo per ogni istanza vengono avviate più distribuzioni nello stesso momento. Quando più distribuzioni inviano comandi all' CodeDeploy agente contemporaneamente, è possibile che venga raggiunto il timeout di cinque minuti tra un evento del ciclo di vita e l'inizio della distribuzione o la fine dell'evento del ciclo di vita precedente. In questo caso, la distribuzione ha esito negativo, anche se un processo di distribuzione è in esecuzione come previsto.
**Nota**
Il timeout predefinito per uno script in un evento del ciclo di vita è di 30 minuti. È possibile modificare il timeout impostando un valore diverso nel file. AppSpec Per ulteriori informazioni, consulta [Aggiungi un AppSpec file per una distribuzione EC2/on-premise](application-revisions-appspec-file.md#add-appspec-file-server).
Non è possibile controllare l'ordine con il quale le distribuzioni si verificano, se si prova a eseguire più distribuzioni contemporaneamente.
Infine, se la distribuzione su un'istanza fallisce, Amazon EC2 Auto Scaling interrompe immediatamente l'istanza. Quando la prima istanza si arresta, le altre distribuzioni in esecuzione iniziano a restituire errori. Poiché CodeDeploy prevede un timeout di un'ora prima che l' CodeDeploy agente risponda alle distribuzioni in sospeso, il timeout di ogni istanza può richiedere fino a 60 minuti.
Per ulteriori informazioni su Amazon EC2 Auto Scaling[, consulta Under the CodeDeploy hood: and Auto Scaling](https://aws.amazon.com/blogs/devops/under-the-hood-aws-codedeploy-and-auto-scaling-integration/) integration.
## Le istanze EC2 in un gruppo Amazon EC2 Auto Scaling non vengono avviate e ricevono l'errore «Heartbeat Timeout»
Un gruppo Amazon EC2 Auto Scaling potrebbe non riuscire a lanciare nuove istanze EC2, generando un messaggio simile al seguente:
`Launching a new EC2 instance . Status Reason: Instance failed to complete user's Lifecycle Action: Lifecycle Action with token was abandoned: Heartbeat Timeout`.
Il messaggio generalmente indica di procedere in uno dei seguenti modi:
+ È stato raggiunto il numero massimo di implementazioni simultanee associate a un account. AWS Per ulteriori informazioni sui limiti di distribuzione, consulta [CodeDeploy quote](limits.md).
+ Il gruppo Auto Scaling ha cercato di avviare troppe istanze EC2 troppo velocemente. Le chiamate API verso [RecordLifecycleActionHeartbeat](https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_RecordLifecycleActionHeartbeat.html)o [CompleteLifecycleAction](https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_CompleteLifecycleAction.html)per ogni nuova istanza sono state limitate.
+ Un'applicazione in CodeDeploy è stata eliminata prima dell'aggiornamento o dell'eliminazione dei gruppi di distribuzione associati.
Quando elimini un'applicazione o un gruppo di distribuzione, CodeDeploy tenta di ripulire tutti gli hook Amazon EC2 Auto Scaling ad esso associati, ma alcuni hook potrebbero rimanere. Se esegui un comando per eliminare un gruppo di distribuzione, gli hook rimanenti vengono restituiti nell'output. Tuttavia, se esegui un comando per eliminare un'applicazione, gli hook rimanenti non vengono visualizzati nell'output.
Pertanto, come best practice, è opportuno eliminare tutti i gruppi di distribuzione associati a un'applicazione prima di eliminare l'applicazione. È possibile utilizzare l'output del comando per identificare gli hook del ciclo di vita che devono essere eliminati manualmente.
Se ricevi il messaggio di errore "Heartbeat Timeout", puoi determinare se il problema dipende da hook del ciclo di vita non eliminati e risolverlo eseguendo le operazioni seguenti:
1. Esegui una delle seguenti operazioni:
+ Chiamate il [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando per eliminare il gruppo di distribuzione associato al gruppo Auto Scaling che causa il timeout dell'heartbeat.
+ Chiamate il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html)comando con un elenco vuoto non nullo di nomi di gruppi Auto Scaling per scollegare tutti gli hook del ciclo di vita di CodeDeploy Auto Scaling gestiti.
Ad AWS CLI esempio, inserisci il seguente comando:
`aws deploy update-deployment-group --application-name my-example-app --current-deployment-group-name my-deployment-group --auto-scaling-groups`
Come altro esempio, se utilizzi l' CodeDeploy API con Java, chiama `UpdateDeploymentGroup` e imposta `autoScalingGroups` su`new ArrayList()`. Questo imposta `autoScalingGroups` su un elenco vuoto e rimuove l'elenco esistente. Non usare`null`, che è l'impostazione predefinita, perché rimane così com'`autoScalingGroups`è, il che non è quello che vuoi.
Esaminare l'output della chiamata. Se l'output contiene una `hooksNotCleanedUp` struttura con un elenco di hook del ciclo di vita di Amazon EC2 Auto Scaling, ci sono degli hook del ciclo di vita rimanenti.
1. Chiama il [describe-lifecycle-hooks](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-lifecycle-hooks.html)comando, specificando il nome del gruppo Amazon EC2 Auto Scaling associato alle istanze EC2 che non sono state avviate. Nell'output, cerca uno dei seguenti elementi:
+ Nomi degli hook del ciclo di vita di Amazon EC2 Auto Scaling che corrispondono `hooksNotCleanedUp` alla struttura identificata nella fase 1.
+ Nomi degli hook del ciclo di vita di Amazon EC2 Auto Scaling che contengono il nome del gruppo di distribuzione associato al gruppo Auto Scaling che non funziona.
+ Nomi degli hook del ciclo di vita di Amazon EC2 Auto Scaling che potrebbero aver causato il timeout dell'heartbeat per la distribuzione. CodeDeploy
1. Se un hook rientra in una delle categorie elencate nel passaggio 2, chiama il comando per eliminarlo. [delete-lifecycle-hook](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/delete-lifecycle-hook.html) Specificare il gruppo Amazon EC2 Auto Scaling e l'hook del ciclo di vita nella chiamata.
**Importante**
Elimina solo gli hook che causano problemi, come indicato nel passaggio 2. Se elimini gli hook validi, le distribuzioni potrebbero fallire o CodeDeploy potrebbe non essere possibile distribuire le revisioni delle applicazioni su istanze EC2 con scalabilità orizzontale.
1. Chiama il [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html)o con i nomi dei gruppi Auto Scaling desiderati. CodeDeployreinstalla gli hook Auto Scaling con nuovi. UUIDs
**Nota**
Se scolleghi un gruppo Auto Scaling da CodeDeploy un gruppo di distribuzione, tutte le distribuzioni in corso nel gruppo Auto Scaling potrebbero fallire e le nuove istanze EC2 scalate orizzontalmente dal gruppo Auto Scaling non riceveranno le revisioni dell'applicazione da. CodeDeploy Per far funzionare nuovamente Auto Scaling CodeDeploy, dovrai ricollegare il gruppo Auto Scaling al gruppo di distribuzione e chiamarne uno nuovo per iniziare un'implementazione `CreateDeployment` a livello di flotta.
## I collegamenti non corrispondenti al ciclo di vita di Amazon EC2 Auto Scaling potrebbero causare l'interruzione o il fallimento delle distribuzioni automatiche nei gruppi di Amazon EC2 Auto Scaling
Amazon EC2 Auto CodeDeploy Scaling utilizza gli hook del ciclo di vita per determinare quali revisioni delle applicazioni devono essere distribuite su quali istanze EC2 dopo il lancio nei gruppi di Amazon EC2 Auto Scaling. Le distribuzioni automatiche possono interrompersi o fallire se gli hook del ciclo di vita e le informazioni su questi hook non corrispondono esattamente in Amazon EC2 Auto Scaling e. CodeDeploy
Se le distribuzioni in un gruppo Amazon EC2 Auto Scaling falliscono, verifica se i nomi degli hook del ciclo di vita in Amazon EC2 Auto Scaling corrispondono. CodeDeploy In caso contrario, usa queste chiamate di comando. AWS CLI
Innanzitutto, ottieni l'elenco dei nomi degli hook del ciclo di vita sia per il gruppo Amazon EC2 Auto Scaling che per il gruppo di distribuzione:
1. Chiama il [describe-lifecycle-hooks](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-lifecycle-hooks.html)comando, specificando il nome del gruppo Amazon EC2 Auto Scaling associato al gruppo di distribuzione in. CodeDeploy Nell'output, nell'elenco `LifecycleHooks`, annotare ogni valore `LifecycleHookName`.
1. Chiama il [get-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-group.html)comando, specificando il nome del gruppo di distribuzione associato al gruppo Amazon EC2 Auto Scaling. Nell'output, nell'`autoScalingGroups`elenco, trova ogni elemento il cui valore del nome corrisponde al nome del gruppo Amazon EC2 Auto Scaling, quindi prendi nota del `hook` valore corrispondente.
Ora confrontare i due set di nomi di hook del ciclo di vita. Se corrispondono esattamente, carattere per carattere, allora non è il problema. Potresti provare altri passaggi per la risoluzione dei problemi di Amazon EC2 Auto Scaling descritti altrove in questa sezione.
Tuttavia, se i due set di nomi di hook del ciclo di vita non corrispondono esattamente, carattere per carattere, procedere nel seguente modo:
1. Se ci sono nomi di hook del ciclo di vita nell'output del comando **describe-lifecycle-hooks** che non sono anche nell'output del comando **get-deployment-group**, allora procedere nel seguente modo:
1. Per ogni nome del lifecycle hook nell'output del comando, chiama il **describe-lifecycle-hooks** comando. [delete-lifecycle-hook](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/delete-lifecycle-hook.html)
1. Chiama il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html)comando, specificando il nome del gruppo Amazon EC2 Auto Scaling originale. CodeDeploy crea nuovi hook del ciclo di vita sostitutivi nel gruppo Amazon EC2 Auto Scaling e associa i lifecycle hook al gruppo di distribuzione. Le distribuzioni automatiche dovrebbero ora riprendere non appena vengono aggiunte nuove istanze al gruppo Amazon EC2 Auto Scaling.
1. Se ci sono nomi di hook del ciclo di vita nell'output del comando **get-deployment-group** che non sono anche nell'output del comando **describe-lifecycle-hooks**, procedere nel seguente modo:
1. Chiama il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html)comando, ma non specifica il nome del gruppo Amazon EC2 Auto Scaling originale.
1. Richiama nuovamente il **update-deployment-group** comando, ma questa volta specifica il nome del gruppo Amazon EC2 Auto Scaling originale. CodeDeploy ricrea gli hook del ciclo di vita mancanti nel gruppo Amazon EC2 Auto Scaling. Le distribuzioni automatiche dovrebbero ora riprendere non appena vengono aggiunte nuove istanze al gruppo Amazon EC2 Auto Scaling.
Una volta che i due set di nomi degli hook del ciclo di vita corrispondono esattamente, carattere per carattere, le revisioni delle applicazioni devono essere nuovamente distribuite, ma solo su nuove istanze man mano che vengono aggiunte al gruppo Amazon EC2 Auto Scaling. Le distribuzioni non avvengono automaticamente su istanze già presenti nel gruppo Amazon EC2 Auto Scaling.
## Errore «La distribuzione non è riuscita perché non è stata trovata alcuna istanza per il tuo gruppo di distribuzione»
Leggi questa sezione se vedi il seguente CodeDeploy errore:
`The deployment failed because no instances were found for your deployment group. Check your deployment group settings to make sure the tags for your EC2 instances or Auto Scaling groups correctly identify the instances you want to deploy to, and then try again.`
Le possibili cause di questo errore sono:
1. Le impostazioni del gruppo di distribuzione includono tag per le istanze EC2, le istanze locali o i gruppi di Auto Scaling che non sono corretti. Per risolvere questo problema, verifica che i tag siano corretti, quindi ridistribuisci l'applicazione.
1. La tua flotta si è ridimensionata dopo l'inizio dell'implementazione. In questo scenario, vengono visualizzate istanze integre nello `InService` stato del parco macchine, ma viene visualizzato anche l'errore riportato sopra. Per risolvere questo problema, ridistribuisci l'applicazione.
1. Il gruppo Auto Scaling non include alcuna istanza presente nello stato. `InService` In questo scenario, quando si tenta di eseguire una distribuzione su tutto il parco macchine, la distribuzione non riesce a causa del messaggio di errore riportato sopra, poiché è CodeDeploy necessaria almeno un'istanza nello stato. `InService` Esistono molte ragioni per cui potresti non avere istanze nello stato. `InService` Alcuni di essi includono:
+ Hai pianificato (o configurato manualmente) la dimensione del gruppo Auto Scaling in modo che sia. `0`
+ Auto Scaling ha rilevato istanze EC2 danneggiate (ad esempio, le istanze EC2 presentavano guasti hardware), quindi le ha annullate tutte, lasciandone nessuna nello stato. `InService`
+ Durante un evento di scalabilità orizzontale da `0` a`1`, CodeDeploy ha implementato una revisione precedentemente riuscita (chiamata ultima revisione riuscita) che era diventata *inefficace dopo l'ultima* implementazione. Ciò ha causato il fallimento della distribuzione sull'istanza con scalabilità orizzontale, che a sua volta ha causato l'annullamento dell'istanza da parte di Auto Scaling, senza lasciare alcuna istanza nello stato. `InService`
Se scopri che non ci sono istanze nello `InService` stato, risolvi il problema come descritto nella procedura seguente,. [To troubleshoot the error if there are no instances in the InService state](#ToTroubleshootIfNoInServiceInstances)
**Per risolvere l'errore se non ci sono istanze nello stato InService**
1. Nella console Amazon EC2, verifica l'impostazione della **capacità desiderata**. Se è zero, impostalo su un numero positivo. Attendi che l'istanza sia attiva`InService`, il che significa che la distribuzione è riuscita. Il problema è stato risolto e puoi saltare i passaggi rimanenti di questa procedura di risoluzione dei problemi. Per informazioni sull'impostazione della **capacità desiderata**, consulta [Impostazione dei limiti di capacità sul gruppo Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-capacity-limits.html) nella Guida per l'utente di *Amazon EC2* Auto Scaling.
1. Se Auto Scaling continua a tentare di lanciare nuove istanze EC2 per soddisfare la capacità desiderata ma non riesce mai a soddisfare la scalabilità orizzontale, di solito ciò è dovuto a un guasto del ciclo di vita di Auto Scaling. Risolvi questo problema nel modo seguente:
1. Per verificare quale evento del ciclo di vita di Auto Scaling non va a buon fine, consulta [Verifying a scaling activity for an Auto Scaling group nella Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-verify-scaling-activity.html) User Guide.
1. Se il nome dell'hook fallito è`CodeDeploy-managed-automatic-launch-deployment-hook-DEPLOYMENT_GROUP_NAME`, vai a CodeDeploy, trova il gruppo di distribuzione e trova la distribuzione fallita avviata da Auto Scaling. Quindi esamina il motivo per cui la distribuzione non è riuscita.
1. Se capisci perché la distribuzione non è riuscita (ad esempio, si sono verificati degli CloudWatch allarmi) e puoi risolvere il problema senza modificare la revisione, fallo ora.
1. Se, dopo un'indagine, stabilisci che CodeDeploy *l'ultima revisione corretta* non è più valida e non ci sono istanze integre nel tuo gruppo Auto Scaling, ti trovi in uno scenario di stallo di implementazione. Per risolvere questo problema, è necessario correggere la CodeDeploy revisione errata rimuovendo temporaneamente il lifecycle hook CodeDeploy del ciclo di vita dal gruppo Auto Scaling, quindi reinstallando l'hook e ridistribuendo una nuova (valida) revisione. Per istruzioni, consulta:
+ [To fix the deployment deadlock issue (CLI)](#ToFixDeployDeadlockCLI)
+ [To fix the deployment deadlock issue (console)](#ToFixDeployDeadlockConsole)
**Per risolvere il problema del deadlock della distribuzione (CLI)**
1. (Facoltativo) Blocca CI/CD le pipeline che causano l' CodeDeploy errore in modo che non si verifichino distribuzioni impreviste durante la risoluzione del problema.
1. Prendi nota della tua attuale impostazione Auto Scaling **DesiredCapacity**:
`aws autoscaling describe-auto-scaling-groups --auto-scaling-group-name ASG_NAME`
Potrebbe essere necessario tornare a questo numero al termine di questa procedura.
1. Imposta l'**DesiredCapacity**impostazione Auto Scaling su. `1` Questa opzione è facoltativa se la capacità desiderata era superiore `1` a quella iniziale. Riducendolo a`1`, l'istanza impiegherà meno tempo per il provisioning e la distribuzione in un secondo momento, il che velocizza la risoluzione dei problemi. Se la capacità desiderata di Auto Scaling era originariamente impostata su`0`, è necessario aumentarla a. `1` Questo è obbligatorio.
aws autoscaling set-desired-capacity - --desired-capacity 1 auto-scaling-group-name *ASG\$1NAME*
**Nota**
I passaggi rimanenti di questa procedura presuppongono che tu abbia impostato il tuo. **DesiredCapacity**`1`
A questo punto, Auto Scaling tenta di scalare fino a un'istanza. Quindi, poiché l'hook CodeDeploy aggiunto è ancora presente, CodeDeploy tenta di eseguire la distribuzione; la distribuzione fallisce; Auto Scaling annulla l'istanza e Auto Scaling tenta di riavviare un'istanza per raggiungere la capacità desiderata di una, operazione che ancora una volta fallisce. È in corso un ciclo di annullamento/riavvio.
1. Annulla la registrazione del gruppo Auto Scaling dal gruppo di distribuzione:
**avvertimento**
Il comando seguente lancerà una nuova istanza EC2 senza software. Prima di eseguire il comando, assicuratevi che un'`InService`istanza di Auto Scaling che non esegue alcun software sia accettabile. Ad esempio, assicuratevi che il sistema di bilanciamento del carico associato all'istanza non invii traffico a questo host senza software.
**Importante**
Utilizzate il CodeDeploy comando mostrato di seguito per rimuovere l'hook. Non rimuovere l'hook tramite il servizio Auto Scaling, poiché la rimozione non verrà riconosciuta da. CodeDeploy
`aws deploy update-deployment-group --application-name APPLICATION_NAME --current-deployment-group-name DEPLOYMENT_GROUP_NAME --auto-scaling-groups`
Dopo aver eseguito questo comando, si verifica quanto segue:
1. CodeDeploy annulla la registrazione del gruppo Auto Scaling dal gruppo di distribuzione.
1. CodeDeploy rimuove l'hook del ciclo di vita Auto Scaling dal gruppo Auto Scaling.
1. Poiché l'hook che stava causando una distribuzione fallita non è più presente, Auto Scaling annulla l'istanza EC2 esistente e ne lancia immediatamente una nuova per scalare fino alla capacità desiderata. La nuova istanza dovrebbe passare presto allo stato attuale. `InService` La nuova istanza non include software.
1. Attendi che l'istanza EC2 entri nello `InService` stato. Per verificarne lo stato, usa il seguente comando:
`aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names ASG_NAME --query AutoScalingGroups[0].Instances[*].LifecycleState`
1. Aggiungi nuovamente l'hook all'istanza EC2:
**Importante**
Usa il CodeDeploy comando mostrato di seguito per aggiungere l'hook. Non utilizzare il servizio Auto Scaling per aggiungere l'hook, poiché l'aggiunta non verrà riconosciuta da. CodeDeploy
`aws deploy update-deployment-group --application-name APPLICATION_NAME --current-deployment-group-name DEPLOYMENT_GROUP_NAME --auto-scaling-groups ASG_NAME`
Dopo aver eseguito questo comando, si verifica quanto segue:
1. CodeDeploy reinstalla l'hook del ciclo di vita Auto Scaling sull'istanza EC2
1. CodeDeploy registra nuovamente il gruppo Auto Scaling con il gruppo di distribuzione.
1. Crea una distribuzione a livello di flotta con Amazon S3 GitHub o una versione che sai essere integra e che desideri utilizzare.
Ad esempio, se la revisione è un file.zip in un bucket Amazon S3 `my-revision-bucket` chiamato con una chiave oggetto `httpd_app.zip` di, inserisci il seguente comando:
`aws deploy create-deployment --application-name APPLICATION_NAME --deployment-group-name DEPLOYMENT_GROUP_NAME --revision "revisionType=S3,s3Location={bucket=my-revision-bucket,bundleType=zip,key=httpd_app.zip}"`
Poiché ora è presente un'`InService`istanza nel gruppo Auto Scaling, questa distribuzione dovrebbe funzionare e non dovresti più visualizzare l'errore *La distribuzione non è riuscita perché non sono state trovate istanze per il tuo* gruppo di distribuzione.
1. Una volta completata l'implementazione, ridimensionate il gruppo Auto Scaling riportandolo alla capacità originale, se in precedenza lo avevate ridimensionato in:
`aws autoscaling set-desired-capacity --auto-scaling-group-name ASG_NAME --desired-capacity ORIGINAL_CAPACITY`
**Per risolvere il problema del deadlock di distribuzione (console)**
1. (Facoltativo) Blocca CI/CD le pipeline che causano l' CodeDeploy errore in modo che non si verifichino distribuzioni impreviste durante la risoluzione del problema.
1. Vai alla console Amazon EC2 e prendi nota dell'impostazione della capacità desiderata di Auto **Scaling.** Potrebbe essere necessario tornare a questo numero al termine di questa procedura. Per informazioni su come trovare questa impostazione, consulta [Impostazione dei limiti di capacità nel gruppo Auto Scaling.](https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-capacity-limits.html)
1. Imposta il numero desiderato di istanze EC2 su: `1`
Questo è facoltativo se la capacità desiderata era maggiore di `1` quella iniziale. Riducendolo a`1`, l'istanza impiegherà meno tempo per il provisioning e la distribuzione in un secondo momento, il che velocizza la risoluzione dei problemi. Se la **capacità di Auto Scaling Desired** era originariamente impostata su`0`, è necessario aumentarla a. `1` Questo è obbligatorio.
**Nota**
I passaggi rimanenti di questa procedura presuppongono che la **capacità desiderata sia stata impostata** su`1`.
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)e scegli **Auto Scaling** Groups dal pannello di navigazione.
1. Scegli la regione appropriata.
1. Vai al gruppo Auto Scaling problematico.
1. **In **Dettagli del gruppo**, scegli Modifica.**
1. Imposta **la capacità desiderata** su**1**.
1. Scegliere **Aggiorna**.
1. Annulla la registrazione del gruppo Auto Scaling dal gruppo di distribuzione:
**avvertimento**
I seguenti passaggi secondari avvieranno una nuova istanza EC2 senza software. Prima di eseguire il comando, assicuratevi che un'`InService`istanza di Auto Scaling che non esegue alcun software sia accettabile. Ad esempio, assicuratevi che il sistema di bilanciamento del carico associato all'istanza non invii traffico a questo host senza software.
1. Apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).
1. Scegli la regione appropriata.
1. Nel riquadro di navigazione, scegliere **Applications (Applicazioni)**.
1. Scegli il nome della tua CodeDeploy applicazione.
1. Scegli il nome del tuo gruppo CodeDeploy di distribuzione.
1. Scegli **Modifica**.
1. Nella **configurazione dell'ambiente**, deseleziona i gruppi **Amazon EC2 Auto** Scaling.
**Nota**
La console non consente di salvare la configurazione se non è stata definita alcuna configurazione di ambiente. Per aggirare il controllo, aggiungi temporaneamente un tag di `EC2` o `On-premises` che sai non verrà risolto per nessun host. **Per aggiungere un tag, seleziona **istanze Amazon EC2** o **Istanza locale** e aggiungi un tag Chiave di o.** **EC2** **On-premises** **Puoi lasciare il tag Value vuoto.**
1. Scegli **Save changes** (Salva modifiche).
Dopo aver completato questi passaggi secondari, si verifica quanto segue:
1. CodeDeploy annulla la registrazione del gruppo Auto Scaling dal gruppo di distribuzione.
1. CodeDeploy rimuove l'hook del ciclo di vita Auto Scaling dal gruppo Auto Scaling.
1. Poiché l'hook che stava causando una distribuzione fallita non è più presente, Auto Scaling annulla l'istanza EC2 esistente e ne lancia immediatamente una nuova per scalare fino alla capacità desiderata. La nuova istanza dovrebbe passare presto allo stato attuale. `InService` La nuova istanza non include software.
1. Attendi che l'istanza EC2 entri nello `InService` stato. Per verificarne lo stato:
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, selezionare **Groups (Gruppi Auto Scaling)**.
1. Scegli il tuo gruppo Auto Scaling.
1. Nel riquadro dei contenuti, scegli la scheda **Gestione delle istanze**.
1. In **Istanze**, assicurati che la colonna **Lifecycle** indichi **InService**accanto all'istanza.
1. Registra nuovamente il gruppo Auto Scaling con CodeDeploy il gruppo di distribuzione utilizzando lo stesso metodo utilizzato per rimuoverlo:
1. Apri la CodeDeploy console all'indirizzo. [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/)
1. Scegli la regione appropriata.
1. Nel riquadro di navigazione, scegliere **Applications (Applicazioni)**.
1. Scegli il nome della tua CodeDeploy applicazione.
1. Scegli il nome del tuo gruppo CodeDeploy di distribuzione.
1. Scegli **Modifica**.
1. Nella **configurazione dell'ambiente**, seleziona i gruppi **Amazon EC2 Auto** Scaling e seleziona il tuo gruppo Auto Scaling dall'elenco.
1. In Istanze **Amazon EC2 o Istanze** **locali**, trova il tag che hai aggiunto e rimuovilo.
1. **Deseleziona la casella di controllo accanto alle istanze **Amazon EC2** o alle istanze locali.**
1. Scegli **Save changes** (Salva modifiche).
Questa configurazione reinstalla il lifecycle hook nel gruppo Auto Scaling.
1. Crea una distribuzione a livello di flotta con Amazon S3 GitHub o una versione che sai essere integra e che desideri utilizzare.
Ad esempio, se la revisione è un file.zip in un bucket Amazon S3 `my-revision-bucket` chiamato con una chiave oggetto di, `httpd_app.zip` procedi come segue:
1. **Nella CodeDeploy console, nella pagina **Deployment Group**, scegli Crea distribuzione.**
1. Per **Revision type (Tipo di revisione)**, scegliere **My application is stored in Amazon S3 (La mia applicazione è archiviata in Amazon S3)**.
1. Per **Posizione di revisione**, scegli`s3://my-revision-bucket/httpd_app.zip`.
1. Per il **tipo di file di revisione, scegli**. `.zip`
1. Scegli **Create deployment (Crea distribuzione)**.
Poiché ora è presente un'`InService`istanza nel gruppo Auto Scaling, questa distribuzione dovrebbe funzionare e non dovresti più visualizzare l'errore *La distribuzione non è riuscita perché non sono state trovate istanze per il tuo* gruppo di distribuzione.
1. Una volta completata l'implementazione, ridimensionate il gruppo Auto Scaling riportandolo alla capacità originale, se in precedenza lo avevate ridimensionato in:
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)e scegli **Auto Scaling** Groups dal pannello di navigazione.
1. Scegli la regione appropriata.
1. Vai al tuo gruppo Auto Scaling.
1. In **Dettagli del gruppo**, scegli **Modifica**.
1. Riporta **la capacità desiderata** al valore originale.
1. Scegliere **Aggiorna**.
# Codici di errore per AWS CodeDeploy
Questo argomento fornisce informazioni di riferimento sugli CodeDeploy errori.
****
| Codice di errore | Descrizione |
| --- | --- |
| `AGENT_ISSUE` | La distribuzione non è riuscita a causa di un problema con l' CodeDeploy agente. Verifica che l'agente sia installato e in esecuzione su tutte le istanze in questo gruppo di distribuzione. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `AUTO_SCALING_IAM_ROLE_PERMISSIONS` | Il ruolo di servizio associato al gruppo di distribuzione non dispone dell'autorizzazione richiesta per eseguire operazioni nel seguente AWS servizio. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `HEALTH_CONSTRAINTS` | La distribuzione globale non è riuscita perché la distribuzione di troppe singole istanze non è riuscita, troppe poche istanze integre sono disponibili per la distribuzione, oppure alcune istanze nel gruppo di distribuzione stanno riscontrando dei problemi. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `HEALTH_CONSTRAINTS_INVALID` | La distribuzione non può iniziare, perché non è disponibile il numero minimo di istanze integre, così come definito dalla configurazione della distribuzione. È possibile ridurre il numero di istanze integre richiesto aggiornando la configurazione della distribuzione o aumentando il numero di istanze in questo gruppo di distribuzione. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `IAM_ROLE_MISSING` | La distribuzione non è riuscita perché non esiste alcun ruolo del servizio con nome del ruolo del servizio specificato per il gruppo di distribuzione. Verificare di utilizzare il nome del ruolo del servizio corretto. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `IAM_ROLE_PERMISSIONS` | CodeDeploy non dispone delle autorizzazioni necessarie per assumere un ruolo oppure il ruolo IAM che stai utilizzando non ti dà l'autorizzazione per eseguire operazioni in un servizio. AWS Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `NO_INSTANCES` | Questo errore potrebbe essere causato da uno dei seguenti motivi. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `OVER_MAX_INSTANCES` | La distribuzione non è riuscita perché più istanze sono mirate per la distribuzione di quelle consentite per l'account. Per ridurre il numero di istanze mirate per questa distribuzione, aggiornare le impostazioni del tag per questo gruppo di distribuzione o eliminare alcune delle istanze mirate. In alternativa, puoi contattarci per richiedere un aumento del limite Supporto AWS . Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `THROTTLED` | L'implementazione non è riuscita perché sono state fatte più richieste di quelle consentite AWS CodeDeploy da un ruolo IAM. Provare a ridurre il numero di richieste. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
| `UNABLE_TO_SEND_ASG` | La distribuzione non è riuscita perché il gruppo di distribuzione non è configurato correttamente con il relativo gruppo Amazon EC2 Auto Scaling. Nella CodeDeploy console, elimina il gruppo Amazon EC2 Auto Scaling dal gruppo di distribuzione, quindi aggiungilo nuovamente. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/error-codes.html) |
## Argomenti correlati
[Risoluzione dei problemi CodeDeploy](troubleshooting.md)