• 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
I tutorial mostrano come eseguire le attività comuni quando si utilizzano le finestre di manutenzione.
**Completamento dei prerequisiti**
Prima di eseguire questi tutorial, completare le attività seguenti.
+ **Configurazione della AWS CLI nel computer locale**: prima di poter eseguire i comandi della AWS CLI, è necessario installare e configurare la CLI nel computer locale. Per informazioni, consulta le pagine [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [Installazione di AWS Strumenti per PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
+ **Verifica di ruoli e autorizzazioni a livello di finestra di manutenzione**: un amministratore AWS nell'account in uso deve concederti le autorizzazioni AWS Identity and Access Management (IAM) necessarie per la gestione delle finestre di manutenzione mediante la CLI. Per informazioni, consultare [Configurazione di Maintenance Windows](setting-up-maintenance-windows.md).
+ **Creazione o configurazione di un'istanza compatibile con Systems Manager**: per poter completare i tutorial, è necessario disporre di almeno un'istanza Amazon Elastic Compute Cloud (Amazon EC2) configurata per l'uso con Systems Manager. Ciò significa che SSM Agent è installato sull'istanza e un profilo dell'istanza IAM per Systems Manager è collegato all'istanza.
Ti consigliamo di avviare un'istanza da un'Amazon Machine Image (AMI) gestita da AWS con l'agente preinstallato. Per ulteriori informazioni, consulta [Trova AMIs con SSM Agent preinstallato](ami-preinstalled-agent.md).
Per informazioni su come installare SSM Agent su un'istanza, consulta i seguenti argomenti:
+ [Installazione e disinstallazione manuale di SSM Agent su istanze EC2 per Windows Server](manually-install-ssm-agent-windows.md)
+ [Installazione e disinstallazione manuale di SSM Agent su istanze EC2 per Linux](manually-install-ssm-agent-linux.md)
Per informazioni su come configurare le autorizzazioni IAM per Systems Manager per l'istanza in uso, consulta la pagina [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md).
+ **Creazione delle risorse aggiuntive necessarie**: Run Command, uno strumento di Systems Manager, include diverse attività che non richiedono la creazione di risorse aggiuntive rispetto a quelle elencate in questo argomento sui prerequisiti. Per questo motivo, forniamo un task Run Command semplice che puoi utilizzare la prima volta che esegui i tutorial. È inoltre necessario disporre di un'istanza EC2 configurata per l'uso con Systems Manager, come descritto in precedenza in questo argomento. Dopo aver configurato l'istanza, potrai registrare un task Run Command semplice.
Lo strumento Maintenance Windows di Systems Manager supporta l'esecuzione dei quattro tipi di attività seguenti:
+ Comandi Run Command
+ Flussi di lavoro di automazione di Systems Manager
+ Funzioni AWS Lambda
+ Processi AWS Step Functions
In linea generale, se un task della finestra di manutenzione che si desidera eseguire richiede risorse aggiuntive, è necessario crearle prima. Ad esempio, se si desidera che una finestra di manutenzione esegua una funzione di AWS Lambda, è necessario creare la funzione di Lambda prima di iniziare. Per un'attività Run Command, è necessario creare il bucket S3 in cui salvare l'output del comando (se si prevede di farlo) e così via.
**Topics**
+ [Tutorial: creazione e gestione delle finestre di manutenzione utilizzando AWS CLI](maintenance-window-tutorial-cli.md)
+ [Tutorial: creazione di una finestra di manutenzione per l'applicazione di patch tramite console](maintenance-window-tutorial-patching.md)
# 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"
}
```
# Tutorial: creazione di una finestra di manutenzione per l'applicazione di patch tramite console
**Importante**
Puoi continuare a usare questo argomento legacy per creare una finestra di manutenzione per l'applicazione di patch. Consigliamo, tuttavia, di utilizzare una policy di patch. Per ulteriori informazioni, consultare [Configurazioni delle policy di patch in Quick Setup](patch-manager-policies.md) e [Configura l'applicazione di patch per le istanze in un'organizzazione utilizzando una policy di patch di Quick Setup](quick-setup-patch-manager.md).
Per ridurre al minimo l'impatto sulla disponibilità dei server, ti consigliamo di configurare una finestra di manutenzione per eseguire l'applicazione di patch in orari che non interrompano le attività aziendali.
È necessario configurare ruoli e autorizzazioni perMaintenance Windows, uno strumento in AWS Systems Manager, prima di iniziare questa procedura. Per ulteriori informazioni, consulta [Configurazione di Maintenance Windows](setting-up-maintenance-windows.md).
**Per creare una finestra di manutenzione per l'applicazione di patch**
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 **Maintenance Windows**.
1. Scegli **Crea finestra di manutenzione**.
1. Nel campo **Nome**, immetti un nome che lo indichi come una finestra di manutenzione per l'applicazione di aggiornamenti critici e importanti.
1. (Facoltativo) In **Descrizione**, immetti una descrizione.
1. Scegli **Consenti destinazioni non registrate** per consentire a un'attività di una finestra di manutenzione di essere eseguita su nodi gestiti, anche se tali nodi non sono stati registrati come destinazioni.
Se si sceglie questa opzione, è possibile scegliere i nodi non registrati (per ID nodo) quando si registra un'attività sulla finestra di manutenzione.
Se non si sceglie questa opzione, è necessario scegliere destinazioni precedentemente registrate quando si registra un'attività sulla finestra di manutenzione.
1. Nella parte superiore della sezione **Pianificazione**, specifica una pianificazione per la finestra di manutenzione tramite una delle tre opzioni di pianificazione.
Per informazioni sulla creazione di cron/rate espressioni, vedere[Riferimento: espressioni Cron e della frequenza per Systems Manager](reference-cron-and-rate-expressions.md).
1. Per **Durata**, inserisci il numero di ore di esecuzione della finestra di manutenzione. Il valore specificato determina l'ora di fine specifica per la finestra di manutenzione in base all'ora di inizio. Nessuna attività della finestra di manutenzione può essere avviata dopo l'ora di fine risultante meno il numero di ore specificato per **Arresta l'inizializzazione di attività** nella fase successiva.
Ad esempio, se la finestra di manutenzione inizia alle 15:00, la durata è di tre ore e il valore **Arresta l'inizializzazione di attività** è un'ora, nessuna attività della finestra di manutenzione può iniziare dopo le 17:00.
1. In **Stop initiating tasks (Interrompi l'avvio delle attività)**, inserire il numero di ore prima del termine della finestra di manutenzione a partire dalle quali il sistema deve interrompere la pianificazione dell'esecuzione di nuove attività.
1. (Facoltativo) In **Data di inizio finestra**, specifica una data e un'ora nel formato ISO-8601 Extended che indichi il momento dell'attivazione della finestra di manutenzione. In questo modo è possibile ritardare l'attivazione della finestra di manutenzione fino alla data futura indicata.
1. (Facoltativo) In **Data di fine finestra**, specifica una data e un'ora nel formato ISO-8601 Extended che indichi il momento della disattivazione della finestra di manutenzione. In questo modo è possibile impostare una data e un'ora nel futuro in cui la finestra di manutenzione non sarà più in esecuzione.
1. (Facoltativo) In **Pianificazione fuso orario**, specifica il fuso orario su cui deve essere basata la pianificazione delle esecuzioni della finestra di manutenzione, nel formato IANA (Internet Assigned Numbers Authority). Ad esempio: "America/Los\$1Angeles", "etc/UTC", or "Asia/Seoul».
Per ulteriori informazioni sui formati validi, consulta il [Database dei fusi orari](https://www.iana.org/time-zones) sul sito web IANA.
1. (Facoltativo) Nell'area **Gestisci tag**, applica una o più name/value coppie di chiavi di tag alla finestra di manutenzione.
I tag sono metadati facoltativi assegnati a una risorsa. Consentono di categorizzare una risorsa in diversi modi, ad esempio in base allo scopo, al proprietario o all'ambiente. Ad esempio, è possibile applicare un tag a questa finestra di manutenzione per identificare il tipo di attività eseguito. In questo caso, puoi specificare la seguente name/value coppia di chiavi:
+ `Key=TaskType,Value=Patching`
1. Scegli **Crea finestra di manutenzione**.
1. Nell'elenco delle finestre di manutenzione, scegli la finestra di manutenzione appena creata, quindi scegli **Operazioni**, **Registra destinazioni**.
1. (Facoltativo) Nella sezione **Dettagli della finestra di manutenzione di destinazione**, specifica il nome, la descrizione e le informazioni sul proprietario (il proprio nome o alias) per la destinazione.
1. In **Selezione della destinazione**, scegli **Specifica tag delle istanze**.
1. In **Specifica tag delle istanze**, immetti una chiave e un valore di tag per identificare i nodi da registrare nella finestra di manutenzione, quindi scegli **Aggiungi**.
1. Scegli **Registra destinazione**. Il sistema crea una finestra di manutenzione di destinazione.
1. Nella pagina dei dettagli della finestra di manutenzione creata, scegli **Operazioni**, **Registra attività di esecuzione comandi**.
1. (Facoltativo) In **Dettagli attività finestra di manutenzione** fornisci il nome e la descrizione dell'attività.
1. Per **Documento comando**, scegli `AWS-RunPatchBaseline`.
1. Per **Priorità attività**, scegli una priorità. Zero (`0`) indica la priorità più elevata.
1. In **Destinazioni**, sotto **Destinazione di**, scegli la finestra di manutenzione di destinazione creata precedentemente in questa procedura.
1. In **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) Per il **Ruolo di servizio IAM**, scegli un ruolo affinché Systems Manager conceda le autorizzazioni durante l'esecuzione di attività della finestra di manutenzione.
Se non specifichi un ARN del ruolo di servizio, Systems Manager utilizza un ruolo collegato al servizio nell’account. Se nell'account non esiste un ruolo collegato al servizio appropriato per Systems Manager, questo viene creato quando l'attività viene registrata correttamente.
**Nota**
Per migliorare il livello di sicurezza, consigliamo vivamente di creare una policy personalizzata e un ruolo di servizio personalizzato per l'esecuzione delle attività della finestra di manutenzione. C'è la possibilità di creare la policy per fornire solo le autorizzazioni necessarie per le specifiche attività della finestra di manutenzione. Per ulteriori informazioni, consulta [Configurazione di Maintenance Windows](setting-up-maintenance-windows.md).
1. (Facoltativo) In **Opzioni di output**, per salvare l'output del comando in un file, seleziona la casella **Abilita scrittura in S3**. Digita i nomi del bucket e del prefisso (cartella) nelle caselle.
**Nota**
Le autorizzazioni S3 che consentono di scrivere dati in un bucket S3 sono quelle del profilo dell'istanza assegnate al nodo gestito e 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 in un Account AWS diverso, assicurarsi che il profilo dell'istanza o il ruolo di servizio IAM associato all'istanza disponga delle autorizzazioni necessarie per scrivere su quel bucket.
Per trasmettere l'output a un gruppo di log di Amazon CloudWatch Logs, seleziona la casella **CloudWatch di output**. Inserisci il nome del gruppo di log nella casella.
1. Nella sezione **SNS notifications (Notifiche SNS)**, se si desidera che vengano inviate notifiche sullo stato di esecuzione del comando, 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. In **Parametri**:
+ Nell'elenco **Operazione**, scegli **Scansiona** per cercare le patch mancanti oppure **Installa** per cercare e installare le patch mancanti.
+ Non è necessario specificare nulla nel campo **Snapshot Id (ID snapshot)**. Questo sistema genera e fornisce automaticamente questo parametro.
+ Non è necessario specificare nulla nel campo **Installa elenco sostituzioni**, a meno che non si desideri che Patch Manager utilizzi un set di patch diverso da quello specificato per la baseline delle patch. Per informazioni, consulta [Nome parametro: `InstallOverrideList`](patch-manager-aws-runpatchbaseline.md#patch-manager-aws-runpatchbaseline-parameters-installoverridelist).
+ Per **RebootOption**, specifica se desideri che i nodi si riavviino se le patch vengono installate durante l'`Install`operazione o se Patch Manager rileva altre patch installate dopo l'ultimo riavvio del nodo. Per informazioni, consulta [Nome parametro: `RebootOption`](patch-manager-aws-runpatchbaseline.md#patch-manager-aws-runpatchbaseline-parameters-norebootoption).
+ (Facoltativo) In **Comment (Commento)** immettere una nota di tracciamento o un promemoria su questo comando.
+ Nella casella **Timeout (seconds) (Timeout (secondi))** immettere il numero di secondi che devono trascorrere per il completamento dell'operazione prima che il sistema la consideri come non andata a buon fine.
1. Scegliere **Register Run command task (Registra attività di esecuzione comandi)**.
Al termine dell'attività della finestra di manutenzione, è possibile visualizzare i dettagli di conformità delle patch nella console di Systems Manager nello strumento [Fleet Manager](fleet-manager.md).
È inoltre possibile visualizzare le informazioni sulla conformità nello strumento [Patch Manager](patch-manager.md), nella scheda **Creazione di rapporti sulla conformità**.
È inoltre possibile utilizzare [DescribePatchGroupState](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DescribePatchGroupState.html)and [DescribeInstancePatchStatesForPatchGroup](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DescribeInstancePatchStatesForPatchGroup.html) APIs per visualizzare i dettagli sulla conformità. Per informazioni sui dati di conformità delle patch, consulta [Informazioni sulla conformità delle patch](compliance-about.md#compliance-monitor-patch).
# Piani di applicazione di patch con le finestre di manutenzione
Dopo avere configurato una baseline delle patch, ed facoltativamente un gruppo di patch, è possibile applicare le patch al nodo utilizzando una finestra di manutenzione. Una finestra di manutenzione può ridurre l'impatto sulla disponibilità del server consentendoti di specificare un'ora per l'applicazione di patch che non interrompa le operazioni aziendali. Una finestra di manutenzione funziona in questo modo:
1. Creare una finestra di manutenzione con una pianificazione per le operazioni di applicazione di patch.
1. Scegliere le destinazioni della finestra di manutenzione specificando il tag `Patch Group` o `PatchGroup` come nome del tag e qualsiasi valore definito per i tag Amazon Elastic Compute Cloud (Amazon EC2), ad esempio, "server web" o "US-EAST-PROD. 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), è necessario utilizzare `PatchGroup` (senza spazio).
1. Creare una nuova attività della finestra di manutenzione task e specificare il documento `AWS-RunPatchBaseline`.
Quando configuri l'attività, è possibile scegliere di effettuare la scansione del nodo o di effettuare la scansione e installare le patch nei nodi. Se scegli di effettuare la scansione dei nodi, Patch Manager, uno strumento di AWS Systems Manager, effettua la scansione di ciascun nodo e genera un elenco delle patch mancanti da verificare.
Se scegli di effettuare la scansione e installare le patch, Patch Manager effettua la scansione di ogni nodo e confronta l'elenco delle patch installate a fronte di quello delle patch approvate nella baseline. Patch Manager identifica le patch mancanti, quindi scarica e installa tutte le patch approvate e mancanti.
Per eseguire un'unica scansione o installazione per risolvere un problema, è possibile utilizzare Run Command per chiamare direttamente il documento `AWS-RunPatchBaseline`.
**Importante**
Dopo l'installazione delle patch, Systems Manager riavvia ciascuna nodo. Il riavvio è necessario per assicurare che le patch vengono installate correttamente e per garantire che il sistema non abbia lasciato il nodo in uno stato potenzialmente errato. (Eccezione: se il parametro `RebootOption` è impostato su `NoReboot` nel documento `AWS-RunPatchBaseline`, il nodo non viene riavviato dopo l'esecuzione di Patch Manager. Per ulteriori informazioni, consulta [Nome parametro: `RebootOption`](patch-manager-aws-runpatchbaseline.md#patch-manager-aws-runpatchbaseline-parameters-norebootoption).)