• 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à.
# Tutorial: creazione e gestione delle finestre di manutenzione utilizzando AWS CLI
Questa sezione include tutorial, che consentono di imparare a utilizzare la AWS Command Line Interface (AWS CLI) per eseguire le operazioni seguenti:
+ Creazione e configurazione di una finestra di manutenzione
+ Visualizzazione delle informazioni sulle finestre di manutenzione
+ Visualizzazione delle informazioni sui task relativi alle finestre di manutenzione e sulla loro esecuzione
+ Aggiornamento di una finestra di manutenzione
+ Eliminazione di una finestra di manutenzione
**Tieni traccia delle risorse IDs**
Man mano che completi le attività di questi AWS CLI tutorial, tieni traccia delle risorse IDs generate dai comandi che esegui. Puoi utilizzare molti di questi ID come input per i comandi successivi. Ad esempio, quando crei la finestra di manutenzione, il sistema fornisce il relativo ID nel seguente formato.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
Prendi nota dei seguenti comandi generati dal sistema, IDs poiché i tutorial di questa sezione li utilizzano:
+ `WindowId`
+ `WindowTargetId`
+ `WindowTaskId`
+ `WindowExecutionId`
+ `TaskExecutionId`
+ `InvocationId`
+ `ExecutionId`
Inoltre, devi disporre dell'ID dell'istanza EC2 che prevedi di utilizzare nei tutorial. Ad esempio: `i-02573cafcfEXAMPLE`
**Topics**
+ [Tutorial: Creare e configurare una finestra di manutenzione utilizzando il AWS CLI](maintenance-windows-cli-tutorials-create.md)
+ [Tutorial: Visualizza le informazioni sulle finestre di manutenzione utilizzando il AWS CLI](maintenance-windows-cli-tutorials-describe.md)
+ [Tutorial: Visualizza informazioni sulle attività e sulle esecuzioni delle attività utilizzando il AWS CLI](mw-cli-tutorial-task-info.md)
+ [Tutorial: Aggiornare una finestra di manutenzione utilizzando il AWS CLI](maintenance-windows-cli-tutorials-update.md)
+ [Tutorial: Eliminare una finestra di manutenzione utilizzando il AWS CLI](mw-cli-tutorial-delete-mw.md)
# Tutorial: Creare e configurare una finestra di manutenzione utilizzando il AWS CLI
Questo tutorial illustra come utilizzare il AWS Command Line Interface (AWS CLI) per creare e configurare una finestra di manutenzione, i relativi obiettivi e le relative attività. L'esecuzione del tutorial si articola in semplici passi. È infatti possibile creare una singola finestra di manutenzione, identificare una singola destinazione e impostare l'esecuzione di un'operazione semplice da parte della finestra di manutenzione. Durante l'intera procedura verranno visualizzate altre informazioni che potrai usare per ottenere scenari più complessi.
Mentre segui i passaggi di questo tutorial, sostituisci i valori nel *red* testo in corsivo con le tue opzioni e. IDs Ad esempio, sostituisci l'ID della finestra di manutenzione *mw-0c50858d01EXAMPLE* e l'ID dell'istanza *i-02573cafcfEXAMPLE* con l'ID IDs delle risorse che crei.
**Topics**
+ [Fase 1: Creare la finestra di manutenzione utilizzando AWS CLI](mw-cli-tutorial-create-mw.md)
+ [Fase 2: Registrare un nodo di destinazione nella finestra di manutenzione utilizzando il AWS CLI](mw-cli-tutorial-targets.md)
+ [Fase 3: Registrare un'operazione nella finestra di manutenzione utilizzando il AWS CLI](mw-cli-tutorial-tasks.md)
# Fase 1: Creare la finestra di manutenzione utilizzando AWS CLI
In questa fase è possibile creare una finestra di manutenzione e specificarne le opzioni di base, come il nome, la pianificazione e la durata. Nelle fasi successive verrà scelta l'istanza da aggiornare e il task da eseguire.
In questo esempio, è necessario creare una finestra di manutenzione che viene eseguita ogni cinque minuti. Di solito, non è possibile eseguire una finestra di manutenzione con questa frequenza. Tuttavia, con questa frequenza è possibile velocizzare la visualizzazione dei risultati del tutorial. Al termine dell'esecuzione di quest'attività verrà illustrato come impostare una frequenza di aggiornamento più bassa.
**Nota**
Per una spiegazione di come le diverse opzioni relative alla pianificazione per le finestre di manutenzione siano tra loro correlate, consulta [Opzioni di pianificazione e periodo attivo per la finestra di manutenzione](maintenance-windows-schedule-options.md).
Per ulteriori informazioni sull'utilizzo dell'opzione `--schedule`, consulta [Riferimento: espressioni Cron e della frequenza per Systems Manager](reference-cron-and-rate-expressions.md).
**Per creare una finestra di manutenzione utilizzando il AWS CLI**
1. Apri AWS Command Line Interface (AWS CLI) ed esegui il seguente comando sul tuo computer locale per creare una finestra di manutenzione che esegua le seguenti operazioni:
+ Avvia l'esecuzione ogni cinque minuti per un massimo di due ore (in base alle esigenze).
+ Impedisce l'avvio di nuovi task nell'ora successiva alla fine dell'operazione della finestra di manutenzione.
+ Consente il supporto di destinazioni non associate (istanze non registrate con la finestra di manutenzione).
+ Mediante l'uso di tag personalizzati indica che l'autore intende utilizzare la finestra di manutenzione in un tutorial.
------
#### [ Linux & macOS ]
```
aws ssm create-maintenance-window \
--name "My-First-Maintenance-Window" \
--schedule "rate(5 minutes)" \
--duration 2 \
--cutoff 1 \
--allow-unassociated-targets \
--tags "Key=Purpose,Value=Tutorial"
```
------
#### [ Windows ]
```
aws ssm create-maintenance-window ^
--name "My-First-Maintenance-Window" ^
--schedule "rate(5 minutes)" ^
--duration 2 ^
--cutoff 1 ^
--allow-unassociated-targets ^
--tags "Key"="Purpose","Value"="Tutorial"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
1. Eseguire il seguente comando per visualizzare ulteriori informazioni su questa e altre finestre di manutenzione già presenti nell'account.
```
aws ssm describe-maintenance-windows
```
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowIdentities":[
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 1,
"NextExecutionTime": "2019-05-11T16:46:16.991Z"
}
]
}
```
Continua su [Fase 2: Registrare un nodo di destinazione nella finestra di manutenzione utilizzando il AWS CLI](mw-cli-tutorial-targets.md).
# Fase 2: Registrare un nodo di destinazione nella finestra di manutenzione utilizzando il AWS CLI
In questa fase viene registrata una destinazione con la nuova finestra di manutenzione. In questo caso, specifica quale nodo aggiornare durante l'esecuzione della finestra di manutenzione.
Per un esempio di registrazione di più di un nodo alla volta utilizzando node IDs, esempi di utilizzo di tag per identificare più nodi ed esempi di specificazione di gruppi di risorse come destinazioni, vedere. [Esempi: registrazione delle destinazioni con una finestra di manutenzione](mw-cli-tutorial-targets-examples.md)
**Nota**
Per eseguire questa fase, è necessario aver già creato un'istanza Amazon Elastic Compute Cloud (Amazon EC2), come descritto nei [prerequisiti per il tutorial relativo alle Maintenance Windows](maintenance-windows-tutorials.md).
**Per registrare un nodo di destinazione con una finestra di manutenzione utilizzando il AWS CLI**
1. Esegui il comando seguente sul computer locale. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowTargetId":"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Esegui ora questo comando sul computer locale per visualizzare i dettagli sulla destinazione della finestra di manutenzione.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
]
}
]
}
```
Continua su [Fase 3: Registrare un'operazione nella finestra di manutenzione utilizzando il AWS CLI](mw-cli-tutorial-tasks.md).
# Esempi: registrazione delle destinazioni con una finestra di manutenzione
Puoi registrare un singolo nodo come destinazione utilizzandone l'ID nodo, come mostrato in [Fase 2: Registrare un nodo di destinazione nella finestra di manutenzione utilizzando il AWS CLI](mw-cli-tutorial-targets.md). Puoi anche registrare uno o più nodi come destinazioni utilizzando i formati di comando forniti in questa pagina.
In generale, sono disponibili due metodi per identificare i nodi da utilizzare come destinazioni della finestra di manutenzione: specificare li singoli nodi e utilizzare i tag delle risorse. Il metodo dei tag delle risorse fornisce più opzioni, come mostrato negli esempi 2-3.
Puoi anche specificare uno o più gruppi di risorse come la destinazione di una finestra di manutenzione. Un gruppo di risorse può includere nodi e molti altri tipi di AWS risorse supportate. Gli esempi 4 e 5, di seguito, mostrano come aggiungere gruppi di risorse alle destinazioni della finestra di manutenzione.
**Nota**
Se una singola attività della finestra di manutenzione è registrata con più destinazioni, le relative chiamate di attività vengono eseguite in sequenza e non in parallelo. Se l'attività deve essere eseguita su più destinazioni contemporaneamente, registrare un'attività per ogni destinazione singolarmente e assegnare a ciascuna attività lo stesso livello di priorità.
Per ulteriori informazioni sulla creazione e la gestione di gruppi di risorse, consulta [Cosa sono i gruppi di risorse?](https://docs.aws.amazon.com/ARG/latest/userguide/resource-groups.html) nella *AWS Resource Groups Guida per l'utente* e [Gruppi di risorse e Assegnazione di tag per AWS](https://aws.amazon.com/blogs/aws/resource-groups-and-tagging/) nel *AWS News Blog*.
Per informazioni sulle quote perMaintenance Windows, uno strumento in AWS Systems Manager, oltre a quelle specificate negli esempi seguenti, vedere [Systems Manager service quotas](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) in. *Riferimenti generali di Amazon Web Services*
## Esempio 1: Registrare più destinazioni utilizzando il nodo IDs
Esegui il comando seguente sul formato del computer locale per registrare più nodi come destinazioni utilizzando il relativo nodo IDs. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE,i-07782c72faEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE ^
--resource-type "INSTANCE" ^
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE,i-07782c72faEXAMPLE
```
------
**Utilizzo consigliato**: questa opzione è particolarmente utile quando si registra per la prima volta un gruppo unico di nodi con una qualsiasi finestra di manutenzione e quando questi nodi *non* condividono un tag di nodo comune.
**Quote:** è possibile specificare fino a un massimo di 50 nodi totali per ogni destinazione della finestra di manutenzione.
## Esempio 2: registrazione delle destinazioni con i tag delle risorse applicati ai nodi
Esegui il comando seguente sul computer locale per registrare tutti i nodi già contrassegnate con una coppia chiave-valore che hai assegnato. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=tag:Region,Values=East"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=tag:Region,Values=East"
```
------
**Utilizzo consigliato**: questa opzione è particolarmente utile quando si registra per la prima volta un gruppo unico di nodi con una qualsiasi finestra di manutenzione e quando questi nodi *non* condividono un tag di nodo comune.
**Quote:** è possibile specificare fino a cinque coppie chiave-valore in totale per ogni destinazione. Se si specificano più coppie chiave-valore, un nodo deve essere contrassegnato con *tutte* le chiavi tag e i valori specificati per essere inclusi nel gruppo di destinazione.
**Nota**
È possibile applicare tag a un gruppo di nodi con la chiave di tag `Patch Group` o `PatchGroup` e assegnare ai nodi un valore di chiave comune, ad esempio `my-patch-group`. (È necessario utilizzare `PatchGroup`, senza spazio, se sono presenti [tag consentiti nei metadati dell'istanza EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#allow-access-to-tags-in-IMDS).) Patch Manager, uno strumento di Systems Manager, valuta la chiave `Patch Group` o `PatchGroup` sui nodi per determinare quale baseline delle patch vi si può applicare. Se l'attività eseguirà il documento SSM `AWS-RunPatchBaseline` o il documento legacy SSM `AWS-ApplyPatchBaseline`, è possibile specificare la stessa coppia chiave-valore `Patch Group` o `PatchGroup` quando si registrano destinazioni con una finestra di manutenzione. Ad esempio: `--target "Key=tag:PatchGroup,Values=my-patch-group`. In questo modo è possibile utilizzare una finestra di manutenzione per aggiornare le patch su un gruppo di nodi che sono già associati alla stessa baseline delle patch. Per ulteriori informazioni, consulta [Gruppi di patch](patch-manager-patch-groups.md).
## Esempio 3: registrazione delle destinazioni con un gruppo di chiavi dei tag (senza valori di tag)
Esegui il comando seguente sul computer locale per registrare tutti i nodi che hanno una o più chiavi dei tag assegnate, indipendentemente dai valori delle chiavi. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=tag-key,Values=Name,Instance-Type,CostCenter"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=tag-key,Values=Name,Instance-Type,CostCenter"
```
------
**Utilizzo consigliato**: utile quando si desidera definire i nodi come destinazioni specificando più *chiavi* dei tag (senza i relativi valori) invece di una sola coppia tag-chiave o coppia di tag chiave-valore.
**Quote:** è possibile specificare fino a cinque coppie tag-chiave in totale per ogni destinazione. Se si specificano più chiavi di tag, un nodo deve essere contrassegnato con *tutte* le chiavi tag specificate per essere incluse nel gruppo di destinazione.
## Esempio 4: registrazione di destinazioni utilizzando un nome del gruppo di risorse
Esegui il comando seguente sul computer locale per registrare un gruppo di risorse specificato, a prescindere dal tipo di risorse che contiene. Sostituiscilo *mw-0c50858d01EXAMPLE* con le tue informazioni. Se le attività assegnate alla finestra di manutenzione non agiscano su un tipo di risorsa incluso in questo gruppo di risorse, il sistema potrebbe segnalare un errore. Attività per le quali viene individuato un tipo di risorsa supportato continuano a essere eseguite nonostante questi errori.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "RESOURCE_GROUP" \
--target "Key=resource-groups:Name,Values=MyResourceGroup"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "RESOURCE_GROUP" ^
--target "Key=resource-groups:Name,Values=MyResourceGroup"
```
------
**Uso consigliato**: utile quando desideri specificare rapidamente un gruppo di risorse come una destinazione senza valutare se tutti i tipi di risorse saranno selezionati per una finestra di manutenzione, oppure quando sai che il gruppo di risorse contiene solo i tipi di risorse su cui le attività eseguono operazioni.
**Quote:** è possibile specificare un solo gruppo di risorse come una destinazione.
## Esempio 5: registrazione di destinazioni filtrando tipi di risorse in un gruppo di risorse
Esegui il comando seguente sul computer locale per registrare solo determinati tipi di risorse che appartengono a un gruppo di risorse specificato. Sostituiscila *mw-0c50858d01EXAMPLE* con le tue informazioni. Con questa opzione, anche se aggiungi un'attività per un tipo di risorsa che appartiene al gruppo di risorse, l'attività non verrà eseguita se non hai aggiunto esplicitamente il tipo di risorsa al filtro.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "RESOURCE_GROUP" \
--target "Key=resource-groups:Name,Values=MyResourceGroup" \
"Key=resource-groups:ResourceTypeFilters,Values=AWS::EC2::Instance,AWS::ECS::Cluster"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "RESOURCE_GROUP" ^
--target "Key=resource-groups:Name,Values=MyResourceGroup" ^
"Key=resource-groups:ResourceTypeFilters,Values=AWS::EC2::Instance,AWS::ECS::Cluster"
```
------
**Uso consigliato**: utile quando si desidera mantenere un controllo rigoroso sui tipi di AWS risorse su cui la finestra di manutenzione può eseguire azioni o quando il gruppo di risorse contiene un gran numero di tipi di risorse e si desidera evitare segnalazioni di errori non necessarie nei registri delle finestre di manutenzione.
**Quote:** è possibile specificare un solo gruppo di risorse come una destinazione.
# Fase 3: Registrare un'operazione nella finestra di manutenzione utilizzando il AWS CLI
In questo passaggio del tutorial, registri un' AWS Systems Manager Run Commandattività che esegue il `df` comando sulla tua istanza Amazon Elastic Compute Cloud (Amazon EC2) per Linux. I risultati di questo comando Linux standard mostrano la quantità di spazio libero disponibile e la quantità di spazio utilizzato sul file system del disco dell'istanza.
oppure
Se utilizzi un'istanza Amazon EC2 per Windows Server anziché una di Linux, nel comando seguente devi sostituire **df** con **ipconfig**. Nell'output di questo comando sono elencati i dettagli relativi all'indirizzo IP, alla maschera di sottorete e al gateway predefinito per i convertitori sull'istanza di destinazione.
Quando sei pronto a registrare altri tipi di task oppure a utilizzare un maggior numero di opzioni Run Command di Systems Manager disponibili, consulta [Esempi: registrazione delle operazioni con una finestra di manutenzione](mw-cli-register-tasks-examples.md). In questo argomento sono disponibili ulteriori informazioni su tutti e quattro i tipi di task e su alcune delle opzioni più importanti in modo da consentirti di creare scenari reali più complessi.
**Per registrare un task con una finestra di manutenzione**
1. Esegui il comando seguente sul computer locale. Sostituisci ogni *example resource placeholder* con le tue informazioni. La versione da eseguire da un computer Windows locale include i caratteri di escape ("/") necessari per eseguire il comando dallo strumento a riga di comando.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--task-arn "AWS-RunShellScript" \
--max-concurrency 1 --max-errors 1 \
--priority 10 \
--targets "Key=InstanceIds,Values=i-0471e04240EXAMPLE" \
--task-type "RUN_COMMAND" \
--task-invocation-parameters '{"RunCommand":{"Parameters":{"commands":["df"]}}}'
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--task-arn "AWS-RunShellScript" ^
--max-concurrency 1 --max-errors 1 ^
--priority 10 ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-type "RUN_COMMAND" ^
--task-invocation-parameters={\"RunCommand\":{\"Parameters\":{\"commands\":[\"df\"]}}}
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE"
}
```
1. Eseguire il comando seguente per visualizzare i dettagli relativi alla finestra di manutenzione creata.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id mw-0c50858d01EXAMPLE
```
------
1. Questo sistema restituisce informazioni simili alle seguenti.
```
{
"Tasks": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskArn": "AWS-RunShellScript",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 10,
"ServiceRoleArn": "arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1"
}
]
}
```
1. Attendere il completamento dell'esecuzione del task, in base alla pianificazione specificata nella [Fase 1: Creare la finestra di manutenzione utilizzando AWS CLI](mw-cli-tutorial-create-mw.md). Ad esempio, se è stato specificato **--schedule "rate(5 minutes)"**, attendere cinque minuti. Eseguire quindi il comando seguente per visualizzare le informazioni sulle esecuzioni completate per questo task.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id mw-0c50858d01EXAMPLE
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
]
}
```
**Suggerimento**
Dopo aver eseguito l'attività, è possibile ridurre la frequenza con cui viene eseguita la finestra di manutenzione. Ad esempio, eseguire il comando seguente per ridurre la frequenza a una volta alla settimana. *mw-0c50858d01EXAMPLE*Sostituiscilo con le tue informazioni.
```
aws ssm update-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--schedule "rate(7 days)"
```
```
aws ssm update-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--schedule "rate(7 days)"
```
Per informazioni sulla gestione delle pianificazioni delle finestre di manutenzione, consulta [Riferimento: espressioni Cron e della frequenza per Systems Manager](reference-cron-and-rate-expressions.md) e [Opzioni di pianificazione e periodo attivo per la finestra di manutenzione](maintenance-windows-schedule-options.md).
Per informazioni sull'utilizzo di AWS Command Line Interface (AWS CLI) per modificare una finestra di manutenzione, vedere[Tutorial: Aggiornare una finestra di manutenzione utilizzando il AWS CLI](maintenance-windows-cli-tutorials-update.md).
Per esercitarsi nell'esecuzione dei AWS CLI comandi e visualizzare ulteriori dettagli sull'attività della finestra di manutenzione e sulle relative esecuzioni, continua a[Tutorial: Visualizza informazioni sulle attività e sulle esecuzioni delle attività utilizzando il AWS CLI](mw-cli-tutorial-task-info.md).
**Accesso all'output dei comandi del tutorial**
L'utilizzo di per visualizzare l'*output* del Run Command comando associato alle esecuzioni delle AWS CLI attività della finestra di manutenzione non rientra nell'ambito di questo tutorial.
È possibile visualizzare questi dati, tuttavia, utilizzando il AWS CLI. (È inoltre possibile visualizzare l'output nella console di Systems Manager o in un file di log archiviato in un bucket Amazon Simple Storage Service (Amazon S3), se la finestra di manutenzione è stata configurata per l'archiviazione dell'output del comando in tale posizione.) L'output del comando **df** in un'istanza EC2 per Linux è simile a quello riportato di seguito.
```
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 485716 0 485716 0% /dev
tmpfs 503624 0 503624 0% /dev/shm
tmpfs 503624 328 503296 1% /run
tmpfs 503624 0 503624 0% /sys/fs/cgroup
/dev/xvda1 8376300 1464160 6912140 18% /
```
L'output del comando **ipconfig** in un'istanza EC2 per Windows Server è simile a quello riportato di seguito:
```
Windows IP Configuration
Ethernet adapter Ethernet 2:
Connection-specific DNS Suffix . : example.com
IPv4 Address. . . . . . . . . . . : 10.24.34.0/23
Subnet Mask . . . . . . . . . . . : 255.255.255.255
Default Gateway . . . . . . . . . : 0.0.0.0
Ethernet adapter Ethernet:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . : abc1.wa.example.net
Wireless LAN adapter Local Area Connection* 1:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . :
Wireless LAN adapter Wi-Fi:
Connection-specific DNS Suffix . :
Link-local IPv6 Address . . . . . : fe80::100b:c234:66d6:d24f%4
IPv4 Address. . . . . . . . . . . : 192.0.2.0
Subnet Mask . . . . . . . . . . . : 255.255.255.0
Default Gateway . . . . . . . . . : 192.0.2.0
Ethernet adapter Bluetooth Network Connection:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . :
```
# Esempi: registrazione delle operazioni con una finestra di manutenzione
È possibile registrare un'attività inRun Command, uno strumento in AWS Systems Manager, con una finestra di manutenzione utilizzando AWS Command Line Interface (AWS CLI), come illustrato in [Registrare le attività con la finestra di manutenzione](mw-cli-tutorial-tasks.md). È inoltre possibile registrare le attività per i flussi di lavoro, AWS Lambda le funzioni e le AWS Step Functions attività di Systems Manager Automation, come illustrato più avanti in questo argomento.
**Nota**
Specifica uno o più target per le attività di tipo Run Command della finestra di manutenzione. A seconda dell'attività, gli obiettivi sono facoltativi per altri tipi di attività della finestra di manutenzione (Automazione e AWS Step Functions). AWS Lambda Per ulteriori informazioni sull'esecuzione di attività che non specificano destinazioni, consulta [Registrazione delle attività della finestra di manutenzione senza destinazioni](maintenance-windows-targetless-tasks.md).
In questo argomento, forniamo esempi di utilizzo del comando AWS Command Line Interface (AWS CLI) `register-task-with-maintenance-window` per registrare ciascuno dei quattro tipi di attività supportati in una finestra di manutenzione. Gli esempi sono solo a titolo dimostrativo, ma è possibile modificarli per creare comandi di registrazione di task funzionanti.
**Utilizzo dell'cli-input-json opzione --**
Per ottimizzare la gestione delle opzioni relative ai task, è possibile utilizzare l'opzione di comando `--cli-input-json`, con i valori delle opzioni inclusi in un file JSON.
Per utilizzare il contenuto del file JSON di esempio disponibile negli esempi, eseguire la procedura seguente nel computer locale:
1. Creare un file assegnandogli, ad esempio, il nome `MyRunCommandTask.json`, `MyAutomationTask.json` oppure il nome desiderato.
1. Copiare il contenuto dell'esempio JSON nel file.
1. Modificare il contenuto del file per la registrazione del task, quindi salvare il file.
1. Nella stessa directory in cui è stato salvato il file, eseguire il comando seguente. Sostituisci il nome del file con. *MyFile.json*
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--cli-input-json file://MyFile.json
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--cli-input-json file://MyFile.json
```
------
**Pseudo parametri nelle attività della finestra di manutenzione**
In alcuni esempi vengono utilizzati gli *pseudoparametri* come metodo per passare le informazioni sugli ID ai task. Ad esempio, `{{TARGET_ID}}` e `{{RESOURCE_ID}}` può essere utilizzato per trasferire AWS risorse alle IDs attività di Automation, Lambda e Step Functions. Per ulteriori informazioni sugli pseudoparametri nel parametro `--task-invocation-parameters`, consulta [Utilizzo degli pseudo parametri durante la registrazione delle attività della finestra di manutenzione](maintenance-window-tasks-pseudo-parameters.md).
**Ulteriori informazioni**
+ [Opzioni dei parametri per il comando register-task-with-maintenance -windows](mw-cli-task-options.md).
+ [https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html](https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html) in *Riferimento ai comandi AWS CLI *
+ [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html) nella *Documentazione di riferimento API di AWS Systems Manager *
## Esempi di registrazione dei task
Le sezioni seguenti forniscono un AWS CLI comando di esempio per la registrazione di un tipo di attività supportato e un esempio JSON che può essere utilizzato con l'opzione. `--cli-input-json`
### Registra un task Run Command di Systems Manager
I seguenti esempi illustrano come registrare i task Run Command di Systems Manager con una finestra di manutenzione utilizzando l' AWS CLI.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--task-arn "AWS-RunShellScript" \
--max-concurrency 1 --max-errors 1 --priority 10 \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--task-type "RUN_COMMAND" \
--task-invocation-parameters '{"RunCommand":{"Parameters":{"commands":["df"]}}}'
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--task-arn "AWS-RunShellScript" ^
--max-concurrency 1 --max-errors 1 --priority 10 ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-type "RUN_COMMAND" ^
--task-invocation-parameters "{\"RunCommand\":{\"Parameters\":{\"commands\":[\"df\"]}}}"
```
------
**Contenuto JSON da utilizzare con l'opzione di file `--cli-input-json`:**
```
{
"TaskType": "RUN_COMMAND",
"WindowId": "mw-0c50858d01EXAMPLE",
"Description": "My Run Command task to update SSM Agent on an instance",
"MaxConcurrency": "1",
"MaxErrors": "1",
"Name": "My-Run-Command-Task",
"Priority": 10,
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AWS-UpdateSSMAgent",
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "A TaskInvocationParameters test comment",
"NotificationConfig": {
"NotificationArn": "arn:aws:sns:region:123456789012:my-sns-topic-name",
"NotificationEvents": [
"All"
],
"NotificationType": "Invocation"
},
"OutputS3BucketName": "amzn-s3-demo-bucket",
"OutputS3KeyPrefix": "S3-PREFIX",
"TimeoutSeconds": 3600
}
}
}
```
### Registra un task di automazione Systems Manager
I seguenti esempi illustrano come registrare i task di automazione di Systems Manager con una finestra di manutenzione utilizzando l' AWS CLI:
**AWS CLI comando:**
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--task-arn "AWS-RestartEC2Instance" \
--service-role-arn arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole \
--task-type AUTOMATION \
--task-invocation-parameters "Automation={DocumentVersion=5,Parameters={InstanceId='{{RESOURCE_ID}}'}}" \
--priority 0 --name "My-Restart-EC2-Instances-Automation-Task" \
--description "Automation task to restart EC2 instances"
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--task-arn "AWS-RestartEC2Instance" ^
--service-role-arn arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole ^
--task-type AUTOMATION ^
--task-invocation-parameters "Automation={DocumentVersion=5,Parameters={InstanceId='{{TARGET_ID}}'}}" ^
--priority 0 --name "My-Restart-EC2-Instances-Automation-Task" ^
--description "Automation task to restart EC2 instances"
```
------
**Contenuto JSON da utilizzare con l'opzione di file `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"TaskArn": "AWS-PatchInstanceWithRollback",
"TaskType": "AUTOMATION","TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "1",
"Parameters": {
"instanceId": [
"{{RESOURCE_ID}}"
]
}
}
}
}
```
### Registra un' AWS Lambda attività
I seguenti esempi illustrano come registrare le operazioni delle funzioni Lambda con una finestra di manutenzione utilizzando la AWS CLI.
Per questi esempi, l'utente che ha creato la funzione Lambda ha denominato tale funzione `SSMrestart-my-instances` e ha creato due parametri denominati `instanceId` e `targetType`.
**Importante**
La policy IAM per Maintenance Windows prevede che il nome (o l'alias) della funzione Lambda sia associato al prefisso `SSM`. Prima di procedere alla registrazione di questo tipo di attività, aggiornane il nome in AWS Lambda includi`SSM`. Ad esempio, se il nome della funzione Lambda è `MyLambdaFunction`, modificalo in `SSMMyLambdaFunction`.
**AWS CLI comando:**
------
#### [ Linux & macOS ]
**Importante**
Se si utilizza la versione 2 di AWS CLI, è necessario includere l'opzione `--cli-binary-format raw-in-base64-out` nel comando seguente se il payload Lambda non è codificato in base 64. L'opzione `cli_binary_format` è disponibile solo nella versione 2. *Per informazioni su questa e altre impostazioni dei file, consulta Impostazioni dei AWS CLI `config` [`config`file supportate](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings) nella Guida per l'utente.AWS Command Line Interface *
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--priority 2 --max-concurrency 10 --max-errors 5 --name "My-Lambda-Example" \
--description "A description for my LAMBDA example task" --task-type "LAMBDA" \
--task-arn "arn:aws:lambda:region:123456789012:function:serverlessrepo-SSMrestart-my-instances-C4JF9EXAMPLE" \
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}","Qualifier": "$LATEST"}}'
```
------
#### [ PowerShell ]
**Importante**
Se si utilizza la versione 2 di AWS CLI, è necessario includere l'opzione `--cli-binary-format raw-in-base64-out` nel comando seguente se il payload Lambda non è codificato in base 64. L'opzione `cli_binary_format` è disponibile solo nella versione 2. *Per informazioni su questa e altre impostazioni dei file, consulta Impostazioni dei AWS CLI `config` [`config`file supportate](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings) nella Guida per l'utente.AWS Command Line Interface *
```
aws ssm register-task-with-maintenance-window `
--window-id "mw-0c50858d01EXAMPLE" `
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" `
--priority 2 --max-concurrency 10 --max-errors 5 --name "My-Lambda-Example" `
--description "A description for my LAMBDA example task" --task-type "LAMBDA" `
--task-arn "arn:aws:lambda:region:123456789012:function:serverlessrepo-SSMrestart-my-instances-C4JF9EXAMPLE" `
--task-invocation-parameters '{\"Lambda\":{\"Payload\":\"{\\\"InstanceId\\\":\\\"{{RESOURCE_ID}}\\\",\\\"targetType\\\":\\\"{{TARGET_TYPE}}\\\"}\",\"Qualifier\": \"$LATEST\"}}'
```
------
**Contenuto JSON da utilizzare con l'opzione di file `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "SSM_RestartMyInstances",
"TaskType": "LAMBDA",
"MaxConcurrency": "10",
"MaxErrors": "10",
"TaskInvocationParameters": {
"Lambda": {
"ClientContext": "ew0KICAi--truncated--0KIEXAMPLE",
"Payload": "{ \"instanceId\": \"{{RESOURCE_ID}}\", \"targetType\": \"{{TARGET_TYPE}}\" }",
"Qualifier": "$LATEST"
}
},
"Name": "My-Lambda-Task",
"Description": "A description for my LAMBDA task",
"Priority": 5
}
```
### Register a Step Functions task (Registra un'attività Step Functions)
I seguenti esempi illustrano come registrare i task delle macchine a stati Step Functions con una finestra di manutenzione utilizzando l' AWS CLI.
**Nota**
Le attività della finestra di manutenzione supportano solo i flussi di lavoro delle macchine a stati standard di Step Functions. Non supportano i flussi di lavoro delle macchine a stati express. Per informazioni sui tipi di flusso di lavoro delle macchine a stati, consulta [Standard vs. Express Workflows](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html) (Differenze flussi di lavoro standard ed express) nella *Guida per gli sviluppatori di AWS Step Functions *.
Per questi esempi, l'utente che ha creato le macchine a stati Step Functions ha creato una macchina a stati denominata `SSMMyStateMachine` con un parametro denominato `instanceId`.
**Importante**
La policy AWS Identity and Access Management (IAM) per Maintenance Windows richiede che i nomi delle macchine a stati Step Functions vengano aggiunti come prefisso. `SSM` Prima di procedere alla registrazione di questo tipo di task, è necessario aggiornare il relativo nome in AWS Step Functions in modo da includere `SSM`. Ad esempio, se il nome della macchina a stati è `MyStateMachine`, modifica tale nome in `SSMMyStateMachine`.
**AWS CLI comando:**
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn arn:aws:states:region:123456789012:stateMachine:SSMMyStateMachine-MggiqEXAMPLE \
--task-type STEP_FUNCTIONS \
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}", "Name":"{{INVOCATION_ID}}"}}' \
--priority 0 --max-concurrency 10 --max-errors 5 \
--name "My-Step-Functions-Task" --description "A description for my Step Functions task"
```
------
#### [ PowerShell ]
```
aws ssm register-task-with-maintenance-window `
--window-id "mw-0c50858d01EXAMPLE" `
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" `
--task-arn arn:aws:states:region:123456789012:stateMachine:SSMMyStateMachine-MggiqEXAMPLE `
--task-type STEP_FUNCTIONS `
--task-invocation-parameters '{\"StepFunctions\":{\"Input\":\"{\\\"InstanceId\\\":\\\"{{RESOURCE_ID}}\\\"}\", \"Name\":\"{{INVOCATION_ID}}\"}}' `
--priority 0 --max-concurrency 10 --max-errors 5 `
--name "My-Step-Functions-Task" --description "A description for my Step Functions task"
```
------
**Contenuto JSON da utilizzare con l'opzione di file `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "SSM_MyStateMachine",
"TaskType": "STEP_FUNCTIONS",
"MaxConcurrency": "10",
"MaxErrors": "10",
"TaskInvocationParameters": {
"StepFunctions": {
"Input": "{ \"instanceId\": \"{{TARGET_ID}}\" }",
"Name": "{{INVOCATION_ID}}"
}
},
"Name": "My-Step-Functions-Task",
"Description": "A description for my Step Functions task",
"Priority": 5
}
```
# Opzioni dei parametri per il comando register-task-with-maintenance -windows
Il comando **register-task-with-maintenance-window** dispone di diverse opzioni per la configurazione di un task in base a esigenze specifiche. Alcune opzioni sono obbligatorie, altre sono facoltative, mentre alcune di esse sono valide solo per un tipo specifico di task della finestra di manutenzione.
Questo argomento fornisce informazioni su alcune di queste opzioni a supporto delle procedure di utilizzo degli esempi disponibili in questa sezione del tutorial. Per informazioni su altre opzioni di comando, consulta **[https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html](https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html)** nelle *Informazioni di riferimento sui comandi AWS CLI *.
**Opzione di comando: `--task-arn`**
L'opzione `--task-arn` consente di specificare la risorsa utilizzata dal task durante l'operazione. Il valore che è possibile specificare dipende dal tipo di task che si sta registrando, come descritto nella seguente tabella.
**TaskArn formati per le attività delle finestre di manutenzione**
| Tipo di task della finestra di manutenzione | TaskArn valore |
| --- | --- |
| **`RUN_COMMAND`** e ** `AUTOMATION`** | `TaskArn` è il nome del documento SSM o l'Amazon Resource Name (ARN). Ad esempio: `AWS-RunBatchShellScript` oppure `arn:aws:ssm:region:111122223333:document/My-Document`. |
| **`LAMBDA`** | `TaskArn` è l'ARN o il nome della funzione. Ad esempio: `SSMMy-Lambda-Function` oppure `arn:aws:lambda:region:111122223333:function:SSMMyLambdaFunction`. La policy IAM per Maintenance Windows prevede che il nome (o l'alias) della funzione Lambda sia associato al prefisso `SSM`. Prima di procedere alla registrazione di questo tipo di attività, aggiornane il nome in AWS Lambda includi`SSM`. Ad esempio, se il nome della funzione Lambda è `MyLambdaFunction`, modifica tale nome in `SSMMyLambdaFunction`. |
| **`STEP_FUNCTIONS`** | `TaskArn` è l'ARN della macchina a stati. Ad esempio: `arn:aws:states:us-east-2:111122223333:stateMachine:SSMMyStateMachine`. La policy IAM per le finestre di manutenzione prevede che i nomi delle macchine a stati Step Functions siano associati al prefisso `SSM`. Prima di registrare questo tipo di task, è necessario aggiornare il relativo nome in AWS Step Functions in modo da includere `SSM`. Ad esempio, se il nome della macchina a stati è `MyStateMachine`, modifica tale nome in `SSMMyStateMachine`. |
**Opzione di comando: `--service-role-arn`**
Il ruolo AWS Systems Manager da assumere durante l'esecuzione dell'operazione della finestra di manutenzione.
Per ulteriori informazioni, consulta [Configurazione di Maintenance Windows](setting-up-maintenance-windows.md)
**Opzione di comando: `--task-invocation-parameters`**
L'opzione `--task-invocation-parameters` viene utilizzata per specificare i parametri univoci per ciascuno dei quattro tipi di task. I parametri supportati per ciascuno dei quattro tipi di task sono descritti nella tabella riportata di seguito.
**Nota**
Per informazioni sull'utilizzo degli pseudoparametri nel contenuto `--task-invocation-parameters`, ad esempio \$1\$1TARGET\$1ID\$1\$1, consulta [Utilizzo degli pseudo parametri durante la registrazione delle attività della finestra di manutenzione](maintenance-window-tasks-pseudo-parameters.md).
Opzioni dei parametri di invocazione dei task per i task della finestra di manutenzione
| Tipo di task della finestra di manutenzione | Parametri disponibili | Esempio |
| --- | --- | --- |
| **`RUN_COMMAND`** | `Comment` `DocumentHash` `DocumentHashType` `NotificationConfig` `OutputS3BucketName` `OutPutS3KeyPrefix` `Parameters` `ServiceRoleArn` `TimeoutSeconds` | "TaskInvocationParameters": {
"RunCommand": {
"Comment": "My Run Command task comment",
"DocumentHash": "6554ed3d--truncated--5EXAMPLE",
"DocumentHashType": "Sha256",
"NotificationConfig": {
"NotificationArn": "arn:aws:sns:region:123456789012:my-sns-topic-name",
"NotificationEvents": [
"FAILURE"
],
"NotificationType": "Invocation"
},
"OutputS3BucketName": "amzn-s3-demo-bucket",
"OutputS3KeyPrefix": "S3-PREFIX",
"Parameters": {
"commands": [
"Get-ChildItem$env: temp-Recurse|Remove-Item-Recurse-force"
]
},
"ServiceRoleArn": "arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole",
"TimeoutSeconds": 3600
}
} |
| **`AUTOMATION`** | `DocumentVersion` `Parameters` | "TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "3",
"Parameters": {
"instanceid": [
"{{TARGET_ID}}"
]
}
}
} |
| **`LAMBDA`** | `ClientContext` `Payload` `Qualifier` | "TaskInvocationParameters": {
"Lambda": {
"ClientContext": "ew0KICAi--truncated--0KIEXAMPLE",
"Payload": "{ \"targetId\": \"{{TARGET_ID}}\", \"targetType\": \"{{TARGET_TYPE}}\" }",
"Qualifier": "$LATEST"
}
} |
| **`STEP_FUNCTIONS`** | `Input` `Name` | "TaskInvocationParameters": {
"StepFunctions": {
"Input": "{ \"targetId\": \"{{TARGET_ID}}\" }",
"Name": "{{INVOCATION_ID}}"
}
} |
# Tutorial: Visualizza le informazioni sulle finestre di manutenzione utilizzando il AWS CLI
Questo tutorial include comandi che consentono di aggiornare o ottenere informazioni su finestre di manutenzione, task, esecuzioni e invocazioni. Gli esempi sono organizzati per comando, per dimostrare come utilizzare le opzioni dei comandi per filtrare il tipo di dettaglio che si desidera visualizzare.
Mentre segui i passaggi di questo tutorial, sostituisci i valori nel *red* testo in corsivo con le tue opzioni e. IDs Ad esempio, sostituisci l'ID della finestra di manutenzione *mw-0c50858d01EXAMPLE* e l'ID dell'istanza *i-02573cafcfEXAMPLE* con l'ID IDs delle risorse che crei.
Per informazioni sull'impostazione e la configurazione di AWS Command Line Interface (AWS CLI), consultate [Installazione, aggiornamento e disinstallazione di AWS CLI e](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) [Configurazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) di. AWS CLI
**Topics**
+ [Esempi di '' describe-maintenance-windows](#mw-cli-tutorials-describe-maintenance-windows)
+ [Esempi di 'describe-maintenance-window-targets'](#mw-cli-tutorials-describe-maintenance-window-targets)
+ [Esempi per 'describe-maintenance-window-tasks'](#mw-cli-tutorials-describe-maintenance-window-tasks)
+ [Esempi per 'describe-maintenance-windows-for-target'](#mw-cli-tutorials-describe-maintenance-windows-for-target)
+ [Esempi per '' describe-maintenance-window-executions](#mw-cli-tutorials-describe-maintenance-window-executions)
+ [Esempi per 'describe-maintenance-window-schedule'](#mw-cli-tutorials-describe-maintenance-window-schedule)
## Esempi di '' describe-maintenance-windows
**Elenca tutte le finestre di manutenzione del tuo Account AWS**
Eseguire il seguente comando seguente.
```
aws ssm describe-maintenance-windows
```
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowIdentities":[
{
"WindowId":"mw-0c50858d01EXAMPLE",
"Name":"My-First-Maintenance-Window",
"Enabled":true,
"Duration":2,
"Cutoff":0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId":"mw-9a8b7c6d5eEXAMPLE",
"Name":"My-Second-Maintenance-Window",
"Enabled":true,
"Duration":4,
"Cutoff":1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
]
}
```
**Elenca tutte le finestre di manutenzione abilitate**
Eseguire il seguente comando seguente.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=true"
```
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowIdentities":[
{
"WindowId":"mw-0c50858d01EXAMPLE",
"Name":"My-First-Maintenance-Window",
"Enabled":true,
"Duration":2,
"Cutoff":0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId":"mw-9a8b7c6d5eEXAMPLE",
"Name":"My-Second-Maintenance-Window",
"Enabled":true,
"Duration":4,
"Cutoff":1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
]
}
```
**Elenca tutte le finestre di manutenzione disabilitate**
Eseguire il seguente comando seguente.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=false"
```
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowIdentities": [
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
**Elenca tutte le finestre di manutenzione con nomi che iniziano con un determinato prefisso**
Eseguire il seguente comando seguente.
```
aws ssm describe-maintenance-windows --filters "Key=Name,Values=My"
```
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"Enabled": true,
"Duration": 4,
"Cutoff": 1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
## Esempi di 'describe-maintenance-window-targets'
**Visualizza le destinazioni di una finestra di manutenzione che corrispondono a un determinato valore delle informazioni dello specifico proprietario**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-6e5c9d4b7cEXAMPLE" \
--filters "Key=OwnerInformation,Values=CostCenter1"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-6e5c9d4b7cEXAMPLE" ^
--filters "Key=OwnerInformation,Values=CostCenter1"
```
------
**Nota**
Le chiavi di filtro supportate sono `Type`, `WindowTargetId` e `OwnerInformation`.
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "tag:Name",
"Values": [
"Production"
]
}
],
"OwnerInformation": "CostCenter1",
"Name": "Target1"
}
]
}
```
## Esempi per 'describe-maintenance-window-tasks'
**Mostra tutte le attività registrate che richiamano al documento del comando SSM `AWS-RunPowerShellScript`**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-0c50858d01EXAMPLE" \
--filters "Key=TaskArn,Values=AWS-RunPowerShellScript"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-0c50858d01EXAMPLE" ^
--filters "Key=TaskArn,Values=AWS-RunPowerShellScript"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"Tasks":[
{
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"driverquery.exe"
]
}
},
"Priority":3,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"INSTANCE"
}
]
},
{
"ServiceRoleArn":"arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"ipconfig"
]
}
},
"Priority":1,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"WINDOW_TARGET"
}
]
}
]
}
```
**Mostra tutte le attività registrate che hanno una priorità di "3"**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=Priority,Values=3"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=Priority,Values=3"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"Tasks":[
{
"ServiceRoleArn":"arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"driverquery.exe"
]
}
},
"Priority":3,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"INSTANCE"
}
]
}
]
}
```
**Mostra tutte le attività registrate che hanno una priorità di "1" e utilizzano Run Command**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-0c50858d01EXAMPLE" \
--filters "Key=Priority,Values=1" "Key=TaskType,Values=RUN_COMMAND"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-0c50858d01EXAMPLE" ^
--filters "Key=Priority,Values=1" "Key=TaskType,Values=RUN_COMMAND"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"Tasks": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskArn": "AWS-RunShellScript",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 1,
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "8a5c4629-31b0-4edd-8aea-33698EXAMPLE",
"TaskArn": "AWS-UpdateSSMAgent",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-0471e04240EXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 1,
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1",
"Name": "My-Run-Command-Task",
"Description": "My Run Command task to update SSM Agent on an instance"
}
]
}
```
## Esempi per 'describe-maintenance-windows-for-target'
**Elenca le informazioni sulle destinazioni della finestra di manutenzione o sui task associati a un nodo specifico.**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-windows-for-target \
--resource-type INSTANCE \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--max-results 10
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-windows-for-target ^
--resource-type INSTANCE ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--max-results 10
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window"
}
]
}
```
## Esempi per '' describe-maintenance-window-executions
**Visualizza tutte le attività eseguite prima di una determinata data**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=ExecutedBefore,Values=2019-05-12T05:00:00Z"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=ExecutedBefore,Values=2019-05-12T05:00:00Z"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "FAILED",
"StatusDetails": "The following SSM parameters are invalid: LevelUp",
"StartTime": 1557617747.993,
"EndTime": 1557617748.101
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557594085.428,
"EndTime": 1557594090.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
}
]
}
```
**Elenca tutte le attività eseguite dopo una determinata data**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=ExecutedAfter,Values=2018-12-31T17:00:00Z"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=ExecutedAfter,Values=2018-12-31T17:00:00Z"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "FAILED",
"StatusDetails": "The following SSM parameters are invalid: LevelUp",
"StartTime": 1557617747.993,
"EndTime": 1557617748.101
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557594085.428,
"EndTime": 1557594090.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
}
]
}
```
## Esempi per 'describe-maintenance-window-schedule'
**Visualizza le prossime dieci esecuzioni programmate della finestra di manutenzione per un determinato nodo.**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--resource-type INSTANCE \
--targets "Key=InstanceIds,Values=i-07782c72faEXAMPLE" \
--max-results 10
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--resource-type INSTANCE ^
--targets "Key=InstanceIds,Values=i-07782c72faEXAMPLE" ^
--max-results 10
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"ScheduledWindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-05-18T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-05-25T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-01T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-08T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-06-15T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-22T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-06-29T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-07-06T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-07-13T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-07-20T23:35:24.902Z"
}
],
"NextToken": "AAEABUXdceT92FvtKld/dGHELj5Mi+GKW/EXAMPLE"
}
```
**Visualizza la pianificazione della finestra di manutenzione per i nodi taggati con una determinata coppia chiave-valore**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--resource-type INSTANCE \
--targets "Key=tag:prod,Values=rhel7"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--resource-type INSTANCE ^
--targets "Key=tag:prod,Values=rhel7"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"ScheduledWindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-20T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-21T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-22T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-23T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-24T05:34:56-07:00"
}
],
"NextToken": "AAEABccwSXqQRGKiTZ1yzGELR6cxW4W/EXAMPLE"
}
```
**Visualizza gli orari di inizio delle prossime quattro esecuzioni di una finestra di manutenzione**
Eseguire il seguente comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--window-id "mw-0c50858d01EXAMPLE" \
--max-results "4"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--window-id "mw-0c50858d01EXAMPLE" ^
--max-results "4"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowSchedule": [
{
"ScheduledWindowExecutions": [
{
"ExecutionTime": "2019-10-04T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-11T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-18T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-25T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
}
]
}
]
}
```
# Tutorial: Visualizza informazioni sulle attività e sulle esecuzioni delle attività utilizzando il AWS CLI
Questo tutorial dimostra come utilizzare AWS Command Line Interface (AWS CLI) per visualizzare i dettagli sulle attività completate nella finestra di manutenzione.
Se arrivi direttamente da [Tutorial: Creare e configurare una finestra di manutenzione utilizzando il AWS CLI](maintenance-windows-cli-tutorials-create.md), verifica di aver lasciato tempo sufficiente alla finestra di manutenzione per completare l'esecuzione almeno una volta al fine di visualizzare i risultati dell'esecuzione.
Man mano che seguite i passaggi di questo tutorial, sostituite i valori nel *red* testo in corsivo con le vostre opzioni e. IDs Ad esempio, sostituisci l'ID della finestra di manutenzione *mw-0c50858d01EXAMPLE* e l'ID dell'istanza *i-02573cafcfEXAMPLE* con l'ID IDs delle risorse che crei.
**Per visualizzare informazioni sulle attività e sulle esecuzioni delle attività utilizzando il AWS CLI**
1. Per visualizzare un elenco di esecuzioni delle attività per una specifica finestra di manutenzione, eseguire il seguente comando.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StatusDetails": "No tasks to execute.",
"StartTime": 1557593193.309,
"EndTime": 1557593193.334
}
]
}
```
1. Per ottenere informazioni sull'esecuzione di un'attività in una finestra di manutenzione, eseguire il seguente comando.
------
#### [ Linux & macOS ]
```
aws ssm get-maintenance-window-execution \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm get-maintenance-window-execution ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskIds": [
"c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
],
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
```
1. Per visualizzare l'elenco delle attività completate nell'ambito di un'esecuzione di una finestra di manutenzione, eseguire il seguente comando.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-execution-tasks \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-execution-tasks ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutionTaskIdentities": [
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.162,
"EndTime": 1557593498.57,
"TaskArn": "AWS-RunShellScript",
"TaskType": "RUN_COMMAND"
}
]
}
```
1. Per ottenere informazioni su un'esecuzione di attività, esegui il seguente comando.
------
#### [ Linux & macOS ]
```
aws ssm get-maintenance-window-execution-task \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" \
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm get-maintenance-window-execution-task ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" ^
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"TaskArn": "AWS-RunShellScript",
"ServiceRole": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"Type": "RUN_COMMAND",
"TaskParameters": [
{
"aws:InstanceId": {
"Values": [
"i-02573cafcfEXAMPLE"
]
},
"commands": {
"Values": [
"df"
]
}
}
],
"Priority": 10,
"MaxConcurrency": "1",
"MaxErrors": "1",
"Status": "SUCCESS",
"StartTime": 1557593493.162,
"EndTime": 1557593498.57
}
```
1. Per ottenere la specifica chiamata dell'attività eseguita per l'esecuzione di un'attività, esegui il seguente comando.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-execution-task-invocations \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" \
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-execution-task-invocations ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" ^
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowExecutionTaskInvocationIdentities": [
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"InvocationId": "c336d2ab-09de-44ba-8f6a-6136cEXAMPLE",
"ExecutionId": "76a5a04f-caf6-490c-b448-92c02EXAMPLE",
"TaskType": "RUN_COMMAND",
"Parameters": "{\"documentName\":\"AWS-RunShellScript\",\"instanceIds\":[\"i-02573cafcfEXAMPLE\"],\"maxConcurrency\":\"1\",\"maxErrors\":\"1\",\"parameters\":{\"commands\":[\"df\"]}}",
"Status": "SUCCESS",
"StatusDetails": "Success",
"StartTime": 1557593493.222,
"EndTime": 1557593498.466
}
]
}
```
# Tutorial: Aggiornare una finestra di manutenzione utilizzando il AWS CLI
Questo tutorial mostra come usare il AWS Command Line Interface (AWS CLI) per aggiornare una finestra di manutenzione. Mostra anche come aggiornare diversi tipi di attività, incluse quelle per AWS Systems Manager Run Command and Automation e AWS Step Functions. AWS Lambda
Gli esempi di questa sezione utilizzano le seguenti operazioni Systems Manager per l'aggiornamento di una finestra di manutenzione:
+ [UpdateMaintenanceWindow](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindow.html)
+ [UpdateMaintenanceWindowTarget](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindowTarget.html)
+ [UpdateMaintenanceWindowTask](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindowTask.html)
+ [DeregisterTargetFromMaintenanceWindow](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DeregisterTargetFromMaintenanceWindow.html)
Per informazioni sull'utilizzo della console di Systems Manager per aggiornare una finestra di manutenzione, consulta [Aggiorna o elimina le risorse della finestra di manutenzione utilizzando la console](sysman-maintenance-update.md).
Mentre segui i passaggi di questo tutorial, sostituisci i valori nel *red* testo in corsivo con le tue opzioni e. IDs Ad esempio, sostituisci l'ID della finestra di manutenzione *mw-0c50858d01EXAMPLE* e l'ID dell'istanza *i-02573cafcfEXAMPLE* con l'ID IDs delle risorse che crei.
**Per aggiornare una finestra di manutenzione utilizzando il AWS CLI**
1. Apri AWS CLI ed esegui il comando seguente per aggiornare una destinazione in modo da includere un nome e una descrizione.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-target \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--name "My-Maintenance-Window-Target" \
--description "Description for my maintenance window target"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-target ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--name "My-Maintenance-Window-Target" ^
--description "Description for my maintenance window target"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target",
"Description": "Description for my maintenance window target"
}
```
1. Eseguire questo comando per utilizzare l'opzione `replace` per rimuovere il campo descrizione e aggiungere un'ulteriore destinazione. Il campo descrizione è rimosso, perché l'aggiornamento non include il campo (valore nullo). Assicurarsi di specificare un nodo aggiuntivo configurato per l'utilizzo con Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-target \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "d208dedf-3f6b-41ff-ace8-8e751EXAMPLE" \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE" \
--name "My-Maintenance-Window-Target" \
--replace
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-target ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "d208dedf-3f6b-41ff-ace8-8e751EXAMPLE" ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE" ^
--name "My-Maintenance-Window-Target" ^
--replace
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE",
"i-0471e04240EXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target"
}
```
1. L'opzione `start-date` permette di ritardare l'attivazione di una finestra di manutenzione fino a una data futura indicata. L'opzione `end-date` permette di impostare una data e un'ora nel futuro dopo la quale la finestra di manutenzione non sarà più eseguita. Specificare le opzioni in formato ISO-8601 Extended.
Eseguire il comando seguente per specificare un intervallo di data e ora per esecuzioni regolarmente pianificate della finestra di manutenzione.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--start-date "2020-10-01T10:10:10Z" \
--end-date "2020-11-01T10:10:10Z"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--start-date "2020-10-01T10:10:10Z" ^
--end-date "2020-11-01T10:10:10Z"
```
------
1. Esegui il seguente comando per aggiornare un task Run Command.
**Suggerimento**
Se il target è un'istanza Amazon Elastic Compute Cloud (Amazon EC2) per Windows Server, modifica da `df` a `ipconfig` e da `AWS-RunShellScript` a `AWS-RunPowerShellScript` nel comando seguente.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "AWS-RunShellScript" \
--service-role-arn "arn:aws:iam::account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters "RunCommand={Comment=Revising my Run Command task,Parameters={commands=df}}" \
--priority 1 --max-concurrency 10 --max-errors 4 \
--name "My-Task-Name" --description "A description for my Run Command task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn "AWS-RunShellScript" ^
--service-role-arn "arn:aws:iam::account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters "RunCommand={Comment=Revising my Run Command task,Parameters={commands=df}}" ^
--priority 1 --max-concurrency 10 --max-errors 4 ^
--name "My-Task-Name" --description "A description for my Run Command task"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AWS-RunShellScript",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "Revising my Run Command task",
"Parameters": {
"commands": [
"df"
]
}
}
},
"Priority": 1,
"MaxConcurrency": "10",
"MaxErrors": "4",
"Name": "My-Task-Name",
"Description": "A description for my Run Command task"
}
```
1. Adatta ed esegui il seguente comando per aggiornare un task Lambda.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id mw-0c50858d01EXAMPLE \
--window-task-id 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "arn:aws:lambda:region:111122223333:function:SSMTestLambda" \
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}"}}' \
--priority 1 --max-concurrency 10 --max-errors 5 \
--name "New-Lambda-Task-Name" \
--description "A description for my Lambda task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id mw-0c50858d01EXAMPLE ^
--window-task-id 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn --task-arn "arn:aws:lambda:region:111122223333:function:SSMTestLambda" ^
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}"}}' ^
--priority 1 --max-concurrency 10 --max-errors 5 ^
--name "New-Lambda-Task-Name" ^
--description "A description for my Lambda task"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
],
"TaskArn": "arn:aws:lambda:us-east-2:111122223333:function:SSMTestLambda",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"Lambda": {
"Payload": "e30="
}
},
"Priority": 1,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "New-Lambda-Task-Name",
"Description": "A description for my Lambda task"
}
```
1. Se stai aggiornando un'attività Step Functions, adatta ed esegui il comando seguente per aggiornarla task-invocation-parameters.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "arn:aws:states:region:execution:SSMStepFunctionTest" \
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}"}}' \
--priority 0 --max-concurrency 10 --max-errors 5 \
--name "My-Step-Functions-Task" \
--description "A description for my Step Functions task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn "arn:aws:states:region:execution:SSMStepFunctionTest" ^
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}"}}' ^
--priority 0 --max-concurrency 10 --max-errors 5 ^
--name "My-Step-Functions-Task" ^
--description "A description for my Step Functions task"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "arn:aws:states:us-east-2:111122223333:execution:SSMStepFunctionTest",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"StepFunctions": {
"Input": "{\"instanceId\":\"{{RESOURCE_ID}}\"}"
}
},
"Priority": 0,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "My-Step-Functions-Task",
"Description": "A description for my Step Functions task"
}
```
1. Eseguire il comando seguente per annullare la registrazione di una destinazione da una finestra di manutenzione. Questo esempio utilizza il parametro `safe` per determinare se la destinazione è referenziata da una qualsiasi e quindi se l'annullamento della registrazione è sicuro.
------
#### [ Linux & macOS ]
```
aws ssm deregister-target-from-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--safe
```
------
#### [ Windows ]
```
aws ssm deregister-target-from-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--safe
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
An error occurred (TargetInUseException) when calling the DeregisterTargetFromMaintenanceWindow operation:
This Target cannot be deregistered because it is still referenced in Task: 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE
```
1. Eseguire il comando seguente per annullare la registrazione di una destinazione da una finestra di manutenzione anche se la destinazione è referenziata da un'attività. È possibile forzare l'operazione di annullamento della registrazione utilizzando il parametro `no-safe`.
------
#### [ Linux & macOS ]
```
aws ssm deregister-target-from-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--no-safe
```
------
#### [ Windows ]
```
aws ssm deregister-target-from-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--no-safe
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Esegui il seguente comando per aggiornare un task Run Command. Questo esempio utilizza un parametro Parameter Store Systems Manager denominato `UpdateLevel`, formattato nel seguente modo: '`{{ssm:UpdateLevel}}`'
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--task-invocation-parameters "RunCommand={Comment=A comment for my task update,Parameters={UpdateLevel='{{ssm:UpdateLevel}}'}}"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-invocation-parameters "RunCommand={Comment=A comment for my task update,Parameters={UpdateLevel='{{ssm:UpdateLevel}}'}}"
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskArn": "AWS-RunShellScript",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "A comment for my task update",
"Parameters": {
"UpdateLevel": [
"{{ssm:UpdateLevel}}"
]
}
}
},
"Priority": 10,
"MaxConcurrency": "1",
"MaxErrors": "1"
}
```
1. Eseguire questo comando per aggiornare un'attività di automazione per specificare i parametri `WINDOW_ID` e `WINDOW_TASK_ID` per il parametro `task-invocation-parameters`:
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE \
--task-arn "AutoTestDoc" \
--service-role-arn "arn:aws:iam:account-id:role/MyMaintenanceWindowServiceRole \
--task-invocation-parameters "Automation={Parameters={InstanceId='{{RESOURCE_ID}}',initiator='{{WINDOW_ID}}.Task-{{WINDOW_TASK_ID}}'}}" \
--priority 3 --max-concurrency 10 --max-errors 5
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE ^
--task-arn "AutoTestDoc" ^
--service-role-arn "arn:aws:iam:account-id:role/MyMaintenanceWindowServiceRole ^
--task-invocation-parameters "Automation={Parameters={InstanceId='{{RESOURCE_ID}}',initiator='{{WINDOW_ID}}.Task-{{WINDOW_TASK_ID}}'}}" ^
--priority 3 --max-concurrency 10 --max-errors 5
```
------
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AutoTestDoc",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"Automation": {
"Parameters": {
"multi": [
"{{WINDOW_TASK_ID}}"
],
"single": [
"{{WINDOW_ID}}"
]
}
}
},
"Priority": 0,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "My-Automation-Task",
"Description": "A description for my Automation task"
}
```
# Tutorial: Eliminare una finestra di manutenzione utilizzando il AWS CLI
Per eliminare una finestra di manutenzione creata in queste esercitazioni, eseguire il seguente comando.
```
aws ssm delete-maintenance-window --window-id "mw-0c50858d01EXAMPLE"
```
Questo sistema restituisce informazioni simili alle seguenti.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```