• La AWS Systems Manager CloudWatch dashboard non sarà più disponibile dopo il 30 aprile 2026. I clienti possono continuare a utilizzare la CloudWatch console Amazon per visualizzare, creare e gestire le proprie CloudWatch dashboard Amazon, proprio come fanno oggi. Per ulteriori informazioni, consulta la [documentazione di Amazon CloudWatch Dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html).
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à.
# AWS Systems Manager Run Command
Utilizzando uno strumento in Run Command AWS Systems Manager, è possibile gestire in remoto e in modo sicuro la configurazione dei nodi gestiti. Un *nodo gestito* è qualsiasi istanza o non EC2 macchina di Amazon Elastic Compute Cloud (Amazon EC2) nell'ambiente [ibrido e multicloud](operating-systems-and-machine-types.md#supported-machine-types) configurata per Systems Manager. Run Commandconsente di automatizzare le attività amministrative più comuni ed eseguire modifiche di configurazione una tantum su larga scala. È possibile utilizzare Run Command from Console di gestione AWS, the AWS Command Line Interface (AWS CLI) o. AWS Tools for Windows PowerShell AWS SDKs Run Commandè offerto senza costi aggiuntivi. Per cominciare a utilizzare Run Command, apri la [console di Systems Manager](https://console.aws.amazon.com//systems-manager/run-command). Nel pannello di navigazione, scegli **Run Command**.
Gli amministratori usano Run Command per eseguire l'installazione o il bootstrap delle applicazioni, creazione di una pipeline di implementazione, acquisizione di file di log quando un'istanza viene chiusa da un gruppo Auto Scaling e unione delle istanze a un dominio Windows.
L'API Run Command segue un modello di consistenza finale dovuto alla natura distribuita del sistema che supporta l'API. Ciò significa che il risultato di un comando API eseguito che influisce sulle risorse non è immediatamente visibile a tutti i comandi successivi eseguiti. È necessario tenerlo a mente quando si esegue un comando API che segue immediatamente un comando API precedente.
**Nozioni di base**
La tabella seguente include informazioni utili per iniziare a usare Run Command.
****
| Topic | Informazioni |
| --- | --- |
| [Configurazione di nodi gestiti per AWS Systems Manager](systems-manager-setting-up-nodes.md) | Verifica di aver completato i requisiti di configurazione per le tue istanze e non EC2 macchine Amazon Elastic Compute Cloud (Amazon EC2) in un ambiente [ibrido e multicloud](operating-systems-and-machine-types.md#supported-machine-types). |
| [Gestione dei nodi in ambienti ibridi e multicloud con Systems Manager](systems-manager-hybrid-multicloud.md) | (Facoltativo) Registra i server locali e in AWS questo modo potrai VMs gestirli utilizzando. Run Command |
| [Gestione dei dispositivi edge con Systems Manager](systems-manager-setting-up-edge-devices.md) | (Facoltativo) Configura i dispositivi edge in modo da poterli gestire utilizzando Run Command. |
| [Esecuzione di comandi su nodi gestiti](running-commands.md) | Scopri come eseguire un comando rivolto a uno o più nodi gestiti utilizzando il Console di gestione AWS. |
| [Spiegazioni passo per passo di Run Command](run-command-walkthroughs.md) | Scopri come eseguire i comandi utilizzando Tools for Windows PowerShell o. AWS CLI |
**EventBridge supporto**
Questo strumento Systems Manager è supportato sia come tipo di *evento* che come tipo di *destinazione* nelle EventBridge regole di Amazon. Per informazioni, consulta [Monitoraggio degli eventi di Systems Manager con Amazon EventBridge](monitoring-eventbridge-events.md) e [Riferimento: modelli e tipi di EventBridge eventi Amazon per Systems Manager](reference-eventbridge-events.md).
**Ulteriori informazioni**
+ [Run CommandIn remoto su un' EC2 istanza (tutorial di 10 minuti)](https://aws.amazon.com/getting-started/hands-on/remotely-run-commands-ec2-instance-systems-manager/)
+ [Service Quotas di Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) nella *Riferimenti generali di Amazon Web Services*
+ [AWS Systems Manager Documentazione di riferimento delle API](https://docs.aws.amazon.com/systems-manager/latest/APIReference/)
**Topics**
+ [Configurazione di Run Command](run-command-setting-up.md)
+ [Esecuzione di comandi su nodi gestiti](running-commands.md)
+ [Utilizzo dei codici di uscita nei comandi](run-command-handle-exit-status.md)
+ [Informazioni sugli stati dei comandi](monitor-commands.md)
+ [Spiegazioni passo per passo di Run Command](run-command-walkthroughs.md)
+ [Risoluzione dei problemi di Systems Manager](troubleshooting-remote-commands.md)
# Configurazione di Run Command
Prima di poter gestire i nodi utilizzandoRun Command, uno strumento in AWS Systems Manager, configura una policy AWS Identity and Access Management (IAM) per qualsiasi utente che eseguirà i comandi. Quando utilizzi delle chiavi di condizione globali per l'azione `SendCommand` nelle policy IAM, è necessario includere la chiave di condizione `aws:ViaAWSService` e impostare il valore booleano su `true`. Di seguito è riportato un esempio di :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"StringEquals": {
"aws:SourceVpce": [
"vpce-1234567890abcdef0"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"Bool": {
"aws:ViaAWSService": "true"
}
}
}
]
}
```
------
È necessario anche configurare i nodi per Systems Manager. Per ulteriori informazioni, consulta [Configurazione di nodi gestiti per AWS Systems Manager](systems-manager-setting-up-nodes.md).
Ti consigliamo di completare le seguenti attività di configurazione opzionali per ridurre al minimo il livello di sicurezza e la day-to-day gestione dei nodi gestiti.
Monitora l'esecuzione dei comandi con Amazon EventBridge
Puoi utilizzarlo EventBridge per registrare le modifiche allo stato di esecuzione dei comandi. È possibile scegliere di creare una regola che venga eseguita ogni volta che si verifica una transizione di stato o quando si verifica una transizione verso uno o più stati di interesse. È inoltre possibile specificare Run Command come azione target quando si verifica un EventBridge evento. Per ulteriori informazioni, consulta [Configurazione EventBridge per gli eventi di Systems Manager](monitoring-systems-manager-events.md).
Monitora l'esecuzione dei comandi utilizzando Amazon Logs CloudWatch
Puoi Run Command configurare l'invio periodico di tutti gli output dei comandi e i log degli errori a un gruppo di CloudWatch log Amazon. È possibile monitorare i log di output in tempo quasi reale, cercare locuzioni, valori o modelli specifici e creare allarmi in base alla ricerca. Per ulteriori informazioni, consulta [Configurazione di Amazon CloudWatch Logs per Run Command](sysman-rc-setting-up-cwlogs.md).
Restrict Run Command accesso a nodi gestiti specifici
Puoi limitare la capacità di un utente di eseguire comandi su nodi gestiti utilizzando AWS Identity and Access Management (IAM). In particolare, è possibile creare una policy IAM con una condizione in base alla quale l'utente può eseguire i comandi solo sui nodi gestiti contrassegnati con tag specifici. Per ulteriori informazioni, consulta [Limitazione dell'accesso Run Command in base ai tag](#tag-based-access).
## Limitazione dell'accesso Run Command in base ai tag
Questa sezione descrive come limitare la capacità di un utente di eseguire comandi sui nodi gestiti specificando una condizione di tag in una policy IAM. I nodi gestiti includono EC2 istanze Amazon e non EC2 nodi in un ambiente [ibrido e multicloud](operating-systems-and-machine-types.md#supported-machine-types) configurato per Systems Manager. Sebbene le informazioni non siano presentate in modo esplicito, puoi anche limitare l'accesso ai dispositivi principali gestiti. AWS IoT Greengrass Per iniziare, devi tagging dei dispositivi AWS IoT Greengrass . Per ulteriori informazioni, consulta [Applicazione di tag alle risorse di AWS IoT Greengrass Version 2](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass Version 2 *.
È possibile limitare l'esecuzione dei comandi a nodi gestiti specifici creando una policy IAM che include una condizione in base alla quale l'utente può eseguire i comandi solo sui nodi a cui sono applicati tag specifici. Nell'esempio seguente, l'utente può utilizzare Run Command (`Effect: Allow, Action: ssm:SendCommand`) utilizzando qualsiasi documento SSM () su qualsiasi nodo (`Resource: arn:aws:ssm:*:*:document/*``Resource: arn:aws:ec2:*:*:instance/*`) a condizione che il nodo sia un Finance WebServer (`ssm:resourceTag/Finance: WebServer`). Se l'utente invia un comando a un nodo privo di tag o con un tag diverso da `Finance: WebServer`, i risultati dell'esecuzione mostrano `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:*:*:document/*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ec2:*:*:instance/*"
],
"Condition":{
"StringLike":{
"ssm:resourceTag/Finance":[
"WebServers"
]
}
}
}
]
}
```
------
È possibile creare policy IAM che permettono a un utente di eseguire comandi su nodi gestiti contrassegnati con più tag. La policy seguente consente all'utente di eseguire comandi su nodi gestiti che dispongono di due tag. Se l'utente invia un comando a un nodo non contrassegnato con questi due tag, i risultati dell'esecuzione mostrano `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
],
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
È anche possibile creare policy IAM che consentono a un utente di eseguire comandi su più gruppi di nodi gestiti con tag. La policy di esempio seguente consente all'utente di eseguire comandi su uno o su entrambi i gruppi di nodi con tag.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Per ulteriori informazioni sulla creazione di policy IAM, consulta la pagina [Policy gestite e policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html) nella *Guida per l'utente IAM*. Per ulteriori informazioni sull'aggiunta di tag ai nodi gestiti, consulta [Editor di tag](https://docs.aws.amazon.com/ARG/latest/userguide/tag-editor.html) nella *AWS Resource Groups Guida per l'utente di*.
# Esecuzione di comandi su nodi gestiti
Questa sezione include informazioni su come inviare i comandi dalla console AWS Systems Manager a nodi gestiti. Questa sezione include anche informazioni su come annullare un comando.
Nota che se il tuo nodo è configurato con l'opzione `noexec` mount per la directory var, non Run Command è in grado di eseguire correttamente i comandi.
**Importante**
Quando si invia un comando utilizzando Run Command, non includere informazioni riservate formattate come testo normale, ad esempio password, dati di configurazione o altri segreti. Tutte le attività dell'API Systems Manager nel tuo account vengono registrate in un bucket S3 per i log. AWS CloudTrail Ciò significa che qualsiasi utente con accesso a quel bucket S3 può visualizzare i valori in testo normale di quei segreti. Per questo motivo, si consiglia vivamente di creare e utilizzare parametri `SecureString` per crittografare i dati sensibili utilizzati nelle operazioni di Systems Manager.
Per ulteriori informazioni, consulta [Limitazione dell'accesso ai parametri Parameter Store mediante policy IAM](sysman-paramstore-access.md).
**La cronologia di esecuzione dell'esecuzione**
La cronologia di ciascun comando è disponibile per 30 giorni. Inoltre è possibile archiviare una copia di tutti i file di log in Amazon Simple Storage Service o ottenere un percorso di verifica di tutte le chiamate API in AWS CloudTrail.
**Informazioni correlate**
Per informazioni sull'invio di comandi tramite altri strumenti, consulta i seguenti argomenti:
+ [Procedura dettagliata: utilizzare con AWS Tools for Windows PowerShell Run Command](walkthrough-powershell.md)o gli esempi nella [AWS Systems Manager sezione del AWS Strumenti per PowerShell Cmdlet Reference](https://docs.aws.amazon.com/powershell/latest/reference/items/AWS_Systems_Manager_cmdlets.html).
+ [Procedura dettagliata: utilizzare con AWS CLI Run Command](walkthrough-cli.md)o gli esempi nel riferimento alla CLI di riferimento di [SSM](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
**Topics**
+ [Esecuzione di comandi dalla console](running-commands-console.md)
+ [Esecuzione di comandi utilizzando una versione specifica del documento](run-command-version.md)
+ [Esecuzione di comandi su vasta scala](send-commands-multiple.md)
+ [Annullamento di un comando](cancel-run-command.md)
# Esecuzione di comandi dalla console
È possibile utilizzareRun Command, uno strumento in AWS Systems Manager, Console di gestione AWS per configurare i nodi gestiti senza dover accedere a essi. Questo argomento include un esempio che mostra come [aggiornare SSM Agent](run-command-tutorial-update-software.md#rc-console-agentexample) su un nodo gestito utilizzando Run Command.
**Prima di iniziare**
Prima di inviare un comando utilizzando Run Command verifica che i nodi gestiti soddisfino tutti i [requisiti di configurazione](systems-manager-setting-up-nodes.md) di Systems Manager.
**Per inviare un comando utilizzando Run Command**
1. Apri la AWS Systems Manager console all'indirizzo [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Nel pannello di navigazione, scegliere **Run Command**.
1. Selezionare **Run command (Esegui comando)**.
1. Nell'elenco **Command document (Documento comando)**, scegliere un documento di Systems Manager.
1. Nella sezione **Command parameters (Parametri di comando)** specificare i valori per i parametri necessari.
1. In **Targets (Destinazioni)**, scegliere i nodi gestiti in cui si desidera eseguire questa operazione specificando i tag, selezionando le istanze o i dispositivi edge manualmente o indicando un gruppo di risorse.
**Suggerimento**
Se un nodo gestito che ti aspetti di vedere non è presente nell'elenco, consulta [Risoluzione dei problemi relativi alla disponibilità dei nodi gestiti](fleet-manager-troubleshooting-managed-nodes.md) per suggerimenti sulla risoluzione dei problemi.
1. In **Other parameters (Altri parametri)**:
+ In **Comment (Commento)** digitare le informazioni su questo comando.
+ In **Timeout (seconds) (Timeout [secondi])**, specificare il numero di secondi che il sistema dovrà attendere prima di generare un errore per l'intera esecuzione del comando.
1. Per **Rate control (Controllo velocità)**:
+ In **Concurrency (Simultaneità)**, specificare un numero o una percentuale di nodi gestiti su cui eseguire contemporaneamente il comando.
**Nota**
Se hai selezionato le destinazioni specificando i tag applicati ai nodi gestiti o specificando i gruppi di AWS risorse e non sei sicuro del numero di nodi gestiti come target, limita il numero di destinazioni che possono eseguire il documento contemporaneamente specificando una percentuale.
+ Per **Error threshold (Soglia di errore)** specificare quando interrompere l'esecuzione del comando sulle altri nodi gestiti dopo un errore su un numero o una percentuale di nodi. Se ad esempio si specificano 3 errori, Systems Manager interrompe l'invio del comando quando riceve il quarto errore. Anche i nodi gestiti che stanno ancora elaborando il comando potrebbero inviare errori.
1. (Facoltativo) Scegliete un CloudWatch allarme da applicare al comando di monitoraggio. Per allegare un CloudWatch allarme al tuo comando, il principale IAM che esegue il comando deve disporre dell'autorizzazione per l'`iam:createServiceLinkedRole`azione. Per ulteriori informazioni sugli CloudWatch allarmi, consulta [Using Amazon CloudWatch alarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html). Si noti che se l'allarme si attiva, qualsiasi chiamata di comando in sospeso non viene eseguita.
1. (Opzionale) Nella sezione **Output options (Opzioni di output)**, per salvare l'output del comando in un file, selezionare la casella **Write command output to an S3 bucket (Scrivi l'output del comando in un bucket S3)**. Digita i nomi del bucket e del prefisso (cartella) nelle caselle.
**Nota**
Le autorizzazioni S3 che garantiscono la possibilità di scrivere i dati in un bucket S3 sono quelle del profilo dell'istanza (per le EC2 istanze) o del ruolo di servizio IAM (macchine ad attivazione ibrida) assegnato all'istanza, non quelle dell'utente IAM che esegue questa attività. Per ulteriori informazioni, consulta le pagine [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md) oppure [Creazione di un ruolo di servizio IAM per un ambiente ibrido](hybrid-multicloud-service-role.md). Inoltre, se il bucket S3 specificato si trova su un Account AWS diverso, assicurarsi che il profilo dell'istanza o il ruolo di servizio IAM associato al nodo gestito disponga delle autorizzazioni necessarie per scrivere su quel bucket.
1. Se si desidera che vengano inviate notifiche sullo stato dell'esecuzione del comando, nella sezione **SNS notifications (Notifiche SNS)** selezionare la casella di controllo **Enable SNS notifications (Abilita notifiche SNS)**.
Per ulteriori informazioni sulla configurazione delle notifiche Amazon SNS per Run Command, consulta [Monitoraggio delle modifiche di stato di Systems Manager utilizzando le notifiche Amazon SNS](monitoring-sns-notifications.md).
1. Selezionare **Esegui**.
Per informazioni su come annullare un comando, consulta [Annullamento di un comando](cancel-run-command.md).
## Riesecuzione dei comandi
Systems Manager include due opzioni che consentono di eseguire nuovamente un comando dalla pagina **Esegui comando** nella console Systems Manager.
+ **Rieseguire**: questo pulsante consente di eseguire lo stesso comando senza apportare modifiche.
+ **Copia su nuovo**: questo pulsante copia le impostazioni di un comando in un nuovo comando e ti dà la possibilità di modificare tali impostazioni prima di eseguirlo.
**Per eseguire nuovamente un comando**
1. AWS Systems Manager [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)Apri la console all'indirizzo.
1. Nel pannello di navigazione, scegliere **Run Command**.
1. Scegliere un comando da eseguire nuovamente. È possibile eseguire nuovamente un comando immediatamente dopo averlo eseguito dalla pagina dei dettagli del comando. In alternativa, è possibile scegliere un comando eseguito in precedenza dalla scheda **Cronologia comandi** .
1. Scegliere **Rieseguire** per eseguire lo stesso comando senza modifiche oppure scegliere **Copia in nuovo** per modificare le impostazioni dei comandi prima di eseguirli.
# Esecuzione di comandi utilizzando una versione specifica del documento
Il parametro document-version consente di specificare quale versione di un documento AWS Systems Manager utilizzare quando viene eseguito il comando. È possibile specificare una delle seguenti opzioni per questo parametro:
+ \$1DEFAULT
+ \$1LATEST
+ Numero di versione
Usa la procedura seguente per eseguire un comando utilizzando il parametro document-version.
------
#### [ Linux ]
**Per eseguire comandi utilizzando AWS CLI le macchine Linux locali**
1. Installa e configura AWS Command Line Interface (AWS CLI), se non l'hai già fatto.
Per informazioni, consulta la pagina [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Creare un elenco di tutti i documenti disponibili
Questo comando elenca tutti i documenti disponibili per il tuo account in base alle autorizzazioni AWS Identity and Access Management (IAM).
```
aws ssm list-documents
```
1. Esegui il comando seguente per visualizzare le diverse versioni di un documento. *document name*Sostituiscili con le tue informazioni.
```
aws ssm list-document-versions \
--name "document name"
```
1. Esegui il comando seguente per eseguire un comando che usa una versione del documento SSM. Sostituisci ogni *example resource placeholder* con le tue informazioni.
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--parameters commands="echo Hello" \
--instance-ids instance-ID \
--document-version '$LATEST'
```
------
#### [ Windows ]
**Per eseguire comandi utilizzando i AWS CLI computer Windows locali**
1. Installa e configura AWS Command Line Interface (AWS CLI), se non l'hai già fatto.
Per informazioni, consulta la pagina [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Creare un elenco di tutti i documenti disponibili
Questo comando elenca tutti i documenti disponibili per il tuo account in base alle autorizzazioni AWS Identity and Access Management (IAM).
```
aws ssm list-documents
```
1. Esegui il comando seguente per visualizzare le diverse versioni di un documento. *document name*Sostituiscili con le tue informazioni.
```
aws ssm list-document-versions ^
--name "document name"
```
1. Esegui il comando seguente per eseguire un comando che usa una versione del documento SSM. Sostituisci ogni *example resource placeholder* con le tue informazioni.
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--parameters commands="echo Hello" ^
--instance-ids instance-ID ^
--document-version "$LATEST"
```
------
#### [ PowerShell ]
**Per eseguire comandi utilizzando gli strumenti per PowerShell**
1. Installa e configura AWS Strumenti per PowerShell (Strumenti per Windows PowerShell), se non l'hai già fatto.
Per informazioni, consulta la pagina [Installazione di AWS Strumenti per PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
1. Creare un elenco di tutti i documenti disponibili
Questo comando elenca tutti i documenti disponibili per il tuo account in base alle autorizzazioni AWS Identity and Access Management (IAM).
```
Get-SSMDocumentList
```
1. Esegui il comando seguente per visualizzare le diverse versioni di un documento. *document name*Sostituiscili con le tue informazioni.
```
Get-SSMDocumentVersionList `
-Name "document name"
```
1. Esegui il comando seguente per eseguire un comando che usa una versione del documento SSM. Sostituisci ogni *example resource placeholder* con le tue informazioni.
```
Send-SSMCommand `
-DocumentName "AWS-RunShellScript" `
-Parameter @{commands = "echo helloWorld"} `
-InstanceIds "instance-ID" `
-DocumentVersion $LATEST
```
------
# Esecuzione di comandi su vasta scala
È possibile utilizzareRun Command, uno strumento in AWS Systems Manager, per eseguire comandi su una flotta di nodi gestiti utilizzando il`targets`. Il parametro `targets` accetta una combinazione `Key,Value` in base ai tag specificati per i nodi gestiti. Quando si esegue il comando, il sistema individua e tenta di eseguire il comando su tutti i nodi gestiti che corrispondono ai tag specificati. Per ulteriori informazioni sull'etichettatura delle istanze gestite, consulta [Tagging your AWS resources nella Tagging](https://docs.aws.amazon.com/tag-editor/latest/userguide/tag-editor.html) Resources User * AWS Guide*. Per informazioni sull'etichettatura dei dispositivi IoT gestiti, consulta [Etichettare le AWS IoT Greengrass Version 2 risorse](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) nella *Guida per gli AWS IoT Greengrass Version 2 sviluppatori*.
Puoi anche utilizzare il `targets` parametro per indirizzare un elenco di nodi gestiti specifici IDs, come descritto nella sezione successiva.
Per controllare l'esecuzione del comando su centinaia o migliaia di nodi gestiti, Run Command include anche i parametri per limitare il numero di nodi che possono elaborare contemporaneamente una richiesta e il numero di errori che possono essere generati da un comando prima che venga terminato.
**Topics**
+ [Impostare come destinazione più nodi gestiti](#send-commands-targeting)
+ [Utilizzo dei controlli di velocità](#send-commands-rate)
## Impostare come destinazione più nodi gestiti
È possibile eseguire un comando e scegliere come target i nodi gestiti specificando tag, nomi di gruppi di AWS risorse o nodi IDs gestiti.
Gli esempi seguenti mostrano il formato del comando quando si utilizza Run Command from the AWS Command Line Interface (AWS CLI ). Sostituisci ogni *example resource placeholder* con le tue informazioni. I comandi di esempio in questa sezione sono troncati utilizzando `[...]`.
**Esempio 1: definizione di tag come target**
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:tag-name,Values=tag-value \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:tag-name,Values=tag-value ^
[...]
```
------
**Esempio 2: Individuazione di un gruppo di AWS risorse in base al nome**
Puoi specificare un massimo di un nome del gruppo di risorse per comando. Quando crei un gruppo di risorse, ti consigliamo di includere `AWS::SSM:ManagedInstance` e `AWS::EC2::Instance` come tipi di risorse nei criteri di raggruppamento.
**Nota**
Per inviare comandi destinati a un gruppo di risorse, è necessario disporre delle autorizzazioni AWS Identity and Access Management (IAM) per elencare o visualizzare le risorse che appartengono a quel gruppo. Per ulteriori informazioni, consulta [Impostazione delle autorizzazioni](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) nella *Guida per l'utente di AWS Resource Groups *.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:Name,Values=resource-group-name \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:Name,Values=resource-group-name ^
[...]
```
------
**Esempio 3: Individuazione di un gruppo di risorse per tipo di AWS risorsa**
Puoi specificare un massimo di un nome del gruppo di risorse per comando. Quando crei un gruppo di risorse, ti consigliamo di includere `AWS::SSM:ManagedInstance` e `AWS::EC2::Instance` come tipi di risorse nei criteri di raggruppamento.
**Nota**
Per inviare comandi destinati a un gruppo di risorse, è necessario disporre di autorizzazioni IAM per elencare o visualizzare le risorse che appartengono a tale gruppo. Per ulteriori informazioni, consulta [Impostazione delle autorizzazioni](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) nella *Guida per l'utente di AWS Resource Groups *.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 ^
[...]
```
------
**Esempio 4: istanza di targeting IDs**
Gli esempi seguenti mostrano come destinazione i nodi gestiti utilizzando il `instanceids` Chiave con il parametro `targets`. È possibile utilizzare questa chiave per indirizzare i dispositivi AWS IoT Greengrass core gestiti perché a ciascun dispositivo viene assegnato un mi-*ID\$1number*. È possibile visualizzare il dispositivo IDs inFleet Manager, uno strumento in AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 ^
[...]
```
------
Se hai aggiunto tag ai nodi gestiti per diversi ambienti usando una `Key` denominata `Environment` e `Values` pari a `Development`, `Test`, `Pre-production` e `Production`, puoi inviare un comando a tutti i nodi gestiti in *uno* degli ambienti utilizzando il parametro `targets` con la seguente sintassi.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
------
Puoi definire altri nodi gestiti come destinazione in altri ambienti aggiungendo voci all'elenco `Values`. Separa gli elementi con le virgole.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development,Test,Pre-production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development,Test,Pre-production ^
[...]
```
------
**Variazione**: perfezionamento dei target utilizzando più criteri `Key`
È possibile perfezionare il numero di target per il comando includendo più criteri `Key`. Se si includono più criteri `Key`, vengono definite come destinazioni i nodi gestiti che soddisfano *tutti* i criteri. Il comando seguente definisce come destinazione tutti i nodi gestiti taggati per il reparto finanze *e* taggati per il ruolo server di database.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database ^
[...]
```
------
**Variazione**: utilizzo di più criteri `Key` e `Value`
Espandendo l'esempio precedente, è possibile definire più reparti e più ruoli server come target includendo altri elementi nei criteri `Values`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
**Variazione**: definizione di nodi gestiti con tag come destinazione utilizzando più criteri `Values`
Se hai applicato tag a nodi gestiti per diversi ambienti usando un oggetto `Key` denominato `Department` e `Values` corrispondente a `Sales` e `Finance`, puoi inviare un comando a tutti i nodi gestiti in questi ambienti utilizzando il parametro `targets` con la sintassi seguente.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Sales,Finance \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Sales,Finance ^
[...]
```
------
È possibile specificare un massimo di cinque chiavi e cinque valori per ogni chiave.
Se una chiave tag (il nome del tag) o un valore tag include spazi, devi racchiudere tra virgolette la chiave o il valore tag, come mostrato nei seguenti esempi.
**Esempio**: spazi nel tag `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:OS,Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:OS,Values="Windows Server 2016" ^
[...]
```
------
**Esempio**: spazi nella chiave `tag` e `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key="tag:Operating System",Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key="tag:Operating System",Values="Windows Server 2016" ^
[...]
```
------
**Esempio**: spazi in un elemento in un elenco di `Values`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" ^
[...]
```
------
## Utilizzo dei controlli di velocità
Puoi controllare la velocità con cui i comandi vengono inviati ai nodi gestiti di un gruppo utilizzando *controlli di concorrenza * e *controlli di errore*.
**Topics**
+ [Utilizzo di controlli di concorrenza](#send-commands-velocity)
+ [Utilizzo dei controlli degli errori](#send-commands-maxerrors)
### Utilizzo di controlli di concorrenza
Puoi controllare il numero di nodi gestiti che eseguono il comando contemporaneamente utilizzando il parametro `max-concurrency` (le opzioni **Simultaneità** nella pagina **Esegui un comando**). Puoi specificare un numero assoluto di nodi gestiti, ad esempio **10**, oppure una percentuale del set di target, ad esempio **10%**. Il sistema di accodamento invia il comando a un singolo nodo e attende il completamento dell'invocazione iniziale prima di inviare il comando ad altri due nodi. Il sistema invia comandi ad altri nodi in modo esponenziale fino al raggiungimento del valore `max-concurrency`. Il valore predefinito per `max-concurrency` è 50. Gli esempi seguenti mostrano come specificare valori per il parametro `max-concurrency`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10 \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10% \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10 ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10% ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
### Utilizzo dei controlli degli errori
Puoi anche controllare l'esecuzione di un comando su centinaia o migliaia di nodi gestiti impostando un limite di errori usando i parametri `max-errors` (il campo **Soglia di errore** nella pagina **Esegui un comando**). Il parametro specifica il numero di errori consentiti prima che il sistema smetta di inviare il comando ad altri nodi gestiti. Puoi specificare un numero assoluto di errori, ad esempio **10**, oppure una percentuale della serie di target, ad esempio **10%**. Se ad esempio specifichi **3**, il sistema smette di inviare il comando quando riceve il quarto errore. Se specifichi **0**, il sistema smette di inviare il comando ad altri nodi gestiti non appena viene restituito il primo risultato di errore. Se invii un comando a 50 nodi gestiti e imposti `max-errors` su **10%**, il sistema smette di inviare il comando ad altri nodi quando riceve il sesto errore.
Per le invocazioni che stanno già eseguendo un comando quando viene raggiunto il valore `max-errors`, viene consentito il completamento dell'operazione, ma alcune di queste invocazioni potrebbero non riuscire. Per evitare che si verifichino più di `max-errors` invocazioni non riuscite, imposta `max-concurrency` su **1** in modo che le invocazioni procedano una alla volta. Il valore predefinito per max-errors è 0. Gli esempi seguenti mostrano come specificare valori per il parametro `max-errors`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-errors 10 \
--targets Key=tag:Database,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-errors 10% \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 1 \
--max-errors 1 \
--targets Key=tag:Environment,Values=Production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10 ^
--targets Key=tag:Database,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10% ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 1 ^
--max-errors 1 ^
--targets Key=tag:Environment,Values=Production ^
[...]
```
------
# Annullamento di un comando
Puoi tentare di annullare un comando finché il servizio mostra che il suo stato è in attesa o in esecuzione. Anche se un comando si trova in uno di questi stati, però, non siamo in grado di garantire che verrà terminato e che il processo sottostante verrà arrestato.
**Per annullare un comando usando la console**
1. Aprire la console AWS Systems Manager all'indirizzo [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Nel pannello di navigazione, scegli **Run Command**.
1. Selezionare l'invocazione del comando da annullare.
1. Scegliere **Cancel command (Annulla comando)**.
**Per annullare un comando usando l'AWS CLI**
Esegui il comando seguente. Sostituisci ciascun *segnaposto delle risorse di esempio* con le tue informazioni.
------
#### [ Linux & macOS ]
```
aws ssm cancel-command \
--command-id "command-ID" \
--instance-ids "instance-ID"
```
------
#### [ Windows ]
```
aws ssm cancel-command ^
--command-id "command-ID" ^
--instance-ids "instance-ID"
```
------
Per ulteriori informazioni sullo stato di un comando annullato, consulta [Informazioni sugli stati dei comandi](monitor-commands.md).
# Utilizzo dei codici di uscita nei comandi
In alcuni casi, potrebbe essere necessario controllare la modalità di gestione dei comandi utilizzando i codici di uscita.
## Specifica dei codici di uscita nei comandi
Utilizzando Run Command, uno strumento di AWS Systems Manager, è possibile specificare i codici di uscita per determinare il modo in cui vengono gestiti i comandi. Per impostazione predefinita, il codice di uscita dell'ultimo comando eseguito in uno script viene segnalato come codice di uscita per l'intero script. Ad esempio, si dispone di uno script che contiene tre comandi. Il primo non riesce, ma i seguenti riescono. Poiché il comando finale è riuscito, lo stato dell'esecuzione viene segnalato come `succeeded`.
**Script di shell**
Per chiudere con esito negativo l'intero comando al primo errore, è possibile includere un'istruzione condizionale della shell per uscire dallo script se un comando precedente a quello finale non riesce. Utilizzare l'approccio seguente.
```
if [ $? != 0 ]
then
exit
fi
```
Nell'esempio seguente, l'intero script ha esito negativo se il primo comando non riesce.
```
cd /test
if [ $? != 0 ]
then
echo "Failed"
exit 1
fi
date
```
**Script di PowerShell**
PowerShell richiede di richiamare esplicitamente `exit` negli script affinché Run Command possa acquisire correttamente il codice di uscita.
```
if ($?) {}
else {exit }
exit
```
Ecco un esempio:
```
cd C:\
if ($?) {echo "Success"}
else {exit 1}
date
```
# Gestione di riavvii durante l'esecuzione dei comandi
Se utilizziRun Command, uno strumento in AWS Systems Manager, per eseguire script che riavviano i nodi gestiti, ti consigliamo di specificare un codice di uscita nello script. Se tenti di riavviare un nodo da uno script utilizzando altri meccanismi, lo stato di esecuzione di script potrebbe non essere aggiornato correttamente, anche se il riavvio è l'ultimo passaggio nel tuo script. Per i nodi gestiti da Windows, è necessario specificare `exit 3010` nello script. Per i nodi gestiti Linux e macOS, è necessario specificare `exit 194`. Il codice di uscita indica ad AWS Systems Manager Agent (SSM Agent) di riavviare il nodo gestito e quindi di riavviare lo script al termine del riavvio. Prima di iniziare il riavvio,SSM Agent notifica al servizio Systems Manager nel cloud che le comunicazioni verranno interrotte durante il riavvio dei server.
**Nota**
Lo script di riavvio non può fare parte di un`aws:runDocument`. Se un documento contiene lo script di riavvio e un altro documento tenta di eseguirlo tramite il plug-in `aws:runDocument`, SSM Agent causerà un errore.
**Creare script idempotenti**
Quando sviluppi script che riavviano i nodi gestiti, rendi idempotenti gli script in modo che la loro esecuzione prosegua dal punto in cui si è interrotta dopo il riavvio. Gli script idempotenti gestiscono lo stato e verificano se l'operazione è stata eseguita o meno. Questo evita che una fase venga eseguita più volte quando è concepita per un'esecuzione singola.
Ecco un esempio generale di script idempotente che riavvia il nodo gestito più volte.
```
$name = Get current computer name
If ($name –ne $desiredName)
{
Rename computer
exit 3010
}
$domain = Get current domain name
If ($domain –ne $desiredDomain)
{
Join domain
exit 3010
}
If (desired package not installed)
{
Install package
exit 3010
}
```
**Esempi**
I seguenti esempi di script usano codici di uscita per riavviare i nodi gestiti. L'esempio Linux installa gli aggiornamenti del pacchetto in e riavvia il nodo. L'esempio di Windows Server installa l'applicazione Hyper-V sul nodo e quindi lo riavvia.
------
#### [ Amazon Linux 2 ]
```
#!/bin/bash
yum -y update
needs-restarting -r
if [ $? -eq 1 ]
then
exit 194
else
exit 0
fi
```
------
#### [ Windows ]
```
$telnet = Get-WindowsFeature -Name Telnet-Client
if (-not $telnet.Installed)
{
# Install Telnet and then send a reboot request to SSM Agent.
Install-WindowsFeature -Name "Telnet-Client"
exit 3010
}
```
------
# Informazioni sugli stati dei comandi
Run Command, uno strumento in AWS Systems Manager, riporta informazioni dettagliate sullo stato dei diversi stati sperimentati da un comando durante l'elaborazione e per ogni nodo gestito che ha elaborato il comando. È possibile monitorare lo stato dei comando usando i metodi seguenti.
+ Scegli l'icona **Refresh** (Aggiorna) della scheda **Commands** (Comandi) nell'interfaccia della console Run Command.
+ Chiama [list-commands](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-commands.html) o [list-command-invocations](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-command-invocations.html)usa il AWS Command Line Interface ()AWS CLI. Oppure chiama [Get- SSMCommand](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommand.html) o [Get- SSMCommand Invocation usando](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommandInvocation.html). AWS Tools for Windows PowerShell
+ Configura Amazon EventBridge per rispondere ai cambiamenti di stato o di stato.
+ Configura Amazon Simple Notification Service (Amazon SNS) per l'invio di notifiche relative a tutte le modifiche di stato o a stati specifici come `Failed` o `TimedOut`.
## Stato di Run Command
Run Command indica dettagli di stato per tre aree: plugin, invocazioni e stato generale dei comandi. Un *plugin* è un blocco di esecuzione di codice definito nel documento del comando. Per ulteriori informazioni sui plugin , consulta [Documentazione di riferimento del plugin per i documenti di comando](documents-command-ssm-plugin-reference.md).
Quando si invia un comando a più nodi gestiti contemporaneamente, ogni copia del documento destinata a ogni nodo è denominata *invocazione di comando*. Ad esempio, se usi il documento `AWS-RunShellScript` e invii un comando `ifconfig` a 20 istanze, quel comando ha 20 invocazioni. Ogni invocazione di comando segnala lo stato individualmente. Anche i plugin per una determinata invocazione di comando segnalano lo stato individualmente.
Infine, Run Command include uno stato di comando aggregato per tutti i plugin e le invocazioni. Lo stato di comando aggregato può essere diverso rispetto allo stato segnalato dai plugin o dalle invocazioni, come mostrato nelle tabelle seguenti.
**Nota**
Se si eseguono comandi su un numero elevato di nodi gestiti utilizzando i parametri `max-concurrency` o `max-errors`, lo stato dei comandi riflette le limitazioni imposte da quei parametri, come descritto nelle tabelle seguenti. Per ulteriori informazioni su questi parametri, consultare [Esecuzione di comandi su vasta scala](send-commands-multiple.md).
**Stato dettagliato per i plugin e le invocazioni dei comandi**
| Status | Informazioni |
| --- | --- |
| Pending (In attesa) | Il comando non è stato ancora inviato al nodo gestito o non è stato ricevuto da SSM Agent. Se il comando non viene ricevuto dall'agente prima che passi il tempo che è uguale alla somma delTimeout (secondi)e il parametroExecution timeout (Timeout di esecuzione)Parametro, lo stato cambia inDelivery Timed Out. |
| InProgress | Systems Manager sta tentando di inviare il comando al nodo gestito oppure il comando è stato ricevuto da SSM Agent e ha iniziato a funzionare sull'istanza. A seconda del risultato di tutti i plugin dei comandi, lo stato passerà a Success, Failed, Delivery Timed Out o Execution Timed Out. Eccezione: se l'agente non è in esecuzione o è disponibile nel nodo, lo stato del comando rimane in In Progress finché l'agente non è nuovamente disponibile o fino al raggiungimento del limite di timeout di esecuzione. Lo stato passerà quindi a uno stato terminale. |
| Ritardato | Il sistema ha tentato di inviare il comando al nodo gestito, ma non è riuscito. Il sistema riprova. |
| Completato | Questo stato viene restituito in diverse condizioni. Questo stato non significa che il comando è stato elaborato correttamente sul nodo. Ad esempio, il comando può essere ricevuto dal SSM Agent nodo gestito e restituire un codice di uscita pari a zero come risultato dell' PowerShell ExecutionPolicyimpossibilità dell'esecuzione del comando. Si tratta di uno stato terminale. Le condizioni che determinano la restituzione di uno stato Success da un comando sono: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/monitor-commands.html) Le stesse condizioni si applicano quando si sceglie come destinazione i gruppi di risorse. Per risolvere gli errori o ottenere ulteriori informazioni sull'esecuzione del comando, invia un comando che gestisce gli errori o le eccezioni restituendo codici di uscita appropriati (codici di uscita diversi da zero in caso di errore del comando). |
| DeliveryTimedOut | Il comando non è stato recapitato al nodo gestito prima della scadenza del timeout complessivo. I timeout complessivi non vengono conteggiati per il limite max-errors del comando padre, ma sono rilevanti per la definizione dello stato del comando come Success, Incomplete o Delivery Timed Out. Si tratta di uno stato terminale. |
| ExecutionTimedOut | L'esecuzione del comando è iniziata sul nodo gestito, ma non è stata completata prima della scadenza. I timeout di esecuzione contano come un errore che invierà una risposta diversa da zero e Systems Manager interromperà il tentativo di esecuzione dell'automazione dei comandi, segnalando lo stato di errore. |
| Non riuscito | Il comando non è riuscito sul nodo gestito. Per un plugin, questo indica che il codice del risultato non era zero. Per un'invocazione del comando, questo indica che il codice del risultato per uno o più plugin non era zero. Le invocazioni non riuscite vengono conteggiate per il limite max-errors del comando padre. Si tratta di uno stato terminale. |
| Annullato | Il comando è stato terminato prima del completamento. Si tratta di uno stato terminale. |
| Non consegnabile | Il comando non può essere recapitato al nodo gestito. Il nodo potrebbe non esistere o non rispondere. Le invocazioni non consegnabili non vengono conteggiate per il limite max-errors del comando padre e non sono rilevanti per la definizione dello stato del comando come Success o Incomplete. Ad esempio, se tutte le invocazioni in un comando dispongono dello stato Undeliverable, lo stato del comando restituito è Failed. Tuttavia, se un comando dispone di cinque chiamate, quattro delle quali restituiscono lo stato Undeliverable e una restituisce lo stato Success, lo stato del comando padre è Success. Si tratta di uno stato terminale. |
| Terminato | Il comando padre ha superato il limite max-errors e le successive invocazioni del comando sono state annullate dal sistema. Si tratta di uno stato terminale. |
| InvalidPlatform | Il comando è stato inviato a un nodo gestito che non corrisponde alle piattaforme richieste specificate dal documento scelto. Invalid Platform non viene conteggiato per il limite massimo di errori del comando padre, ma contribuisce a determinare lo stato del comando come Successo o Failed. Ad esempio, se tutte le invocazioni in un comando dispongono dello stato Invalid Platform, lo stato del comando restituito è Failed. Tuttavia, se un comando dispone di cinque chiamate, quattro delle quali restituiscono lo stato Invalid Platform e una restituisce lo stato Success, lo stato del comando padre è Success. Si tratta di uno stato terminale. |
| AccessDenied | L'utente o il ruolo AWS Identity and Access Management (IAM) che avvia il comando non ha accesso al nodo gestito di destinazione. Access Deniednon viene conteggiato nel max-errors limite del comando principale, ma contribuisce a determinare se lo stato del comando principale è Success oFailed. Ad esempio, se tutte le invocazioni in un comando dispongono dello stato Access Denied, lo stato del comando restituito è Failed. Tuttavia, se un comando dispone di cinque chiamate, quattro delle quali restituiscono lo stato Access Denied e una restituisce lo stato Success, lo stato del comando padre è Success. Si tratta di uno stato terminale. |
**Stato dettagliato per un comando**
| Status | Informazioni |
| --- | --- |
| Pending (In attesa) | Il comando non è ancora stato ricevuto da un agente su qualsiasi nodo gestito. |
| InProgress | Il comando è stato inviato ad almeno un'istanza, ma non ha raggiunto lo stato finale su ogni nodo gestito. |
| Ritardato | Il sistema ha tentato di inviare il comando al nodo, ma non è riuscito. Il sistema riprova. |
| Completato | Il comando è stato ricevuto da SSM Agent su tutti i nodi gestiti specificati o destinazione e ha restituito un codice di uscita zero. Tutte le invocazioni di comando hanno raggiunto uno stato terminale e non è stato raggiunto il valore max-errors. Questo stato non significa che il comando è stato elaborato correttamente su tutti i nodi gestiti specificati o destinazione. Si tratta di uno stato terminale. Per risolvere gli errori o ottenere ulteriori informazioni sull'esecuzione del comando, invia un comando che gestisce gli errori o le eccezioni restituendo codici di uscita appropriati (codici di uscita diversi da zero in caso di errore del comando). |
| DeliveryTimedOut | Il comando non è stato recapitato al nodo gestito prima della scadenza del timeout complessivo. I valore di max-errors o altre invocazioni del comando mostra lo stato Delivery Timed Out. Si tratta di uno stato terminale. |
| Non riuscito | Il comando non è riuscito sul nodo gestito. I valore di `max-errors` o altre invocazioni del comando mostra lo stato `Failed`. Si tratta di uno stato terminale. |
| Incomplete (Incompleto) | Il comando è stato tentato su tutti i nodi gestiti e una o più invocazioni non hanno il valore Success. Il numero delle invocazioni non riuscite, però, non è sufficiente perché lo stato sia Failed. Si tratta di uno stato terminale. |
| Annullato | Il comando è stato terminato prima del completamento. Si tratta di uno stato terminale. |
| RateExceeded | Il numero di nodi gestiti definiti come target dal comando ha superato la quota dell'account per le invocazioni in attesa. Il sistema ha annullato il comando prima di eseguirlo su qualsiasi nodo. Si tratta di uno stato terminale. |
| AccessDenied | L'utente o il ruolo che avvia il comando non dispone dell'accesso al gruppo di risorse target. AccessDenied non viene conteggiato ai fini del limite di max-errors del comando padre, ma contribuisce a stabilire se lo stato del comando padre è Success o Failed. Ad esempio, se tutte le invocazioni in un comando dispongono dello statoAccessDenied, lo stato del comando restituito èFailed. Tuttavia, se un comando dispone di 5 invocazioni, 4 delle quali restituiscono lo statoAccessDeniede 1 dei quali restituisce lo statoSuccess, lo stato del comando genitore èSuccess.) Si tratta di uno stato terminale. |
| Nessuna istanza nel tag | Il valore del tag chiave-coppia o il gruppo di risorse cui fa riferimento il comando non corrisponde ad alcun nodo gestito. Si tratta di uno stato terminale. |
## Informazioni sui valori di timeout dei comandi
Systems Manager applica i seguenti valori di timeout durante l'esecuzione dei comandi.
**Timeout totale**
Nella console Systems Manager, specifica il valore di timeout nel campo **Timeout (secondi)**. Dopo l'invio di un comando, Run Command controlla se il comando è scaduto o meno. Se un comando raggiunge il limite di scadenza del comando (timeout totale), lo stato viene modificato in `DeliveryTimedOut` per tutte le chiamate che hanno lo stato`InProgress`, `Pending` o `Delayed`.
![\[Il campo Timeout (secondi) nella console di Systems Manager\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/images/run-command-delivery-time-out-time-out-seconds.png)
A livello più tecnico, il timeout complessivo, ossia **Timeout (secondi)**, è una combinazione di due valori di timeout, come illustrato di seguito:
`Total timeout = "Timeout(seconds)" from the console + "timeoutSeconds": "{{ executionTimeout }}" from your SSM document`
Ad esempio, il valore predefinito di **Timeout (secondi)**Nella console Systems Manager è di 600 secondi. Se si esegue un comando utilizzando il comando `AWS-RunShellScript` SSM, il valore predefinito di **"timeoutSeconds": "\$1\$1 executionTimeout \$1\$1"** è di 3.600 secondi, come mostrato nell'esempio del documento seguente:
```
"executionTimeout": {
"type": "String",
"default": "3600",
"runtimeConfig": {
"aws:runShellScript": {
"properties": [
{
"timeoutSeconds": "{{ executionTimeout }}"
```
Ciò significa che il comando viene eseguito per 4.200 secondi (70 minuti) prima che il sistema imposti lo stato del comando su `DeliveryTimedOut`.
**Timeout di esecuzione**
Nella console Systems Manager specificare il valore di timeout di esecuzione nel campo **Timeout di esecuzione**, se disponibile. Non tutti i documenti SSM richiedono di specificare un timeout di esecuzione. Il campo **Timeout di esecuzione** viene visualizzato solo quando un parametro di input corrispondente è stato definito nel documento SSM. Se specificato, il comando deve essere completato entro questo periodo di tempo.
**Nota**
Run Command si basa sulla risposta terminale del documento SSM Agent per determinare se il comando è stato recapitato o meno all'agente. SSM Agent deve inviare un segnale `ExecutionTimedOut` per una chiamata o un comando da contrassegnare come `ExecutionTimedOut`.
![\[Il campo Timeout di esecuzione nella console Systems Manager\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/images/run-command-execution-timeout-console.png)
**Timeout di esecuzione predefinito**
Se un documento SSM non richiede di specificare esplicitamente un valore di timeout di esecuzione, Systems Manager applica il timeout di esecuzione predefinito hard-coded.
**Come Systems Manager segnala i timeout**
Se Systems Manager riceve una risposta `execution timeout` da SSM Agent su una destinazione, Systems Manager contrassegna la chiamata del comando come `executionTimeout`.
Se Run Command non riceve una risposta terminale di documenti da SSM Agent, l'invocazione del comando è contrassegnata come `deliveryTimeout`.
Per determinare lo stato di timeout su una destinazione, SSM Agent combina tutti i parametri e il contenuto del documento SSM da calcolare per `executionTimeout`. Quando SSM Agent determina che un comando è scaduto, invia `executionTimeout` al servizio.
Il valore predefinito per **Timeout (secondi)** è 3.600 secondi. Il valore predefinito per **Timeout di esecuzione** è anche 3.600 secondi. Pertanto, il timeout predefinito totale per un comando è 7200 secondi.
**Nota**
SSM Agent elabora `executionTimeout` in modo diverso a seconda del tipo di documento SSM e della versione del documento.
# Spiegazioni passo per passo di Run Command
Le procedure guidate presenti in questa sezione illustrano come eseguire comandi con Run Command, uno strumento di AWS Systems Manager, utilizzando sia il AWS Command Line Interface (AWS CLI) che AWS Tools for Windows PowerShell.
**Topics**
+ [Aggiornamento del software utilizzando Run Command](run-command-tutorial-update-software.md)
+ [Procedura dettagliata: utilizzare con AWS CLI Run Command](walkthrough-cli.md)
+ [Procedura dettagliata: utilizzare con AWS Tools for Windows PowerShell Run Command](walkthrough-powershell.md)
I comandi di esempio sono disponibili anche nei seguenti riferimenti.
+ [Systems ManagerAWS CLIRiferimento del](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
+ [AWS Tools for Windows PowerShell - AWS Systems Manager](https://docs.aws.amazon.com/powershell/latest/reference/items/SimpleSystemsManagement_cmdlets.html)
# Aggiornamento del software utilizzando Run Command
Le procedure seguenti descrivono come aggiornare il software nei nodi gestiti.
## Aggiornamento di SSM Agent utilizzando Run Command
La procedura seguente descrive come aggiornare rapidamente SSM Agent in esecuzione sui tuoi nodi gestiti. È possibile eseguire l'aggiornamento alla versione più recente di SSM Agent o il downgrade a una versione precedente. Quando si esegue il comando, il sistema scarica la versione da AWS, la installa e quindi disinstalla la versione esistente prima dell'esecuzione del comando. Se si verifica un errore durante il processo, il sistema torna alla versione presente sul server prima dell'esecuzione di questo comando e lo stato del comando indica che il comando non è riuscito.
**Nota**
Se un'istanza sta eseguendo la versione 13.0 (Ventura) o successiva di macOS, l'istanza deve avere la versione SSM Agent 3.1.941.0 o successiva per eseguire il documento AWS-UpdateSSMAgent. Se l'istanza esegue una versione di SSM Agent precedente alla 3.1.941.0, è possibile aggiornare il tuo SSM Agent per eseguire il documento AWS-UpdateSSMAgent eseguendo i comandi `brew update` e `brew upgrade amazon-ssm-agent`.
Per ricevere notifiche sugli aggiornamenti dell'SSM Agent, iscriviti alla pagina [Note di rilascio dell'SSM Agent](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) su GitHub.
**Per aggiornare SSM Agent utilizzando Run Command**
1. Apri la console all' AWS Systems Manager indirizzo. [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)
1. Nel pannello di navigazione, scegli **Run Command**.
1. Seleziona **Esegui comando**.
1. Nell'elenco **Command document (Documento comando)** scegliere **`AWS-UpdateSSMAgent`**.
1. Nella sezione **Command parameters (Parametri comando)** specificare i valori per i parametri seguenti, se necessario:
1. (Facoltativo) Per **Versione**, digita la versione di SSM Agent da installare. È possibile installare [versioni precedenti](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) dell'agente. Se non si specifica una versione, viene installata quella più recente.
1. (Facoltativo) Per **Consenti downgrade**, scegli **true** per installare una versione precedente di SSM Agent. Se si seleziona questa opzione, è necessario specificare il numero della versione [precedente](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md). Scegliere **false** per installare solo la versione più recente del servizio.
1. In **Targets (Destinazioni)**, scegliere i nodi gestiti in cui si desidera eseguire questa operazione specificando i tag, selezionando le istanze o i dispositivi edge manualmente o indicando un gruppo di risorse.
**Suggerimento**
Se un nodo gestito che ti aspetti di vedere non è presente nell'elenco, consulta [Risoluzione dei problemi relativi alla disponibilità dei nodi gestiti](fleet-manager-troubleshooting-managed-nodes.md) per suggerimenti sulla risoluzione dei problemi.
1. In **Altri parametri**:
+ In **Commento**, digita le informazioni su questo comando.
+ In **Timeout (secondi)**, specifica il numero di secondi che il sistema dovrà attendere prima di generare un errore per l'intera esecuzione del comando.
1. Per **Controllo velocità**:
+ In **Simultaneità**, specifica un numero o una percentuale di nodi gestiti su cui eseguire contemporaneamente il comando.
**Nota**
Se hai selezionato le destinazioni specificando i tag applicati ai nodi gestiti o specificando i gruppi di AWS risorse e non sei sicuro del numero di nodi gestiti come target, limita il numero di destinazioni che possono eseguire il documento contemporaneamente specificando una percentuale.
+ Per **Soglia di errore**, specificare quando interrompere l'esecuzione del comando sulle altri nodi gestiti dopo un errore su un numero o una percentuale di nodi. Se, ad esempio, si specificano tre errori, Systems Manager interrompe l'invio del comando quando riceve il quarto errore. Anche i nodi gestiti che stanno ancora elaborando il comando potrebbero inviare errori.
1. (Facoltativo) Nella sezione **Opzioni di output**, per salvare l'output del comando in un file, seleziona la casella **Scrivi l'output del comando in un bucket S3**. Digita i nomi del bucket e del prefisso (cartella) nelle caselle.
**Nota**
Le autorizzazioni S3 che danno la possibilità di scrivere dati in un bucket S3 sono quelle del profilo dell'istanza (per istanze EC2) o del ruolo di servizio IAM (in macchine attivate da sistemi ibridi) assegnate all'istanza, non quelle dell'utente IAM che esegue questo processo. Per ulteriori informazioni, consulta le pagine [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md) oppure [Creazione di un ruolo di servizio IAM per un ambiente ibrido](hybrid-multicloud-service-role.md). Inoltre, se il bucket S3 specificato si trova su un Account AWS diverso, assicurarsi che il profilo dell'istanza o il ruolo di servizio IAM associato al nodo gestito disponga delle autorizzazioni necessarie per scrivere su quel bucket.
1. Se vuoi che vengano inviate notifiche sullo stato dell'esecuzione del comando, nella sezione **Notifiche SNS** selezionara la casella di controllo **Abilita notifiche SNS**.
Per ulteriori informazioni sulla configurazione delle notifiche Amazon SNS per Run Command, consulta [Monitoraggio delle modifiche di stato di Systems Manager utilizzando le notifiche Amazon SNS](monitoring-sns-notifications.md).
1. Scegli **Esegui**.
## Aggiornamento tramite PowerShell Run Command
La procedura seguente descrive come eseguire l'aggiornamento PowerShell alla versione 5.1 sui nodi gestiti Windows Server 2012 e 2012 R2. Lo script fornito in questa procedura scarica l'aggiornamento 5.1 di Windows Management Framework (WMF) e avvia l'installazione dell'aggiornamento. Il nodo si riavvia durante questo processo perché questo è necessario durante l'installazione di WMF 5.1. Il download e l'installazione dell'aggiornamento richiedono circa cinque minuti.
**Per eseguire l'aggiornamento utilizzando PowerShell Run Command**
1. Apri la AWS Systems Manager console all'indirizzo [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Nel pannello di navigazione, scegli **Run Command**.
1. Seleziona **Esegui comando**.
1. Nell'elenco **Command document (Documento comando)** scegliere **`AWS-RunPowerShellScript`**.
1. Nella**Comandi**Incollare i comandi seguenti per il sistema operativo in uso.
------
#### [ Windows Server 2012 R2 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839516" -OutFile "Win8.1AndW2K12R2-KB3191564-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('Win8.1AndW2K12R2-KB3191564-x64.msu', '/quiet')
```
------
#### [ Windows Server 2012 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839513" -OutFile "W2K12-KB3191565-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('W2K12-KB3191565-x64.msu', '/quiet')
```
------
1. In **Targets (Destinazioni)**, scegliere i nodi gestiti in cui si desidera eseguire questa operazione specificando i tag, selezionando le istanze o i dispositivi edge manualmente o indicando un gruppo di risorse.
**Suggerimento**
Se un nodo gestito che ti aspetti di vedere non è presente nell'elenco, consulta [Risoluzione dei problemi relativi alla disponibilità dei nodi gestiti](fleet-manager-troubleshooting-managed-nodes.md) per suggerimenti sulla risoluzione dei problemi.
1. In **Altri parametri**:
+ In **Commento**, digita le informazioni su questo comando.
+ In **Timeout (secondi)**, specifica il numero di secondi che il sistema dovrà attendere prima di generare un errore per l'intera esecuzione del comando.
1. Per **Controllo velocità**:
+ In **Simultaneità**, specifica un numero o una percentuale di nodi gestiti su cui eseguire contemporaneamente il comando.
**Nota**
Se hai selezionato le destinazioni specificando i tag applicati ai nodi gestiti o specificando i gruppi di AWS risorse e non sei sicuro del numero di nodi gestiti come target, limita il numero di destinazioni che possono eseguire il documento contemporaneamente specificando una percentuale.
+ Per **Soglia di errore**, specificare quando interrompere l'esecuzione del comando sulle altri nodi gestiti dopo un errore su un numero o una percentuale di nodi. Se, ad esempio, si specificano tre errori, Systems Manager interrompe l'invio del comando quando riceve il quarto errore. Anche i nodi gestiti che stanno ancora elaborando il comando potrebbero inviare errori.
1. (Facoltativo) Nella sezione **Opzioni di output**, per salvare l'output del comando in un file, seleziona la casella **Scrivi l'output del comando in un bucket S3**. Digita i nomi del bucket e del prefisso (cartella) nelle caselle.
**Nota**
Le autorizzazioni S3 che danno la possibilità di scrivere dati in un bucket S3 sono quelle del profilo dell'istanza (per istanze EC2) o del ruolo di servizio IAM (in macchine attivate da sistemi ibridi) assegnate all'istanza, non quelle dell'utente IAM che esegue questo processo. Per ulteriori informazioni, consulta le pagine [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md) oppure [Creazione di un ruolo di servizio IAM per un ambiente ibrido](hybrid-multicloud-service-role.md). Inoltre, se il bucket S3 specificato si trova su un Account AWS diverso, assicurarsi che il profilo dell'istanza o il ruolo di servizio IAM associato al nodo gestito disponga delle autorizzazioni necessarie per scrivere su quel bucket.
1. Se vuoi che vengano inviate notifiche sullo stato dell'esecuzione del comando, nella sezione **Notifiche SNS** selezionara la casella di controllo **Abilita notifiche SNS**.
Per ulteriori informazioni sulla configurazione delle notifiche Amazon SNS per Run Command, consulta [Monitoraggio delle modifiche di stato di Systems Manager utilizzando le notifiche Amazon SNS](monitoring-sns-notifications.md).
1. Scegli **Esegui**.
Dopo il riavvio del nodo gestito e il completamento dell'installazione dell'aggiornamento, connettiti al nodo per confermare che l'aggiornamento alla versione 5.1 è PowerShell stato eseguito correttamente. Per verificare la versione di PowerShell sul tuo nodo, apri PowerShell e accedi. `$PSVersionTable` Il valore `PSVersion` nella tabella di output mostra 5.1, se l'aggiornamento è riuscito.
Se il valore di `PSVersion` è diverso da 5.1, ad esempio 3.0 o 4.0, rivedi i log di **configurazione** nel Visualizzatore eventi in **Log di Windows**. Questi log indicano perché l'installazione dell'aggiornamento non è riuscita.
# Procedura dettagliata: utilizzare con AWS CLI Run Command
La procedura dettagliata di esempio seguente mostra come utilizzare il comando AWS Command Line Interface (AWS CLI) per visualizzare informazioni su comandi e parametri dei comandi, come eseguire comandi e come visualizzare lo stato di tali comandi.
**Importante**
Solo gli amministratori attendibili dovrebbero essere autorizzati a utilizzare i documenti AWS Systems Manager preconfigurati mostrati in questo argomento. I comandi o gli script specificati nei documenti Systems Manager vengono eseguiti con privilegi amministrativi sui nodi gestiti. Se un utente è autorizzato a eseguire uno dei documenti Systems Manager predefiniti (qualsiasi documento che inizia con `AWS-`), lo stesso utente avrà anche accesso al nodo come amministratore. Per tutti gli altri utenti, è consigliabile creare documenti restrittivi e condividerli con utenti specifici.
**Topics**
+ [Fase 1. Nozioni di base](#walkthrough-cli-settings)
+ [Fase 2: esecuzione di script di shell per visualizzare i dettagli delle risorse](#walkthrough-cli-run-scripts)
+ [Fase 3: invio di comandi semplici utilizzando il documento `AWS-RunShellScript`](#walkthrough-cli-example-1)
+ [Fase 4: esecuzione di un semplice script Python usando Run Command](#walkthrough-cli-example-2)
+ [Fase 5: esecuzione di uno script Bash usandoRun Command](#walkthrough-cli-example-3)
## Fase 1. Nozioni di base
Devi disporre dei privilegi di amministratore sui nodi gestiti da configurare oppure delle autorizzazioni appropriate in AWS Identity and Access Management (IAM). Si noti inoltre che questo esempio utilizza la regione Stati Uniti orientali (Ohio) (us-east-2). Run Commandè disponibile negli [endpoint del servizio Systems Manager Regioni AWS](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) elencati in. *Riferimenti generali di Amazon Web Services* Per ulteriori informazioni, consulta [Configurazione di nodi gestiti per AWS Systems Manager](systems-manager-setting-up-nodes.md).
**Per eseguire comandi utilizzando AWS CLI**
1. Installa e configura AWS Command Line Interface (AWS CLI), se non l'hai già fatto.
Per informazioni, consulta la pagina [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Creare un elenco di tutti i documenti disponibili
Questo comando elenca tutti i documenti disponibili per il tuo account in base alle (IAM) autorizzazioni.
```
aws ssm list-documents
```
1. Verificare che un nodo gestito sia pronto a ricevere comandi
L'output del comando seguente mostra se i nodi gestiti sono online.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--output text --query "InstanceInformationList[*]"
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--output text --query "InstanceInformationList[*]"
```
------
1. Utilizzare il comando seguente per visualizzare i dettagli su uno determinato nodo gestito.
**Nota**
Per eseguire i comandi in questa procedura dettagliata, sostituisci l'istanza e il comando. IDs Per i dispositivi AWS IoT Greengrass core gestiti, utilizzate l'ID mi- *ID\$1number* for instance. L'ID comando viene restituito come risposta a **send-command**. IDs Le istanze sono disponibili pressoFleet Manager, uno strumento in AWS Systems Manager..
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
## Fase 2: esecuzione di script di shell per visualizzare i dettagli delle risorse
Se utilizzi Run Command e il documento `AWS-RunShellScript`, puoi eseguire qualsiasi comando o script su un nodo gestito come se fossi connesso localmente.
**Visualizzare la descrizione e i parametri disponibili**
Usa il comando seguente per visualizzare una descrizione del documento JSON .
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "[Document.Name,Document.Description]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "[Document.Name,Document.Description]"
```
------
Usa il comando seguente per visualizzare i parametri disponibili e i dettagli su tali parametri.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "Document.Parameters[*]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "Document.Parameters[*]"
```
------
## Fase 3: invio di comandi semplici utilizzando il documento `AWS-RunShellScript`
Usa il comando seguente per ottenere le informazioni IP per un nodo gestito.
Se prendi come target un nodo gestito Windows Server, cambia il `document-name` a `AWS-RunPowerShellScript` e cambia il `command` da `ifconfig` a `ipconfig`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "IP config" \
--parameters commands=ifconfig \
--output text
```
------
#### [ Windows ]
```
aws ssm send-command ^
--instance-ids "instance-ID" ^
--document-name "AWS-RunShellScript" ^
--comment "IP config" ^
--parameters commands=ifconfig ^
--output text
```
------
**Ottenere informazioni sul comando con i dati di risposta**
Il comando seguente usa l'ID comando restituito dal comando precedente per ottenere i dettagli e i dati di risposta dell'esecuzione del comando. Il sistema restituisce i dati di risposta se il comando è stato completato. Se l'esecuzione del comando mostra `"Pending"` o `"InProgress"`, esegui di nuovo il comando per visualizzare i dati di risposta.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id $sh-command-id \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id $sh-command-id ^
--details
```
------
**Identificazione dell'utente**
Il comando seguente mostra l'utente predefinito che esegue i comandi.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux managed node" \
--parameters commands=whoami \
--output text \
--query "Command.CommandId")
```
------
**Ottenere lo stato del comando**
Il comando seguente usa l'ID comando per ottenere lo stato di esecuzione del comando sul nodo gestito. Questo esempio usa l'ID di comando restituito nel comando precedente.
------
#### [ Linux & macOS ]
```
aws ssm list-commands \
--command-id "command-ID"
```
------
#### [ Windows ]
```
aws ssm list-commands ^
--command-id "command-ID"
```
------
**Ottenere i dettagli del comando**
Il comando seguente usa l'ID comando del comando precedente per ottenere lo stato di esecuzione del comando per singoli nodo gestito.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id "command-ID" ^
--details
```
------
**Ottenere informazioni sul comando con i dati di risposta per un nodo gestito specifico**
Il comando seguente restituisce l'output della richiesta `aws ssm send-command` originale per un nodo gestito specifico.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--instance-id instance-ID \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--instance-id instance-ID ^
--command-id "command-ID" ^
--details
```
------
**Visualizzare la versione Python**
Il comando seguente restituisce la versione di Python in esecuzione su un nodo.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters commands='python -V' \
--output text --query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Fase 4: esecuzione di un semplice script Python usando Run Command
Il seguente comando esegue un semplice script Python "Hello World" utilizzando Run Command.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters '{"commands":["#!/usr/bin/python","print \"Hello World from python\""]}' \
--output text \
--query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Fase 5: esecuzione di uno script Bash usandoRun Command
Gli esempi in questa sezione mostrano come eseguire il seguente script bash usandoRun Command.
Per esempi di utilizzo diRun Commandper eseguire script archiviati in posizioni remote, vedere[Esecuzione di script da Amazon S3](integration-s3.md)e[Esecuzione di script da GitHub](integration-remote-scripts.md).
```
#!/bin/bash
yum -y update
yum install -y ruby
cd /home/ec2-user
curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install
chmod +x ./install
./install auto
```
*Questo script installa l' AWS CodeDeploy agente su Amazon Linux e Red Hat Enterprise Linux (RHEL) istanze, come descritto in [Creare un'istanza Amazon EC2](https://docs.aws.amazon.com/codedeploy/latest/userguide/instances-ec2-create.html) per la Guida CodeDeploy per l'utente.AWS CodeDeploy *
Lo script installa l' CodeDeploy agente da un bucket S3 AWS gestito nella regione Stati Uniti orientali (Ohio) (us-east-2),. `aws-codedeploy-us-east-2`
**Esegui uno script bash in un comando AWS CLI **
Nell'esempio seguente viene illustrato come includere lo script bash in un comando CLI utilizzando l'opzione `--parameters`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets '[{"Key":"InstanceIds","Values":["instance-id"]}]' \
--parameters '{"commands":["#!/bin/bash","yum -y update","yum install -y ruby","cd /home/ec2-user","curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install","chmod +x ./install","./install auto"]}'
```
------
**Esegui uno script bash in un file JSON**
Nell'esempio seguente, il contenuto dello script bash viene archiviato in un file JSON e il file viene incluso nel comando usando l'`--cli-input-json`opzione.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets "Key=InstanceIds,Values=instance-id" \
--cli-input-json file://installCodeDeployAgent.json
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--targets "Key=InstanceIds,Values=instance-id" ^
--cli-input-json file://installCodeDeployAgent.json
```
------
Il comando `installCodeDeployAgent.json` che fa riferimento al file JSON viene visualizzato nell'esempio seguente.
```
{
"Parameters": {
"commands": [
"#!/bin/bash",
"yum -y update",
"yum install -y ruby",
"cd /home/ec2-user",
"curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install",
"chmod +x ./install",
"./install auto"
]
}
}
```
# Procedura dettagliata: utilizzare con AWS Tools for Windows PowerShell Run Command
Negli esempi seguenti viene illustrato come utilizzare AWS Tools for Windows PowerShell per visualizzare informazioni su comandi e parametri dei comandi, come eseguire comandi e come visualizzare lo stato di tali comandi. Questa procedura guidata include un esempio per ognuno dei documenti AWS Systems Manager predefiniti.
**Importante**
Solo gli amministratori fidati dovrebbero essere autorizzati a usare i documenti Systems Manager preconfigurati mostrati in questo argomento. I comandi o gli script specificati nei documenti Systems Manager vengono eseguiti con privilegi amministrativi sui nodi gestiti. Se un utente è autorizzato a eseguire uno qualsiasi dei documenti predefiniti di Systems Manager (qualsiasi documento che inizia con AWS), allora quell'utente ha anche l'accesso come amministratore al nodo. Per tutti gli altri utenti, è consigliabile creare documenti restrittivi e condividerli con utenti specifici.
**Topics**
+ [Configura le impostazioni AWS Tools for Windows PowerShell della sessione](#walkthrough-powershell-settings)
+ [Creare un elenco di tutti i documenti disponibili](#walkthrough-powershell-all-documents)
+ [Esegue PowerShell comandi o script](#walkthrough-powershell-run-script)
+ [Installare un'applicazione usando`AWS-InstallApplication`documento](#walkthrough-powershell-install-application)
+ [Installa un PowerShell modulo utilizzando il documento `AWS-InstallPowerShellModule` JSON](#walkthrough-powershell-install-module)
+ [Aggiungere un nodo gestito a un dominio usando il Documento JSON `AWS-JoinDirectoryServiceDomain`](#walkthrough-powershell-domain-join)
+ [Invia i parametri di Windows ad Amazon CloudWatch Logs utilizzando il documento `AWS-ConfigureCloudWatch`](#walkthrough-powershell-windows-metrics)
+ [Attivare o disattivare l'aggiornamento automatico di Windows utilizzando il`AWS-ConfigureWindowsUpdate`documento](#walkthrough-powershell-enable-windows-update)
+ [Gestire gli aggiornamenti di Windows usando Run Command](#walkthough-powershell-windows-updates)
## Configura le impostazioni AWS Tools for Windows PowerShell della sessione
**Specificare le credenziali**
Apri **Tools for Windows PowerShell** sul tuo computer locale ed esegui il comando seguente per specificare le tue credenziali. È necessario disporre delle autorizzazioni di amministratore sui nodi gestiti che si desidera configurare oppure è necessario disporre dell'autorizzazione appropriata in AWS Identity and Access Management (IAM). Per ulteriori informazioni, consulta [Configurazione di nodi gestiti per AWS Systems Manager](systems-manager-setting-up-nodes.md).
```
Set-AWSCredentials –AccessKey key-name –SecretKey key-name
```
**Imposta un valore predefinito Regione AWS**
Esegui il comando seguente per impostare la regione per la PowerShell sessione. L'esempio utilizza la regione degli Stati Uniti orientali (Ohio) (us-east-2). Run Commandè disponibile negli [endpoint del servizio Systems Manager Regioni AWS](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) elencati in. *Riferimenti generali di Amazon Web Services*
```
Set-DefaultAWSRegion `
-Region us-east-2
```
## Creare un elenco di tutti i documenti disponibili
Questo comando elenca tutti i documenti disponibili per il tuo account:
```
Get-SSMDocumentList
```
## Esegue PowerShell comandi o script
Se utilizzi Run Command e il documento `AWS-RunPowerShell`, è possibile eseguire qualsiasi comando o script su un nodo gestito come se fossi connesso localmente. È possibile inviare comandi o digitare il percorso di uno script locale per eseguire il comando.
**Nota**
Per ulteriori informazioni sul riavvio dei nodi gestiti quando usi Run Command per chiamare gli script, consulta [Gestione di riavvii durante l'esecuzione dei comandi](send-commands-reboot.md).
**Visualizzare la descrizione e i parametri disponibili**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript"
```
**Visualizzare ulteriori informazioni sui parametri**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript" | Select -ExpandProperty Parameters
```
### Invia comandi utilizzando il documento `AWS-RunPowerShellScript`
Il comando seguente mostra il contenuto della directory `"C:\Users"` e il contenuto della directory `"C:\"` su due nodi gestiti.
```
$runPSCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1", "instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'=@('dir C:\Users', 'dir C:\')}
```
**Ottenere i dettagli della richiesta del comando**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando su entrambi i nodi gestiti. Questo esempio usa `CommandId` restituito nel comando precedente.
```
Get-SSMCommand `
-CommandId $runPSCommand.CommandId
```
Lo stato del comando in questo esempio può essere Success, Pending o. InProgress
**Ottenere informazioni sul comando per nodo gestito**
Il comando seguente usa `CommandId` del comando precedente per ottenere lo stato di esecuzione del comando per singoli nodi gestiti.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId
```
**Ottenere informazioni sul comando con i dati di risposta per un nodo gestito specifico**
Il comando seguente restituisce l'output del comando `Send-SSMCommand` originale per un nodo gestito specifico.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Annullare un comando
Il comando seguente annulla `Send-SSMCommand` per il documento `AWS-RunPowerShellScript`.
```
$cancelCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1","instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'='Start-Sleep –Seconds 120; dir C:\'}
Stop-SSMCommand -CommandId $cancelCommand.CommandId
```
**Controllare lo stato del comando**
Il comando seguente controlla lo stato del comando `Cancel`
```
Get-SSMCommand `
-CommandId $cancelCommand.CommandId
```
## Installare un'applicazione usando`AWS-InstallApplication`documento
Utilizzando Run Command e il documento `AWS-InstallApplication`, è possibile installare, riparare o disinstallare applicazioni su nodi gestiti. Il comando richiede il percorso o l'indirizzo di un file MSI.
**Nota**
Per ulteriori informazioni sul riavvio dei nodi gestiti quando usi Run Command per chiamare gli script, consulta [Gestione di riavvii durante l'esecuzione dei comandi](send-commands-reboot.md).
**Visualizzare la descrizione e i parametri disponibili**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication"
```
**Visualizzare ulteriori informazioni sui parametri**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication" | Select -ExpandProperty Parameters
```
### Invia comandi utilizzando il documento `AWS-InstallApplication`
Il comando seguente installa una versione di Python nel nodo gestito in modalità automatica e registra l'output in un file di testo locale nell'unità `C:`.
```
$installAppCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallApplication" `
-Parameter @{'source'='https://www.python.org/ftp/python/2.7.9/python-2.7.9.msi'; 'parameters'='/norestart /quiet /log c:\pythoninstall.txt'}
```
**Ottenere informazioni sul comando per nodo gestito**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true
```
**Ottenere informazioni sul comando con i dati di risposta per un nodo gestito specifico**
Il comando seguente restituisce i risultati dell'installazione di Python.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
## Installa un PowerShell modulo utilizzando il documento `AWS-InstallPowerShellModule` JSON
È possibile utilizzare Run Command per installare PowerShell moduli su nodi gestiti. Per ulteriori informazioni sui PowerShell moduli, consulta [ PowerShell Moduli di Windows](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_modules?view=powershell-6).
**Visualizzare la descrizione e i parametri disponibili**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule"
```
**Visualizzare ulteriori informazioni sui parametri**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule" | Select -ExpandProperty Parameters
```
### Installa un PowerShell modulo
Il comando seguente scarica il file EZOut con estensione zip, lo installa e quindi esegue un comando aggiuntivo per installare il visualizzatore XPS. Infine, l'output di questo comando viene caricato in un bucket S3 denominato “amzn-s3-demo-bucket”.
```
$installPSCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallPowerShellModule" `
-Parameter @{'source'='https://gallery.technet.microsoft.com/EZOut-33ae0fb7/file/110351/1/EZOut.zip';'commands'=@('Add-WindowsFeature -name XPS-Viewer -restart')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Ottenere informazioni sul comando per nodo gestito**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true
```
**Ottenere informazioni sul comando con i dati di risposta per il nodo gestito**
Il comando seguente restituisce l'output del comando `Send-SSMCommand` originale per il `CommandId` specifico.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Aggiungere un nodo gestito a un dominio usando il Documento JSON `AWS-JoinDirectoryServiceDomain`
UtilizzandoRun Command, è possibile aggiungere rapidamente un nodo gestito a un dominio. AWS Directory Service Prima di eseguire il comando, è necessario [creare una directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html). Ti consigliamo anche di consultare Directory Service. Per ulteriori informazioni, consulta la [Guida di amministrazione di AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/).
Al momento è possibile solo aggiungere un nodo gestito a un dominio. Non è possibile rimuovere un nodo gestito da un dominio.
**Nota**
Per informazioni sui nodi gestiti durante l'utilizzo di Run Command per chiamare script, vedi [Gestione di riavvii durante l'esecuzione dei comandi](send-commands-reboot.md).
**Visualizzare la descrizione e i parametri disponibili**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain"
```
**Visualizzare ulteriori informazioni sui parametri**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain" | Select -ExpandProperty Parameters
```
### Unisci un nodo gestito a un dominio
Il comando seguente unisce un nodo gestito al Directory Service dominio specificato e carica qualsiasi output generato nel bucket di esempio Amazon Simple Storage Service (Amazon S3).
```
$domainJoinCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-JoinDirectoryServiceDomain" `
-Parameter @{'directoryId'='d-example01'; 'directoryName'='ssm.example.com'; 'dnsIpAddresses'=@('192.168.10.195', '192.168.20.97')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Ottenere informazioni sul comando per nodo gestito**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true
```
**Ottenere informazioni sul comando con i dati di risposta per il nodo gestito**
Questo comando restituisce l'output dell'originale `Send-SSMCommand` per lo specifico `CommandId`.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Invia i parametri di Windows ad Amazon CloudWatch Logs utilizzando il documento `AWS-ConfigureCloudWatch`
Puoi inviare Windows Server messaggi nei log di applicazione, sistema, sicurezza ed Event Tracing for Windows (ETW) ad Amazon Logs. CloudWatch Quando abiliti la registrazione per la prima volta, invia tutti i log generati entro un (1) minuto dal momento in cui inizi il caricamento per i log applicazioni, di sistema, di sicurezza e di ETW. I log precedenti a questo intervallo non sono inclusi. Se disabiliti la registrazione e la riattivi in seguito, Systems Manager invia i log dal momento che è stata interrotta. Per tutti i file di log personalizzati e log IIS (Internet Information Services), Systems Manager legge i file di log dall'inizio. Inoltre, Systems Manager può anche inviare i dati del contatore delle prestazioni ai CloudWatch registri.
Se in precedenza hai attivato CloudWatch l'integrazione in EC2 Config, le impostazioni di Systems Manager sostituiscono tutte le impostazioni archiviate localmente sul nodo gestito nel file. `C:\Program Files\Amazon\EC2ConfigService\Settings\AWS.EC2.Windows.CloudWatch.json` *Per ulteriori informazioni sull'utilizzo di EC2 Config per gestire i contatori delle prestazioni e i log su un singolo nodo gestito, consulta [Raccolta di metriche e log dalle istanze Amazon EC2 e dai server locali con l'agente nella Amazon User](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) Guide. CloudWatch CloudWatch *
**Visualizzare la descrizione e i parametri disponibili**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch"
```
**Visualizzare ulteriori informazioni sui parametri**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch" | Select -ExpandProperty Parameters
```
### Invia i log delle applicazioni a CloudWatch
Il comando seguente configura il nodo gestito e sposta i registri delle applicazioni Windows in. CloudWatch
```
$cloudWatchCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"ApplicationEventLog", "FullName":"AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"LogName":"Application", "Levels":"7"}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch", "Parameters":{"Region":"region", "LogGroup":"my-log-group", "LogStream":"instance-id"}}], "Flows":{"Flows":["ApplicationEventLog,CloudWatch"]}}}'}
```
**Ottenere informazioni sul comando per nodo gestito**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true
```
**Ottenere informazioni sul comando con i dati di risposta per un nodo gestito specifico**
Il comando seguente restituisce i risultati della CloudWatch configurazione di Amazon.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Invia i contatori delle prestazioni all' CloudWatch utilizzo del documento `AWS-ConfigureCloudWatch`
Il seguente comando dimostrativo carica i contatori delle prestazioni su. CloudWatch Per ulteriori informazioni, consulta la *[Amazon CloudWatch User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
```
$cloudWatchMetricsCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"PerformanceCounter", "FullName":"AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"CategoryName":"Memory", "CounterName":"Available MBytes", "InstanceName":"", "MetricName":"AvailableMemory", "Unit":"Megabytes","DimensionName":"", "DimensionValue":""}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"AccessKey":"", "SecretKey":"","Region":"region", "NameSpace":"Windows-Default"}}], "Flows":{"Flows":["PerformanceCounter,CloudWatch"]}}}'}
```
## Attivare o disattivare l'aggiornamento automatico di Windows utilizzando il`AWS-ConfigureWindowsUpdate`documento
Con Run Command e il documento `AWS-ConfigureWindowsUpdate` è possibile abilitare o disabilitare gli aggiornamenti automatici di Windows nei nodi gestiti Windows Server. Questo comando configura l'agente di aggiornamento di Windows in modo da scaricare e installare gli aggiornamenti di Windows nel giorno e all'ora specificati. Se un aggiornamento richiede il riavvio, il nodo gestito si riavvia automaticamente 15 minuti dopo l'installazione degli aggiornamenti. Con questo comando è possibile anche configurare Windows Update in modo da controllare la disponibilità di aggiornamenti senza installarli. Il documento `AWS-ConfigureWindowsUpdate` è ufficialmente supportato in Windows Server 2012 e nelle versioni successive.
**Visualizzare la descrizione e i parametri disponibili**
```
Get-SSMDocumentDescription `
–Name "AWS-ConfigureWindowsUpdate"
```
**Visualizzare ulteriori informazioni sui parametri**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureWindowsUpdate" | Select -ExpandProperty Parameters
```
### Attivare l'aggiornamento automatico di Windows
Il comando seguente configura Windows Update in modo da scaricare e installare automaticamente gli aggiornamenti ogni giorno alle 10:00.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='InstallUpdatesAutomatically'; 'scheduledInstallDay'='Daily'; 'scheduledInstallTime'='22:00'}
```
**Visualizzare lo stato del comando per abilitare l'aggiornamento automatico di Windows**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando e abilitare l'aggiornamento automatico di Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
### Disabilitare l'aggiornamento automatico di Windows
Il comando seguente riduce il livello della notifica di Windows Update in modo che il sistema verifichi la disponibilità di aggiornamenti senza aggiornare automaticamente il nodo gestito.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='NeverCheckForUpdates'}
```
**Visualizzare lo stato del comando per disabilitare l'aggiornamento automatico di Windows**
Il comando seguente usa `CommandId` per ottenere lo stato di esecuzione del comando e abilitare l'aggiornamento automatico di Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
## Gestire gli aggiornamenti di Windows usando Run Command
Utilizzando Run Command e il documento `AWS-InstallWindowsUpdates` è possibile gestire gli aggiornamenti per i nodi gestiti Windows Server. Questo comando analizza o installa gli aggiornamenti mancanti sui nodi gestiti e, facoltativamente, si riavvia dopo l'installazione. È possibile anche specificare le classificazioni e i livelli di gravità appropriati per gli aggiornamenti da installare nell'ambiente.
**Nota**
Per ulteriori informazioni sul riavvio dei nodi gestiti quando usi Run Command per chiamare gli script, consulta [Gestione di riavvii durante l'esecuzione dei comandi](send-commands-reboot.md).
Gli esempi seguenti dimostrano come eseguire le attività di gestione di Windows Update specificate.
### Cercare tutti gli aggiornamenti di Windows mancanti
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Scan'}
```
### Installare specifici aggiornamenti di Windows
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'IncludeKbs'='kb-ID-1,kb-ID-2,kb-ID-3';'AllowReboot'='True'}
```
### Installare importanti aggiornamenti di Windows mancanti
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'SeverityLevels'='Important';'AllowReboot'='True'}
```
### Installare gli aggiornamenti di Windows mancanti con specifiche esclusioni
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'ExcludeKbs'='kb-ID-1,kb-ID-2';'AllowReboot'='True'}
```
# Risoluzione dei problemi di Systems Manager
Run Command, uno strumento in AWS Systems Manager, fornisce dettagli sullo stato di ogni esecuzione di comando. Per ulteriori informazioni sui dettagli degli stati dei comandi, consulta [Informazioni sugli stati dei comandi](monitor-commands.md). Puoi usare anche le informazioni in questo argomento per la risoluzione dei problemi relativi a Run Command.
**Topics**
+ [Alcuni dei miei nodi gestiti mancano](#where-are-instances)
+ [Una fase nel mio script non è riuscita, ma lo stato generale è "riuscito"](#ts-exit-codes)
+ [SSM Agent non funziona correttamente](#ts-ssmagent-linux)
## Alcuni dei miei nodi gestiti mancano
Nella pagina **Esegui un comando**, dopo avere scelto un documento SSM da eseguire e aver selezionato **Selezione manuale delle istanze)** nella sezione **Destinazioni**, viene visualizzato un elenco dei nodi gestiti su cui puoi decidere di eseguire il comando.
Se un nodo gestito che ti aspetti di vedere non è presente nell'elenco, consulta [Risoluzione dei problemi relativi alla disponibilità dei nodi gestiti](fleet-manager-troubleshooting-managed-nodes.md) per suggerimenti sulla risoluzione dei problemi.
Dopo aver creato, attivato, riavviato o riavviato un nodo gestito, installato Run Command su un nodo o collegato un profilo di istanza AWS Identity and Access Management (IAM) a un nodo, possono essere necessari alcuni minuti prima che il nodo gestito venga aggiunto all'elenco.
## Una fase nel mio script non è riuscita, ma lo stato generale è "riuscito"
È possibile utilizzare Run Command per definire come i codici di uscita vengono gestiti dagli script. Per impostazione predefinita, il codice di uscita dell'ultimo comando eseguito in uno script viene segnalato come codice di uscita per l'intero script. È tuttavia possibile includere un'istruzione condizionale per uscire dallo script se un comando precedente a quello finale non riesce. Per maggiori informazioni ed esempi, consulta [Specifica dei codici di uscita nei comandi](run-command-handle-exit-status.md#command-exit-codes).
## SSM Agent non funziona correttamente
Se si verificano problemi durante l'esecuzione di comandi con Run Command, è possibile che sia presente un problema relativo a SSM Agent. Per informazioni su come indagare i problemi con SSM Agent, consulta [Risoluzione dei problemi relativi a SSM Agent](troubleshooting-ssm-agent.md).