

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

# Monitoraggio delle implementazioni in CodeDeploy
<a name="monitoring"></a>

Il monitoraggio è un elemento importante per mantenere l'affidabilità, la disponibilità e le prestazioni delle soluzioni CodeDeploy esistenti. AWS È necessario raccogliere i dati di monitoraggio da tutte le parti della AWS soluzione in modo da poter eseguire più facilmente il debug di un errore multipunto, se si verifica. Prima di iniziare il monitoraggio CodeDeploy, tuttavia, è necessario creare un piano di monitoraggio che includa le risposte alle seguenti domande:
+ Quali sono gli obiettivi del monitoraggio?
+ Di quali risorse si intende eseguire il monitoraggio?
+ Con quale frequenza sarà eseguito il monitoraggio di queste risorse?
+ Quali strumenti di monitoraggio verranno utilizzati?
+ Chi eseguirà i processi di monitoraggio?
+ Chi deve ricevere una notifica quando si verifica un problema?

Il passaggio successivo consiste nello stabilire una linea di base per CodeDeploy le normali prestazioni nell'ambiente in uso, misurando le prestazioni in diversi momenti e in diverse condizioni di carico. Durante il monitoraggio CodeDeploy, archivia i dati di monitoraggio cronologici in modo da poterli confrontare con i dati sulle prestazioni correnti, identificare i normali modelli di prestazioni e le anomalie delle prestazioni e ideare metodi per risolvere i problemi.

Ad esempio, se utilizzi CodeDeploy, puoi monitorare lo stato delle distribuzioni e delle istanze di destinazione. Quando le distribuzioni o le istanze falliscono, potrebbe essere necessario riconfigurare un file di specifiche dell'applicazione, reinstallare o aggiornare l' CodeDeploy agente, aggiornare le impostazioni in un'applicazione o in un gruppo di distribuzione o apportare modifiche alle impostazioni dell'istanza o a un file. AppSpec 

Per stabilire una baseline, devi monitorare almeno gli elementi seguenti:
+ Eventi e stato della distribuzione
+ Eventi e stato dell'istanza

## Strumenti di monitoraggio automatici
<a name="monitoring_automated_tools"></a>

AWS fornisce diversi strumenti che è possibile utilizzare per il monitoraggio. CodeDeploy Alcuni di questi strumenti possono essere configurati in modo che eseguano automaticamente il monitoraggio, mentre altri richiedono l'intervento manuale. Si consiglia di automatizzare il più possibile i processi di monitoraggio.

Puoi utilizzare i seguenti strumenti di monitoraggio automatizzato per osservare CodeDeploy e segnalare quando qualcosa non va:
+ **Amazon CloudWatch Alarms**: monitora una singola metrica in un periodo di tempo specificato ed esegui una o più azioni in base al valore della metrica rispetto a una determinata soglia in diversi periodi di tempo. L'azione è una notifica inviata a un argomento di Amazon Simple Notification Service (Amazon SNS) o a una policy di Amazon EC2 Auto Scaling. CloudWatch gli allarmi non richiamano azioni semplicemente perché si trovano in uno stato particolare; lo stato deve essere cambiato e mantenuto per un determinato numero di periodi. Per ulteriori informazioni, consulta [Monitoraggio delle implementazioni con gli strumenti di Amazon CloudWatch](monitoring-cloudwatch.md).

  Per informazioni sull'aggiornamento del ruolo del servizio per l'utilizzo con il monitoraggio degli allarmi di CloudWatch , consulta [Concedere CloudWatch le autorizzazioni a un ruolo di servizio CodeDeploy](monitoring-create-alarms-grant-permissions.md). Per informazioni su come aggiungere il monitoraggio degli CloudWatch allarmi alle tue CodeDeploy operazioni, consulta [Crea un'applicazione con CodeDeploy](applications-create.md)[Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md), o. [Modifica le impostazioni del gruppo di distribuzione con CodeDeploy](deployment-groups-edit.md)

  
+ **Amazon CloudWatch Logs**: monitora, archivia e accedi ai tuoi file di registro da AWS CloudTrail o altre fonti. Per ulteriori informazioni, consulta [Monitoring Log Files](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchLogs.html) nella *Amazon CloudWatch User Guide*.

  Per informazioni sull'utilizzo della CloudWatch console per visualizzare CodeDeploy i log, consulta [Visualizza i log nella CloudWatch console CodeDeploy Logs.](https://aws.amazon.com/blogs/devops/view-aws-codedeploy-logs-in-amazon-cloudwatch-console/)
+ **Amazon CloudWatch Events**: abbina gli eventi e li indirizza a una o più funzioni o stream di destinazione per apportare modifiche, acquisire informazioni sullo stato e intraprendere azioni correttive. Per ulteriori informazioni, consulta [What is Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchEvents.html) nella *Amazon CloudWatch User Guide*.

  Per informazioni sull'utilizzo di CloudWatch Events nelle tue CodeDeploy operazioni, consulta[Monitoraggio delle distribuzioni con Amazon Events CloudWatch](monitoring-cloudwatch-events.md).
+ **AWS CloudTrail Monitoraggio dei log**: condividi i file di CloudTrail registro tra account, monitora i file di registro in tempo reale inviandoli a CloudWatch Logs, scrivi applicazioni di elaborazione dei log in Java e verifica che i file di registro non siano cambiati dopo la consegna da parte di. CloudTrail Per ulteriori informazioni, consulta [Lavorare con i file di CloudTrail registro nella Guida](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-working-with-log-files.html) per l'*AWS CloudTrail utente*. 

  Per informazioni sull'utilizzo di CloudTrail with CodeDeploy, vedere[Monitoraggio delle implementazioni con AWS CloudTrail](monitoring-cloudtrail.md).
+ **Amazon Simple Notification Service**: configura i trigger basati sugli eventi per ricevere notifiche via SMS o e-mail su eventi di distribuzione e istanze, come il successo o l'errore. Per ulteriori informazioni, consulta [Creare un argomento](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) e [Cos'è Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/welcome.html).

  Per informazioni sulla configurazione delle notifiche di Amazon SNS per CodeDeploy, consulta. [Monitoraggio delle distribuzioni con le notifiche degli eventi di Amazon SNS](monitoring-sns-event-notifications.md)

## Strumenti di monitoraggio manuali
<a name="monitoring_manual_tools"></a>

Un'altra parte importante del monitoraggio CodeDeploy consiste nel monitorare manualmente gli elementi che gli CloudWatch allarmi non coprono. Le dashboard della AWS console CodeDeploy CloudWatch, e altre, forniscono una at-a-glance panoramica dello stato dell'ambiente AWS . Ti consigliamo di controllare anche i file di registro sulle CodeDeploy distribuzioni.
+ CodeDeploy la console mostra:
  + Lo stato delle distribuzioni
  + La data e l'ora dell'ultimo tentativo e dell'ultimo esito positivo di ogni distribuzione di una revisione
  + Il numero di istanze che hanno avuto esito positivo o negativo, che sono state ignorate o che sono in corso in una distribuzione
  + Lo stato delle istanze locali
  + La data e l'ora in cui la registrazione di istanze locali è stata eseguita o annullata
+ CloudWatch la home page mostra:
  + Stato e allarmi attuali
  + Grafici degli allarmi e delle risorse
  + Stato di integrità dei servizi

  Inoltre, è possibile utilizzare CloudWatch per effettuare le seguenti operazioni: 
  + Crea [pannelli di controllo personalizzati](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CloudWatch_Dashboards.html) per monitorare i servizi di interesse.
  + Crea grafici dei dati dei parametri per la risoluzione di problemi e il rilevamento di tendenze.
  + Cerca e sfoglia tutte le metriche AWS delle tue risorse
  + Crea e modifica gli allarmi per ricevere le notifiche dei problemi.

**Argomenti**
+ [Monitoring Deployments with Amazon CloudWatch Tools](monitoring-cloudwatch.md)
+ [Monitoring Deployments](monitoring-cloudtrail.md)
+ [Monitoring Deployments with Amazon SNS Event Notifications](monitoring-sns-event-notifications.md)

# Monitoraggio delle implementazioni con gli strumenti di Amazon CloudWatch
<a name="monitoring-cloudwatch"></a>

Puoi monitorare le CodeDeploy distribuzioni utilizzando i seguenti CloudWatch strumenti: Amazon CloudWatch Events, CloudWatch allarmi e Amazon Logs. CloudWatch 

La revisione dei log creati dall' CodeDeploy agente e dalle distribuzioni può aiutarti a risolvere le cause degli errori di distribuzione. In alternativa alla revisione dei CodeDeploy log di un'istanza alla volta, è possibile utilizzare CloudWatch Logs per monitorare tutti i log in una posizione centrale.

Per informazioni sull'utilizzo di CloudWatch allarmi ed CloudWatch eventi per monitorare le CodeDeploy distribuzioni, consulta i seguenti argomenti. 

**Topics**
+ [Monitoraggio delle distribuzioni con allarmi in CloudWatch CodeDeploy](monitoring-create-alarms.md)
+ [Monitoraggio delle distribuzioni con Amazon Events CloudWatch](monitoring-cloudwatch-events.md)

# Monitoraggio delle distribuzioni con allarmi in CloudWatch CodeDeploy
<a name="monitoring-create-alarms"></a>

Puoi creare un CloudWatch allarme per un'istanza o un gruppo Amazon EC2 Auto Scaling che utilizzi CodeDeploy nelle tue operazioni. Un allarme controlla una singola metrica in un periodo di tempo specificato ed esegue una o più azioni in base al valore della metrica rispetto a una determinata soglia in diversi periodi di tempo. CloudWatch gli allarmi richiamano azioni quando il loro stato cambia (ad esempio, da a). `OK` `ALARM`

Utilizzando la funzionalità di CloudWatch allarme nativa, puoi specificare qualsiasi azione supportata in CloudWatch caso di errore di un'istanza utilizzata in una distribuzione, come l'invio di una notifica Amazon SNS o l'arresto, la chiusura, il riavvio o il ripristino di un'istanza. Per CodeDeploy le tue operazioni, puoi configurare un gruppo di distribuzione per interrompere una distribuzione ogni volta che viene attivato un CloudWatch allarme associato al gruppo di distribuzione. 

È possibile associare fino a dieci CloudWatch allarmi a un gruppo di CodeDeploy distribuzione. Se uno degli allarmi specificati viene attivato, la distribuzione viene interrotta e passa allo stato Interrotta. Per utilizzare questa opzione, è necessario concedere CloudWatch le autorizzazioni per il proprio ruolo di CodeDeploy servizio.

Per informazioni sulla configurazione degli CloudWatch allarmi nella CloudWatch console, consulta la sezione [Creazione di CloudWatch allarmi Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/AlarmThatSendsEmail.html) nella *Amazon CloudWatch User Guide*.

Per informazioni sull'associazione di un CloudWatch allarme a un gruppo di distribuzione in CodeDeploy, consulta e. [Crea un gruppo di distribuzione con CodeDeploy](deployment-groups-create.md) [Modifica le impostazioni del gruppo di distribuzione con CodeDeploy](deployment-groups-edit.md)

**Topics**
+ [Concedere CloudWatch le autorizzazioni a un ruolo di servizio CodeDeploy](monitoring-create-alarms-grant-permissions.md)

# Concedere CloudWatch le autorizzazioni a un ruolo di servizio CodeDeploy
<a name="monitoring-create-alarms-grant-permissions"></a>

Prima di poter utilizzare il monitoraggio degli CloudWatch allarmi nelle distribuzioni, è necessario concedere al ruolo di servizio utilizzato nelle CodeDeploy operazioni l' CloudWatch autorizzazione ad accedere alle risorse. 

**Per concedere le CloudWatch autorizzazioni a un ruolo di servizio**

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

1. Nella console IAM, nel pannello di navigazione, scegli **Ruoli**.

1. Scegli il nome del ruolo di servizio che utilizzi nelle tue AWS CodeDeploy operazioni.

1. Nella scheda **Permissions (Autorizzazioni)**, nell'area **Inline Policies (Policy inline)**, scegliere **Create Role Policy (Crea policy ruolo)**.

   —oppure—

   Se il pulsante **Create Role Policy (Crea policy ruolo)** non è disponibile, espandere l'area **Inline Policies (Policy inline)**, quindi scegliere **click here (fai clic qui)**.

1. Nella pagina **Set Permissions** (Imposta autorizzazioni), scegli **Custom Policy** (Policy personalizzata), quindi scegli **Select** (Seleziona).

1. Nella pagina **Review Policy (Riconsulta policy)**, nel campo **Policy Name (Nome policy)**, digitare un nome per identificare questa policy, ad esempio `CWAlarms`.

1. Incollare quanto segue nel campo **Policy Document (Documento policy)**: 

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "cloudwatch:DescribeAlarms",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Scegli **Apply Policy** (Applica policy).

# Monitoraggio delle distribuzioni con Amazon Events CloudWatch
<a name="monitoring-cloudwatch-events"></a>

Puoi utilizzare Amazon CloudWatch Events per rilevare e reagire ai cambiamenti nello stato di un'istanza o di una distribuzione (un «evento») nelle tue CodeDeploy operazioni. Quindi, in base alle regole che crei, CloudWatch Events invocherà una o più azioni mirate quando una distribuzione o un'istanza entra nello stato specificato in una regola. A seconda del tipo di cambiamento di stato, potrebbe essere necessario inviare notifiche, acquisire informazioni sullo stato, eseguire un'azione correttiva, avviare eventi o eseguire altre operazioni. Puoi selezionare i seguenti tipi di obiettivi quando utilizzi CloudWatch Events come parte delle tue CodeDeploy operazioni:
+ AWS Lambda funzioni
+  Flussi Kinesis
+ Code Amazon SQS
+ Obiettivi predefiniti (`EC2 CreateSnapshot API call``EC2 RebootInstances API call``EC2 StopInstances API call`,, e`EC2 TerminateInstances API call`)
+ Argomenti di Amazon SNS

Di seguito sono riportati alcuni casi d'uso:
+ Utilizza una funzione di Lambda per inoltrare una notifica a un canale Slack quando le distribuzioni hanno esito negativo.
+ Effettua il push dei dati relativi a distribuzioni o istanze su un flusso Kinesis per supportare il monitoraggio completo dello stato in tempo reale.
+ Usa le azioni di CloudWatch allarme per arrestare, terminare, riavviare o ripristinare automaticamente EC2 le istanze Amazon quando si verifica un evento di distribuzione o istanza specificato.

Il resto di questo argomento descrive la procedura di base per la creazione di una CloudWatch regola Events per. CodeDeploy Prima di creare regole di evento da utilizzare nelle CodeDeploy operazioni, tuttavia, è necessario effettuare le seguenti operazioni:
+ Completa i prerequisiti CloudWatch degli eventi. Per informazioni, consulta i [prerequisiti di Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CWE_Prerequisites.html).
+ Acquisisci familiarità con eventi, regole e obiettivi in Events. CloudWatch Per ulteriori informazioni, consulta [Che cos'è Amazon CloudWatch Events?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) e [nuovi CloudWatch eventi: monitora e rispondi alle modifiche alle tue AWS risorse](https://aws.amazon.com/blogs/aws/new-cloudwatch-events-track-and-respond-to-changes-to-your-aws-resources/).
+ Crea la destinazione o le destinazioni da utilizzare nelle regole degli eventi. 

**Per creare una regola CloudWatch relativa agli eventi per CodeDeploy:**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel pannello di navigazione seleziona **Events** (Eventi).

1. Scegli **Create rule (Crea regola)**, quindi, in **Event selector (Selettore evento)**, scegli **AWS CodeDeploy**.

1. Specifica un tipo di dettaglio:
   + Per creare una regola che si applichi a tutte le modifiche di stato delle istanze e delle distribuzioni, scegli **Any detail type (Qualsiasi tipo di dettaglio)**, quindi passa alla fase 6.
   + Per creare una regola applicabile solo alle istanze, scegli **Tipo di dettaglio specifico**, quindi scegli Notifica di **modifica dello stato dell'CodeDeploy istanza**.
   + **Per creare una regola che si applichi solo alle distribuzioni, scegli **Tipo di dettaglio specifico**, quindi scegli CodeDeploy Notifica di modifica dello stato di distribuzione.**

1. Specificare le modifiche di stato cui si applica la regola:
   + Per creare una regola che si applichi a tutte le modifiche di stato, scegli **Any state (Qualsiasi stato)**.
   + Per creare una regola che si applichi solo ad alcune modifiche di stato, scegli **Specific state(s) (Stati specifici)**, quindi scegli uno o più valori di stato dall'elenco. La tabella seguente include i valori di stato che è possibile scegliere:  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/monitoring-cloudwatch-events.html)

1. Specificate a quali CodeDeploy applicazioni si applica la regola:
   + Per creare una regola che si applichi a tutte le applicazioni, scegli **Any application (Qualsiasi applicazione)**, quindi passa al punto 8.
   + Per creare una regola che si applichi a una sola applicazione, scegli **Specific application (Applicazione specifica)**, quindi seleziona il nome dell'applicazione dall'elenco.

1. Specifica i gruppi di distribuzione a cui si applica la regola:
   + Per creare una regola che si applichi a tutti i gruppi di distribuzione associati all'applicazione selezionata, scegli **Any deployment group (Qualsiasi gruppo di distribuzione)**.
   + Per creare una regola che si applichi a uno solo dei gruppi di distribuzione associati all'applicazione selezionata, scegli **Specific deployment group(s) (Gruppi di distribuzione specifici)**, quindi seleziona il nome del gruppo di distribuzione dall'elenco.

1. Verifica la configurazione delle regole per accertarti che soddisfi i tuoi requisiti di monitoraggio di eventi.

1. Nell'area **Targets** (Destinazioni), scegli **Add target\$1** (Aggiungi destinazione).

1. Nell'elenco **Select target type** (Seleziona tipo di destinazione), scegli il tipo di destinazione da utilizzare con questa regola, quindi configura le eventuali altre opzioni richieste da quel tipo. 

1. Scegli **Configura dettagli**.

1. Nella pagina **Configure rule details (Configura i dettagli della regola)**, digita un nome e una descrizione per la regola, quindi seleziona la casella **State (Stato)** per abilitare la regola non appena viene creata.

1. Se la regola ti soddisfa, scegli **Create rule** (Crea regola).

# Monitoraggio delle implementazioni con AWS CloudTrail
<a name="monitoring-cloudtrail"></a>

CodeDeploy è integrato con CloudTrail, un servizio che acquisisce le chiamate API effettuate da o per conto del CodeDeploy tuo AWS account e invia i file di registro a un bucket Amazon S3 da te specificato. CloudTrailacquisisce le chiamate API dalla CodeDeploy console, dai CodeDeploy comandi tramite o AWS CLI direttamente. CodeDeploy APIs Utilizzando le informazioni raccolte da CloudTrail, è possibile determinare a quale richiesta è stata effettuata CodeDeploy, l'indirizzo IP di origine da cui è stata effettuata la richiesta, chi ha effettuato la richiesta, quando è stata effettuata e così via. Per ulteriori informazioni CloudTrail, incluso come configurarlo e abilitarlo, consulta la [Guida AWS CloudTrail per l'utente](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

## CodeDeploy informazioni in CloudTrail
<a name="service-name-info-in-cloudtrail"></a>

Quando CloudTrail la registrazione è abilitata nel tuo AWS account, le chiamate API effettuate alle CodeDeploy azioni vengono tracciate nei file di registro. CodeDeploy i record vengono scritti insieme ad altri record AWS di servizio in un file di registro. CloudTrail determina quando creare e scrivere su un nuovo file in base a un periodo di tempo e alle dimensioni del file.

Tutte le CodeDeploy azioni vengono registrate e documentate nel [AWS CodeDeploy Command Line Reference e nel [AWS CodeDeploy API](https://docs.aws.amazon.com/codedeploy/latest/APIReference/) Reference](https://docs.aws.amazon.com/cli/latest/reference/deploy/index.html). Ad esempio, le chiamate per creare distribuzioni, eliminare applicazioni e registrare le revisioni delle applicazioni generano voci nei file di registro. CloudTrail 

Ogni voce di log contiene informazioni sull'utente che ha generato la richiesta. Le informazioni sull'identità dell'utente contenute nel registro consentono di determinare se la richiesta è stata effettuata con credenziali utente o root, con credenziali di sicurezza temporanee per un ruolo o un utente federato o da un altro servizio. AWS Per ulteriori informazioni, consulta il campo **userIdentity** nel [riferimento agli eventi CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/event_reference_top_level.html).

È possibile archiviare i file di log nel bucket per un periodo di tempo indeterminato, ma è anche possibile definire regole per il ciclo di vita di Amazon S3 per archiviare o eliminare automaticamente i file di log. Per impostazione predefinita, la crittografia lato server (SSE) di Amazon S3 viene utilizzata per crittografare i file di registro.

Puoi fare in modo che le notifiche di Amazon SNS vengano CloudTrail pubblicate quando vengono consegnati nuovi file di log. Per ulteriori informazioni, consulta l'argomento relativo alla [configurazione delle notifiche Amazon SNS per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html).

Puoi anche aggregare i file di CodeDeploy log di più AWS regioni e più AWS account in un unico bucket Amazon S3. Per ulteriori informazioni, consulta [Ricezione di file di CloudTrail registro da](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/aggregating_logs_top_level.html) più regioni.

## Comprendere CodeDeploy le voci dei file di registro
<a name="understanding-service-name-entries"></a>

CloudTrail i file di registro possono contenere una o più voci di registro in cui ogni voce è composta da più eventi in formato JSON. Una voce di log rappresenta una singola richiesta emessa da qualsiasi origine e include informazioni sull'operazione richiesta, eventuali parametri, la data e l'ora dell'operazione e così via. Le voci di log non vengono necessariamente create in un ordine specifico, ovvero non costituiscono una traccia di stack ordinata delle chiamate API pubbliche.

L'esempio seguente mostra una voce di CloudTrail registro che illustra l'azione di creazione di un gruppo di distribuzione: CodeDeploy 

```
{
	"Records": [{
		"eventVersion": "1.02",
		"userIdentity": {
			"type": "AssumedRole",
			"principalId": "AKIAI44QH8DHBEXAMPLE:203.0.113.11",
			"arn": "arn:aws:sts::123456789012:assumed-role/example-role/203.0.113.11",
			"accountId": "123456789012",
			"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
			"sessionContext": {
				"attributes": {
					"mfaAuthenticated": "false",
					"creationDate": "2014-11-27T03:57:36Z"
				},
				"sessionIssuer": {
					"type": "Role",
					"principalId": "AKIAI44QH8DHBEXAMPLE",
					"arn": "arn:aws:iam::123456789012:role/example-role",
					"accountId": "123456789012",
					"userName": "example-role"
				}
			}
		},
		"eventTime": "2014-11-27T03:57:36Z",
		"eventSource": "codedeploy.amazonaws.com",
		"eventName": "CreateDeploymentGroup",
		"awsRegion": "us-west-2",
		"sourceIPAddress": "203.0.113.11",
		"userAgent": "example-user-agent-string",
		"requestParameters": {
			"applicationName": "ExampleApplication",
			"serviceRoleArn": "arn:aws:iam::123456789012:role/example-instance-group-role",
			"deploymentGroupName": "ExampleDeploymentGroup",
			"ec2TagFilters": [{
                "value": "CodeDeployDemo",
				"type": "KEY_AND_VALUE",
				"key": "Name"
            }],
            "deploymentConfigName": "CodeDeployDefault.HalfAtATime"
		},
		"responseElements": {
			"deploymentGroupId": "7d64e680-e6f4-4c07-b10a-9e117EXAMPLE"
		},
		"requestID": "86168559-75e9-11e4-8cf8-75d18EXAMPLE",
		"eventID": "832b82d5-d474-44e8-a51d-093ccEXAMPLE",
		"eventType": "AwsApiCall",
		"recipientAccountId": "123456789012"
	},
    ... additional entries ...
    ]
}
```

# Monitoraggio delle distribuzioni con le notifiche degli eventi di Amazon SNS
<a name="monitoring-sns-event-notifications"></a>

Puoi aggiungere trigger a un gruppo di CodeDeploy distribuzione per ricevere notifiche sugli eventi relativi alle distribuzioni o alle istanze in quel gruppo di distribuzione. Queste notifiche vengono inviate ai destinatari abbonati a un argomento di Amazon SNS che hai inserito nell'azione del trigger. 

Puoi ricevere notifiche per CodeDeploy eventi in messaggi SMS o messaggi e-mail. Puoi anche utilizzare i dati JSON creati quando si verifica un evento specifico in altri modi, ad esempio inviando messaggi alle code di Amazon SQS o richiamando una funzione in. AWS Lambda Per esaminare la struttura dei dati JSON forniti per i trigger di distribuzione e istanza, consulta [Formati di dati JSON per i trigger CodeDeploy](monitoring-sns-event-notifications-json-format.md).

Utilizzare i trigger per ricevere le notifiche può risultare utile per:
+ Sviluppatori che hanno necessità di sapere quando una distribuzione non riesce o viene interrotta per potersi occupare della risoluzione del problema.
+ Sei un amministratore di sistema che deve sapere quante istanze falliscono per monitorare lo stato della tua flotta Amazon EC2.
+ Sei un manager che desidera un at-a-glance conteggio degli eventi di implementazione e di istanza, che puoi ottenere attraverso regole di filtro che indirizzano diversi tipi di notifiche nelle cartelle del tuo client di posta elettronica desktop. 

Puoi creare fino a 10 trigger per ogni gruppo di CodeDeploy distribuzione, per uno qualsiasi dei seguenti tipi di eventi.


| Eventi di distribuzione | Eventi di istanza | 
| --- | --- | 
|  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/monitoring-sns-event-notifications.html)  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/monitoring-sns-event-notifications.html)  | 
| ¹ Si applica solo alle distribuzioni. blue/green Indica che nelle istanze in un ambiente di sostituzione è stata installata l'ultima revisione dell'applicazione e il traffico dall'ambiente originale può ora essere reindirizzato in un sistema di bilanciamento del carico. Per ulteriori informazioni, consulta [Utilizzo delle distribuzioni in CodeDeploy](deployments.md). | 

**Topics**
+ [Concedi le autorizzazioni Amazon SNS per un ruolo di servizio](monitoring-sns-event-notifications-permisssions.md)
+ [Crea un trigger per un CodeDeploy evento](monitoring-sns-event-notifications-create-trigger.md)
+ [Modifica un trigger in un gruppo di distribuzione](monitoring-sns-event-notifications-edit-trigger.md)
+ [Eliminare un trigger da un gruppo di distribuzione](monitoring-sns-event-notifications-delete-trigger.md)
+ [Formati di dati JSON per i trigger](monitoring-sns-event-notifications-json-format.md)

# Concedi le autorizzazioni Amazon SNS per un ruolo di servizio CodeDeploy
<a name="monitoring-sns-event-notifications-permisssions"></a>

Prima che i trigger possano generare notifiche, al ruolo di servizio che utilizzi nelle tue CodeDeploy operazioni deve essere concessa l'autorizzazione per accedere alle risorse Amazon SNS. 

**Per concedere le autorizzazioni di Amazon SNS a un ruolo di servizio**

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

1. Nella console IAM, nel pannello di navigazione, scegli **Ruoli**.

1. Selezionare il nome del ruolo del servizio utilizzato nelle operazioni AWS CodeDeploy .

1. Nella scheda **Permissions (Autorizzazioni)**, nell'area **Inline Policies (Policy inline)**, scegliere **Create Role Policy (Crea policy ruolo)**.

   —oppure—

   Se il pulsante **Create Role Policy (Crea policy ruolo)** non è disponibile, espandere l'area **Inline Policies (Policy inline)**, quindi scegliere **click here (fai clic qui)**.

1. Nella pagina **Set Permissions** (Imposta autorizzazioni), scegli **Custom Policy** (Policy personalizzata), quindi scegli **Select** (Seleziona).

1. Nella pagina **Review Policy (Rivedi policy)**, nel campo **Policy Name (Nome policy)**, immettere un nome per questa policy, ad esempio `SNSPublish`.

1. Incollare quanto segue nel campo **Policy Document (Documento policy)**: 

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "sns:Publish",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Scegli **Apply Policy** (Applica policy).

# Crea un trigger per un evento CodeDeploy
<a name="monitoring-sns-event-notifications-create-trigger"></a>

Puoi creare un trigger che pubblica un argomento di Amazon Simple Notification Service (Amazon SNS) per un AWS CodeDeploy evento di distribuzione o istanza. Quindi, quando si verifica l'evento, tutti gli abbonati all'argomento associato ricevono notifiche tramite l'endpoint specificato nell'argomento, ad esempio un messaggio SMS o un messaggio e-mail. Amazon SNS offre diversi metodi per iscriversi agli argomenti.

Prima di creare un trigger, devi impostare l'argomento Amazon SNS a cui il trigger faccia riferimento. Per informazioni, consulta [Creare un argomento](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html). Quando crei un argomento, ti consigliamo di assegnargli un nome che ne identifichi lo scopo, in formati come `Topic-group-us-west-3-deploy-fail` o`Topic-group-project-2-instance-stop`. 

È inoltre necessario concedere ad Amazon SNS le autorizzazioni per un ruolo di CodeDeploy servizio prima di poter inviare notifiche per il trigger. Per informazioni, consulta [Concedi le autorizzazioni Amazon SNS per un ruolo di servizio CodeDeploy](monitoring-sns-event-notifications-permisssions.md).

Dopo aver creato l'argomento, si possono aggiungere i sottoscrittori. Per informazioni sulla creazione, la gestione e l'iscrizione agli argomenti, consulta [Cos'è Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/welcome.html).



## Crea un trigger per inviare notifiche per CodeDeploy eventi (console)
<a name="monitoring-sns-event-notifications-create-trigger-console"></a>

È possibile utilizzare la CodeDeploy console per creare trigger per un CodeDeploy evento. Al termine del processo di installazione, viene inviato un messaggio di notifica di prova per verificare che le autorizzazioni e i dettagli dei trigger siano impostati correttamente.

**Per creare un trigger per un evento CodeDeploy**

1. In Console di gestione AWS, apri la AWS CodeDeploy console.

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

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

1. Nella pagina **Applications (Applicazioni)** scegliere il nome dell'applicazione associata al gruppo di distribuzione in cui si intende aggiungere un trigger.

1. Nella pagina **Application details (Dettagli applicazione)** scegliere il gruppo di distribuzione in cui si intende aggiungere un trigger.

1.  Scegli **Modifica**. 

1.  Espandere **Advanced - optional (Opzioni avanzate - opzionale)**. 

1.  Nell'area **Triggers (Trigger)**, scegliere **Create trigger (Crea trigger)**. 

1. Nel riquadro **Create deployment trigger (Crea trigger di distribuzione)** eseguire le operazioni seguenti:

   1. In **Trigger name (Nome trigger)**, immettere un nome per il trigger che consenta di identificarne lo scopo. Si consiglia di utilizzare formati come `Trigger-group-us-west-3-deploy-fail` o `Trigger-group-eu-central-instance-stop`.

   1. In **Eventi**, scegli il tipo o i tipi di eventi per attivare l'argomento Amazon SNS per l'invio di notifiche. 

   1. Negli **argomenti di Amazon SNS**, scegli il nome dell'argomento che hai creato per l'invio di notifiche per questo trigger.

   1.  Scegli **Crea trigger**. CodeDeploy invia una notifica di prova per confermare che l'accesso è stato configurato correttamente tra CodeDeploy e l'argomento Amazon SNS. La conferma verrà inviata in un messaggio SMS o in un messaggio e-mail, in base al tipo di endpoint selezionato per l'argomento e a seconda che sia stata effettuata la sottoscrizione all'argomento. 

1.  Scegli **Save changes** (Salva modifiche). 

## Crea un trigger per inviare notifiche per CodeDeploy gli eventi (CLI)
<a name="monitoring-sns-event-notifications-create-trigger-cli"></a>

È possibile utilizzare l'interfaccia a riga di comando per includere i trigger al momento della creazione di un gruppo di distribuzione oppure è possibile aggiungere trigger a un gruppo di distribuzione esistente.

### Per creare un trigger per l'invio di notifiche per un nuovo gruppo di distribuzione
<a name="monitoring-sns-event-notifications-create-trigger-cli-new"></a>

Crea un file JSON per configurare il gruppo di distribuzione, quindi esegui il [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando utilizzando l'`--cli-input-json`opzione. 

Il modo più semplice per creare il file JSON consiste nell'utilizzare l'opzione `--generate-cli-skeleton` per ottenere una copia del formato JSON, quindi fornire i valori richiesti in un editor di testo normale.

1. Eseguire il comando seguente, quindi copiare i risultati in un editor di testo normale.

   ```
   aws deploy create-deployment-group --generate-cli-skeleton
   ```

1. Aggiungi il nome di un' CodeDeploy applicazione esistente all'output:

   ```
   {
       "applicationName": "TestApp-us-east-2",
       "deploymentGroupName": "",
       "deploymentConfigName": "",
       "ec2TagFilters": [
           {
               "Key": "",
               "Value": "",
               "Type": ""
           }
       ],
       "onPremisesInstanceTagFilters": [
           {
               "Key": "",
               "Value": "",
               "Type": ""
           }
       ],
       "autoScalingGroups": [
           ""
       ],
       "serviceRoleArn": "",
       "triggerConfigurations": [
           {
               "triggerName": "",
               "triggerTargetArn": "",
               "triggerEvents": [
                   ""
               ]
           }
       ]
   }
   ```

1. Fornire i valori per i parametri che si desidera configurare.

   Quando si utilizza il [create-deployment-group](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeploymentGroup.html)comando, è necessario fornire almeno i valori per i seguenti parametri:
   + `applicationName`: il nome di un'applicazione già creata nel proprio account. 
   + `deploymentGroupName`: un nome per il gruppo di distribuzione da creare.
   + `serviceRoleArn`: L'ARN di un ruolo di servizio esistente impostato CodeDeploy nel tuo account. Per informazioni, consulta [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).

   Nella sezione `triggerConfigurations` fornire i valori per i seguenti parametri: 
   + `triggerName`: il nome da assegnare al trigger per poterlo identificare facilmente. Si consiglia di utilizzare formati come `Trigger-group-us-west-3-deploy-fail` o `Trigger-group-eu-central-instance-stop`.
   + `triggerTargetArn`: L'ARN dell'argomento Amazon SNS che hai creato per associarlo al tuo trigger, in questo formato:. `arn:aws:sns:us-east-2:444455556666:NewTestTopic`
   + `triggerEvents`: il tipo di evento o gli eventi per cui si desidera attivare le notifiche. È possibile specificare uno o più tipi di evento utilizzando le virgole per separare i diversi nomi (ad esempio, `"triggerEvents":["DeploymentSuccess","DeploymentFailure","InstanceFailure"]`). Quando si aggiungono più tipi di evento, le notifiche vengono inviate all'argomento specificato per tutti i tipi di evento, anziché a un argomento diverso per ciascuno di essi. Puoi scegliere tra i seguenti tipi di evento:
     + DeploymentStart
     + DeploymentSuccess
     + DeploymentFailure
     + DeploymentStop
     + DeploymentRollback
     + DeploymentReady (Si applica solo alle istanze sostitutive in una distribuzione) blue/green 
     + InstanceStart
     + InstanceSuccess
     + InstanceFailure
     + InstanceReady (Si applica solo alle istanze sostitutive in una blue/green distribuzione)

   L'esempio di configurazione seguente crea un gruppo di distribuzione denominato `dep-group-ghi-789-2` per un'applicazione denominata `TestApp-us-east-2` e un trigger che richiede l'invio di notifiche ogni volta che viene avviata una distribuzione, indipendentemente dall'esito:

   ```
   {
       "applicationName": "TestApp-us-east-2",
       "deploymentConfigName": "CodeDeployDefault.OneAtATime",
       "deploymentGroupName": "dep-group-ghi-789-2",
       "ec2TagFilters": [
           {
               "Key": "Name",
               "Value": "Project-ABC",
               "Type": "KEY_AND_VALUE"
           }
       ],
       "serviceRoleArn": "arn:aws:iam::444455556666:role/AnyCompany-service-role",
       "triggerConfigurations": [
           {
               "triggerName": "Trigger-group-us-east-2",
               "triggerTargetArn": "arn:aws:sns:us-east-2:444455556666:us-east-deployments",
               "triggerEvents": [
                   "DeploymentStart",
                   "DeploymentSuccess",
                   "DeploymentFailure"
               ]
           }
       ]
   }
   ```

1. Salva gli aggiornamenti come file JSON e chiama il file utilizzando l'opzione `--cli-input-json` quando esegui il comando **create-deployment-group**:
**Importante**  
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.

   ```
   aws deploy create-deployment-group --cli-input-json file://filename.json
   ```

   Al termine del processo di creazione riceverai un messaggio di notifica di prova che indica che i dettagli delle autorizzazioni e dei trigger sono impostati correttamente.

### Per creare un trigger per l'invio di notifiche per un gruppo di distribuzione esistente
<a name="monitoring-sns-event-notifications-create-trigger-cli-existing"></a>

Per utilizzare l'opzione AWS CLI per aggiungere trigger per CodeDeploy eventi a un gruppo di distribuzione esistente, crea un file JSON per aggiornare il gruppo di distribuzione, quindi esegui il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando utilizzando l'opzione. `--cli-input-json` 

Il modo più semplice per creare il file JSON consiste nell'eseguire il comando **get-deployment-group** per ottenere una copia della configurazione del gruppo di distribuzione in formato JSON, quindi aggiornare i valori di parametro in un editor di testo normale.

1.  Eseguire il comando seguente, quindi copiare i risultati in un editor di testo normale.

   ```
   aws deploy get-deployment-group --application-name application --deployment-group-name deployment-group
   ```

1. Eliminare quanto segue dall'output:
   + Eliminare `{ "deploymentGroupInfo":` all'inizio dell'output.
   + Eliminare `}` alla fine dell'output. 
   + Eliminare la riga contenente `deploymentGroupId`.
   + Eliminare la riga contenente `deploymentGroupName`.

   Il contenuto del file di testo dovrebbe essere analogo al seguente:

   ```
   {
       "applicationName": "TestApp-us-east-2",
       "deploymentConfigName": "CodeDeployDefault.OneAtATime",
       "autoScalingGroups": [],
       "ec2TagFilters": [
           {
               "Type": "KEY_AND_VALUE",
               "Value": "Project-ABC",
               "Key": "Name"
           }
       ],
       "triggerConfigurations": [],
       "serviceRoleArn": "arn:aws:iam::444455556666:role/AnyCompany-service-role",
       "onPremisesInstanceTagFilters": []
   }
   ```

1. Nella sezione `triggerConfigurations` aggiungere i dati per i parametri `triggerEvents`, `triggerTargetArn` e `triggerName`. Per informazioni sui parametri di configurazione dei trigger, vedere. [TriggerConfig](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_TriggerConfig.html)

   Il contenuto del file di testo dovrebbe essere analogo al seguente. Questo codice richiede l'invio di notifiche ogni volta che viene avviata una distribuzione, indipendentemente dall'esito. 

   ```
   {
       "applicationName": "TestApp-us-east-2",
       "deploymentConfigName": "CodeDeployDefault.OneAtATime",
       "autoScalingGroups": [],
       "ec2TagFilters": [
           {
               "Type": "KEY_AND_VALUE",
               "Value": "Project-ABC",
               "Key": "Name"
           }
       ],
       "triggerConfigurations": [
           {
               "triggerEvents": [
                   "DeploymentStart",
                   "DeploymentSuccess",
                   "DeploymentFailure"
               ],
               "triggerTargetArn": "arn:aws:sns:us-east-2:444455556666:us-east-deployments",
               "triggerName": "Trigger-group-us-east-2"
           }
       ],
       "serviceRoleArn": "arn:aws:iam::444455556666:role/AnyCompany-service-role",
       "onPremisesInstanceTagFilters": []
   }
   ```

1. Salva gli aggiornamenti come file JSON, quindi esegui il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando utilizzando l'`--cli-input-json`opzione. Assicurati di includere l'`--current-deployment-group-name`opzione e di sostituire il nome del tuo file JSON con: *filename* 
**Importante**  
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.

   ```
   aws deploy update-deployment-group --current-deployment-group-name deployment-group-name --cli-input-json file://filename.json
   ```

   Al termine del processo di creazione riceverai un messaggio di notifica di prova che indica che i dettagli delle autorizzazioni e dei trigger sono impostati correttamente.

# Modifica un trigger in un gruppo di distribuzione CodeDeploy
<a name="monitoring-sns-event-notifications-edit-trigger"></a>

Se i requisiti di notifica cambiano, puoi modificare il trigger anziché crearne uno nuovo.

## CodeDeploy Modificare un trigger (CLI)
<a name="monitoring-sns-event-notifications-edit-trigger-cli"></a>

 Per utilizzare il comando AWS CLI per modificare i dettagli del trigger per CodeDeploy gli eventi quando aggiorni un gruppo di distribuzione, crea un file JSON per definire le modifiche alle proprietà del gruppo di distribuzione, quindi esegui il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html)comando con l'`--cli-input-json`opzione. 

Il modo più semplice per creare il file JSON consiste nell'eseguire il comando **get-deployment-group** per ottenere i dettagli correnti del gruppo di distribuzione in formato JSON, quindi modificare i valori richiesti in un editor di testo normale.

1. Esegui il comando seguente, sostituendo i nomi dell'applicazione e del gruppo di distribuzione con e: *application* *deployment-group*

   ```
   aws deploy get-deployment-group --application-name application --deployment-group-name deployment-group
   ```

1. Copiare i risultati del comando in un editor di testo normale ed eliminare quanto segue:
   + Eliminare `{ "deploymentGroupInfo":` all'inizio dell'output. 
   + Eliminare `}` alla fine dell'output. 
   + Eliminare la riga contenente `deploymentGroupId`.
   + Eliminare la riga contenente `deploymentGroupName`.

   Il contenuto del file di testo dovrebbe essere analogo al seguente:

   ```
   {
       "applicationName": "TestApp-us-east-2",
       "deploymentConfigName": "CodeDeployDefault.OneAtATime",
       "autoScalingGroups": [],
       "ec2TagFilters": [
           {
               "Type": "KEY_AND_VALUE",
               "Value": "East-1-Instances",
               "Key": "Name"
           }
       ],
       "triggerConfigurations": [
           {
               "triggerEvents": [
                   "DeploymentStart",
                   "DeploymentSuccess",
                   "DeploymentFailure",
                   "DeploymentStop"
               ],
               "triggerTargetArn": "arn:aws:sns:us-east-2:111222333444:Trigger-group-us-east-2",
               "triggerName": "Trigger-group-us-east-2"
           }
       ],
       "serviceRoleArn": "arn:aws:iam::444455556666:role/AnyCompany-service-role",
       "onPremisesInstanceTagFilters": []
   }
   ```

1. Modificare i parametri, se necessario. Per informazioni sui parametri di configurazione dei trigger, vedere. [TriggerConfig](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_TriggerConfig.html)

1. Salva gli aggiornamenti come file JSON, quindi esegui il [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html)comando utilizzando l'`--cli-input-json`opzione. Assicurati di includere l'`--current-deployment-group-name`opzione e di sostituire il nome del tuo file JSON con: *filename* 
**Importante**  
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.

   ```
   aws deploy update-deployment-group --current-deployment-group-name deployment-group-name --cli-input-json file://filename.json
   ```

Al termine del processo di creazione riceverai un messaggio di notifica di prova che indica che i dettagli delle autorizzazioni e dei trigger sono impostati correttamente.

# Eliminare un trigger da un gruppo di distribuzione CodeDeploy
<a name="monitoring-sns-event-notifications-delete-trigger"></a>

Dal momento che esiste un limite di 10 trigger per gruppo di distribuzione, è possibile eliminare i trigger non più utilizzati. Non è possibile annullare l'eliminazione di un trigger, ma è possibile ricreare un trigger eliminato.

## Eliminare un trigger da un gruppo di distribuzione (console)
<a name="monitoring-sns-event-notifications-delete-trigger-console"></a>

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

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

1. Nella pagina **Applications (Applicazioni)** scegliere il nome dell'applicazione associata al gruppo di distribuzione in cui si intende eliminare un trigger.

1. Nella pagina **Application details (Dettagli applicazione)** scegliere il gruppo di distribuzione in cui si desidera eliminare un trigger.

1.  Scegli **Modifica**. 

1.  Espandere **Advanced - optional (Opzioni avanzate - opzionale)**. 

1. Nell'area **Triggers (Trigger)** scegliere il trigger che si desidera eliminare, quindi scegliere **Delete trigger (Elimina trigger)**. 

1.  Scegli **Save changes** (Salva modifiche). 

## Eliminare un trigger da un gruppo di distribuzione (CLI)
<a name="monitoring-sns-event-notifications-delete-trigger-cli"></a>

Per eliminare un trigger utilizzando l'interfaccia a riga di comando, chiamare il comando [update-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/update-deployment-group.html) con i parametri di configurazione dei trigger vuoti, specificando:
+ Il nome dell'applicazione associata a questo gruppo di distribuzione. Per visualizzare un elenco di nomi di applicazioni, chiamate il comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ Il nome del gruppo di distribuzione associato a questa applicazione. Per visualizzare un elenco di nomi dei gruppi di distribuzione, chiama il comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).

Esempio:

```
aws deploy update-deployment-group --application-name application-name --current-deployment-group-name deployment-group-name --trigger-configurations
```

# Formati di dati JSON per i trigger CodeDeploy
<a name="monitoring-sns-event-notifications-json-format"></a>

Puoi utilizzare l'output JSON creato quando un trigger per una distribuzione o un'istanza viene attivato in un flusso di lavoro di notifica personalizzato, ad esempio l'invio di messaggi alle code di Amazon SQS o il richiamo di una funzione in. AWS Lambda

**Nota**  
In questa guida non viene spiegato come configurare le notifiche tramite JSON. Per informazioni sull'utilizzo di Amazon SNS per inviare messaggi alle code di Amazon SQS, consulta Invio di [messaggi Amazon SNS alle code Amazon SQS](https://docs.aws.amazon.com/sns/latest/dg/SendMessageToSQS.html). [Per informazioni sull'uso di Amazon SNS per richiamare una funzione Lambda, consulta Richiamare le funzioni Lambda utilizzando le notifiche Amazon SNS.](https://docs.aws.amazon.com/sns/latest/dg/sns-lambda.html)

I seguenti esempi illustrano la struttura dell'output JSON disponibile con i trigger CodeDeploy.

**Output JSON di esempio per trigger basati su istanze**

```
{
    "region": "us-east-2",
    "accountId": "111222333444",
    "eventTriggerName": "trigger-group-us-east-instance-succeeded",
    "deploymentId": "d-75I7MBT7C",
    "instanceId": "arn:aws:ec2:us-east-2:444455556666:instance/i-496589f7",
    "lastUpdatedAt": "1446744207.564",
    "instanceStatus": "Succeeded",
    "lifecycleEvents": [
        {
            "LifecycleEvent": "ApplicationStop",
            "LifecycleEventStatus": "Succeeded",
            "StartTime": "1446744188.595",
            "EndTime": "1446744188.711"
        },
        {
            "LifecycleEvent": "BeforeInstall",
            "LifecycleEventStatus": "Succeeded",
            "StartTime": "1446744189.827",
            "EndTime": "1446744190.402"
        }
//More lifecycle events might be listed here
    ]
}
```

**Output JSON di esempio per trigger basati su distribuzione**

```
{
    "region": "us-west-1",
    "accountId": "111222333444",
    "eventTriggerName": "Trigger-group-us-west-3-deploy-failed",
    "applicationName": "ProductionApp-us-west-3",
    "deploymentId": "d-75I7MBT7C",
    "deploymentGroupName": "dep-group-def-456",
    "createTime": "1446744188.595",
    "completeTime": "1446744190.402",
    "deploymentOverview": {
        "Failed": "10",
        "InProgress": "0",
        "Pending": "0",
        "Skipped": "0",
        "Succeeded": "0"
    },
    "status": "Failed",
    "errorInformation": {
        "ErrorCode": "IAM_ROLE_MISSING",
        "ErrorMessage": "IAM Role is missing for deployment group: dep-group-def-456"
    }
}
```