• 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à.
# Documenti di AWS Systems Manager
Un AWS Systems Manager documento (documento SSM) definisce le azioni che Systems Manager esegue sulle istanze gestite. Systems Manager include più di 100 documenti preconfigurati che è possibile utilizzare specificando i parametri nel runtime (tempo di esecuzione). I documenti preconfigurati si possono trovare nella console Documenti di Systems Manager scegliendo la scheda **Owned by Amazon** (Di proprietà di Amazon) o specificando Amazon per il filtro `Owner` quando si chiama l'operazione dell'API `ListDocuments`. I documenti utilizzano JavaScript Object Notation (JSON) o YAML e includono passaggi e parametri specificati dall'utente.
Per una maggiore sicurezza, a partire dal 14 luglio 2025, i documenti SSM supportano l'interpolazione delle variabili di ambiente durante l'elaborazione dei parametri. Questa funzionalità, disponibile nella versione 2.2 dello schema e nella versione 3.3.2746.0 SSM Agent o successiva, aiuta a prevenire gli attacchi di iniezione di comandi.
Per iniziare a utilizzare i documenti SSM, apri la [console di Systems Manager](https://console.aws.amazon.com/systems-manager/documents). Nel pannello di navigazione, scegli **Documenti**.
**Importante**
In Systems Manager, un documento SSM *di proprietà di Amazon* è un documento creato e gestito dallo stesso Amazon Web Services. I documenti *di proprietà di Amazon* includono un prefisso simile a `AWS-*` nel nome del documento. Il proprietario del documento è considerato Amazon, non un account utente specifico all'interno AWS. Questi documenti sono disponibili al pubblico e possono essere utilizzati da tutti.
## Come può lo strumento Documenti essere vantaggioso per la mia organizzazione?
Documents, uno strumento di cui AWS Systems Manager fa parte, offre i seguenti vantaggi:
+ **Categorie di documenti**
Per trovare i documenti di cui hai bisogno, scegli una categoria a seconda del tipo di documento che stai cercando. Per ampliare la ricerca, è possibile scegliere più categorie dello stesso tipo di documento. La scelta di categorie di diversi tipi di documento non è supportata. Le categorie sono supportate solo per i documenti di proprietà di Amazon.
+ **Versioni dei documenti**
È possibile creare e salvare diverse versioni dei documenti. È quindi possibile specificare una versione predefinita per ogni documento. La versione predefinita di un documento può essere aggiornata a una versione più recente o ripristinata a una versione precedente. Quando si modificano i contenuti di un documento, Systems Manager incrementa automaticamente la versione del documento. È possibile recuperare o utilizzare qualsiasi versione di un documento specificando la versione del documento nella console, i comandi AWS Command Line Interface (AWS CLI) o le chiamate API.
+ **Personalizzazione di documenti per le proprie esigenze**
Se desideri personalizzare le fasi e le operazioni in un documento, puoi creare un documento tuo. Il sistema memorizza il documento con l'utente Account AWS nel momento in Regione AWS cui lo si crea. Per ulteriori informazioni su come creare un documento SSM, consultare [Creazione del contenuto del documento SSM](documents-creating-content.md).
+ **Tagging di documenti**
È possibile applicare tag ai documenti per consentire ai clienti di individuarli rapidamente. Ad esempio, è possibile contrassegnare mediante tag documenti per ambienti, reparti, utenti, gruppi o periodi specifici. È inoltre possibile limitare l'accesso ai documenti creando una policy AWS Identity and Access Management (IAM) che specifichi i tag a cui un utente o un gruppo può accedere.
+ **Condivisione di documenti**
È possibile rendere i documenti pubblici o condividerli con Account AWS specifici nella stessa Regione AWS. La condivisione di documenti tra gli account può essere utile, ad esempio, se si desidera che tutte le istanze di Amazon Elastic Compute Cloud (Amazon EC2) fornite ai clienti e ai dipendenti abbiano la stessa configurazione. Oltre a mantenere aggiornate le applicazioni o le patch sulle istanze, è possibile limitare l'accesso a determinate attività da parte delle istanze dei clienti. In alternativa, è possibile assicurare che alle istanze utilizzate dagli account dei dipendenti nell'organizzazione venga concesso l'accesso a specifiche risorse interne. Per ulteriori informazioni, consulta [Condivisione di documenti SSM](documents-ssm-sharing.md).
## Chi deve utilizzare i documenti?
+ Qualsiasi AWS cliente che desideri utilizzare gli strumenti di Systems Manager per migliorare la propria efficienza operativa su larga scala, ridurre gli errori associati all'intervento manuale e ridurre i tempi di risoluzione dei problemi comuni.
+ Esperti di infrastruttura che desiderano automatizzare le attività di implementazione e configurazione.
+ Amministratori che desiderano risolvere in modo affidabile i problemi comuni, migliorare l'efficienza della risoluzione dei problemi e ridurre le operazioni ripetitive.
+ Utenti che desiderano automatizzare un'attività che in genere eseguono manualmente.
## Quali sono i tipi di documenti SSM?
La tabella seguente illustra i diversi tipi di documenti SSM e il loro utilizzo.
****
| Tipo | Utilizzo con | Informazioni |
| --- | --- | --- |
| ApplicationConfiguration ApplicationConfigurationSchema | [AWS AppConfig](https://docs.aws.amazon.com/appconfig/latest/userguide/what-is-appconfig.html) | AWS AppConfig, uno strumento che consente di creare, gestire e distribuire rapidamente configurazioni di applicazioni. AWS Systems ManagerÈ possibile archiviare i dati di configurazione in un documento SSM creando un documento che utilizza il tipo di documento `ApplicationConfiguration`. Per ulteriori informazioni, consulta [Configurazioni in forma libera](https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-creating-configuration-and-profile.html#free-form-configurations) nella *Guida per l'utente di AWS AppConfig *. Se crei una configurazione in un documento SSM, devi specificare o creare uno schema JSON corrispondente. Lo schema utilizza il tipo di documento `ApplicationConfigurationSchema` e, come un insieme di regole, definisce le proprietà consentite per ogni impostazione di configurazione dell'applicazione. Per ulteriori informazioni, consulta [Informazioni sui validatori](https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-creating-configuration-and-profile-validators.html) nella *Guida per l'utente di AWS AppConfig *. |
| runbook Automation | [Automazione](systems-manager-automation.md) [State Manager](systems-manager-state.md) [Maintenance Windows](maintenance-windows.md) | Utilizza i runbook di Automazione durante l'esecuzione di attività comuni di manutenzione e implementazione, ad esempio la creazione o l'aggiornamento di una Amazon Machine Image (AMI). State Manager utilizza i runbook di Automazione per applicare una configurazione. Queste operazioni possono essere eseguite su una o più destinazioni in qualsiasi momento durante il ciclo di vita di un'istanza. Maintenance Windows utilizza i runbook di Automazione per eseguire attività comuni di manutenzione e implementazione in base alla pianificazione specificata. Tutti i runbook Automation supportati per i sistemi operativi basati su Linux sono supportati anche sulle istanze EC2 per macOS. |
| Documento Modifica calendario | [Change Calendar](systems-manager-change-calendar.md) | Change Calendar, uno strumento in AWS Systems Manager, utilizza il tipo di `ChangeCalendar` documento. Un documento Change Calendar memorizza una voce del calendario e gli eventi associati che possono consentire o impedire alle operazioni di automazione di modificare l'ambiente. In Change Calendar, un documento memorizza i dati [iCalendar 2.0](https://icalendar.org/) in formato testo normale. Change Calendar non è supportato nelle istanze EC2 per macOS. |
| AWS CloudFormation modello | [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) | AWS CloudFormation i modelli descrivono le risorse che desideri inserire negli CloudFormation stack. Archiviando CloudFormation i modelli come documenti di Systems Manager, è possibile trarre vantaggio dalle funzionalità documentali di Systems Manager. Questi includono la creazione e il confronto di più versioni del modello e la condivisione del modello con altri account nella stessa Regione AWS. È possibile creare e modificare CloudFormation modelli e pile utilizzando Application Manager uno strumento in Systems Manager. Per ulteriori informazioni, consulta [Utilizzo di CloudFormation modelli e pile in Application Manager](application-manager-working-stacks.md). |
| Documento di comando | [Run Command](run-command.md) [State Manager](systems-manager-state.md) [Maintenance Windows](maintenance-windows.md) | Run Command, uno strumento in AWS Systems Manager, utilizza i documenti di comando per eseguire comandi. State Manager, uno strumento in AWS Systems Manager, utilizza i documenti di comando per applicare una configurazione. Queste azioni possono essere eseguite su una o più destinazioni in qualsiasi momento durante il ciclo di vita di un'istanza. Maintenance Windows, uno strumento in AWS Systems Manager, utilizza i documenti di comando per applicare una configurazione basata sulla pianificazione specificata. La maggior parte dei documenti Command è supportata su tutti i sistemi operativi Linux e Windows Server compatibile con Systems Manager. I seguenti documenti Command sono supportati nelle istanze EC2 per macOS: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/documents.html) |
| AWS Config modello di pacchetto di conformità | [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/WhatIsConfig.html) | AWS Config i modelli di conformance pack sono documenti in formato YAML utilizzati per creare pacchetti di conformità che contengono l'elenco di regole gestite o personalizzate e azioni correttive. AWS Config Per ulteriori informazioni, consulta la pagina [Pacchetti di conformità](https://docs.aws.amazon.com/config/latest/developerguide/conformance-packs.html). |
| Documento del pacchetto | [Distributor](distributor.md) | In Distributor, uno strumento di AWS Systems Manager, un pacchetto è rappresentato da un documento SSM. Un documento di un pacchetto include file di archivio ZIP allegati che contengono software o asset da installare su istanze gestite. La creazione di un pacchetto in Distributor genera il documento del pacchetto. Distributor non è supportata da Oracle Linux e dalle Istanze gestite macOS. |
| Documento di policy | [State Manager](systems-manager-state.md) | Inventory, uno strumento di AWS Systems Manager, utilizza il documento `AWS-GatherSoftwareInventory` Policy con un'State Managerassociazione per raccogliere dati di inventario dalle istanze gestite. Durante la creazione dei documenti SSM, i runbook Automation e i documenti Command sono il metodo preferito per applicare una policy su un'istanza gestita. L'inventario di Systems Manager e il documento di policy `AWS-GatherSoftwareInventory` sono supportati su tutti i sistemi operativi compatibili con Systems Manager. |
| Modello di analisi post-imprevisto | [Analisi post-imprevisto dello Strumento·di·gestione·degli·incidenti](https://docs.aws.amazon.com/incident-manager/latest/userguide/analysis.html) | Incident Manager utilizza il modello di analisi post-incidente per creare un'analisi basata sulle migliori pratiche di gestione AWS delle operazioni. Usare il modello per creare un'analisi che il team può utilizzare per individuare i miglioramenti apportati alla risposta agli imprevisti. |
| Documento di sessione | [Session Manager](session-manager.md) | Session Manager, uno strumento in AWS Systems Manager, utilizza i documenti di sessione per determinare il tipo di sessione da avviare, ad esempio una sessione di port forwarding, una sessione per eseguire un comando interattivo o una sessione per creare un tunnel SSH. I documenti di sessione sono supportati su tutti i sistemi operativi Linux e Windows Server compatibili con Systems Manager. I seguenti documenti Command sono supportati nelle istanze EC2 per macOS: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/documents.html) |
**Quote del documento SSM**
Per informazioni sulle quote del documento SSM, consulta [Service quotas di Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) nella *Riferimenti generali di Amazon Web Services*.
**Topics**
+ [
## Come può lo strumento Documenti essere vantaggioso per la mia organizzazione?
](#ssm-docs-benefits)
+ [
## Chi deve utilizzare i documenti?
](#documents-who)
+ [
## Quali sono i tipi di documenti SSM?
](#what-are-document-types)
+ [
# Componenti del documento
](documents-components.md)
+ [
# Creazione del contenuto del documento SSM
](documents-creating-content.md)
+ [
# Utilizzo dei documenti
](documents-using.md)
+ [
# Risoluzione dei problemi di gestione dei parametri
](parameter-troubleshooting.md)
# Componenti del documento
In questa sezione sono incluse informazioni sui componenti che compongono i documenti SSM.
**Topics**
+ [
# Schemi, funzionalità ed esempi
](documents-schemas-features.md)
+ [
# Elementi di dati e parametri
](documents-syntax-data-elements-parameters.md)
+ [
# Documentazione di riferimento del plugin per i documenti di comando
](documents-command-ssm-plugin-reference.md)
# Schemi, funzionalità ed esempi
AWS Systems Manager I documenti (SSM) utilizzano le seguenti versioni dello schema.
+ I documenti di tipo `Command` possono utilizzare le versione dello schema 1.2, 2.0 e 2.2. Se si utilizzano documenti con lo schema 1.2, consigliamo di creare documenti con la versione 2.2 dello schema.
+ I documenti di tipo `Policy` devono utilizzare la versione dello schema 2.0 o una versione successiva.
+ I documenti di tipo `Automation` devono utilizzare la versione dello schema 0.3.
+ I documenti di tipo `Session` devono utilizzare la versione dello schema 1.0.
+ Puoi creare documenti in formato JSON o YAML.
Per ulteriori informazioni sull'utilizzo del documento schema `Session`, consulta [Schema documento di sessione](session-manager-schema.md).
Utilizzando la versione più recente dello schema per documenti `Command` e `Policy`, puoi sfruttare le seguenti funzionalità.
**Funzionalità dei documenti con versione dello schema 2.2**
| Funzionalità | Informazioni |
| --- | --- |
| Modifica dei documenti | Ora i documenti possono essere aggiornati. Con la versione 1.2, qualsiasi aggiornamento a un documento doveva essere salvato con un nome diverso. |
| Controllo delle versioni automatico | Qualsiasi aggiornamento a un documento crea una nuova versione. Non si tratta di una versione dello schema, ma di una versione del documento. |
| Versione predefinita | Se disponi di più versioni di un documento, puoi specificare quale versione è il documento predefinito. |
| Sequenziamento | I plugin o le *fasi* in un documento vengono eseguiti nell'ordine specificato. |
| Supporto multipiattaforma | Il supporto multipiattaforma consente di specificare sistemi operativi differenti per plugin differenti all'interno dello stesso documento SSM. Il supporto multipiattaforma utilizza il parametro `precondition` all'interno di una fase. |
| Interpolazione dei parametri | Interpolazione significa inserire o sostituire un valore variabile in una stringa. Immagina che sia come riempire uno spazio vuoto con valori effettivi, prima che la stringa venga utilizzata. Nel contesto dei documenti SSM, l'interpolazione dei parametri consente di interpolare i parametri delle stringhe in variabili di ambiente prima dell'esecuzione del comando, offrendo una maggiore sicurezza contro le iniezioni di comandi. Se impostato su `ENV_VAR`, l'agente crea una variabile di ambiente denominata `SSM_parameter-name`, che contiene il valore del parametro. |
**Nota**
È necessario mantenere AWS Systems Manager SSM Agent le istanze aggiornate alla versione più recente per utilizzare le nuove funzionalità di Systems Manager e le funzionalità dei documenti SSM. Per ulteriori informazioni, consulta [Aggiornamento di SSM Agent utilizzando Run Command](run-command-tutorial-update-software.md#rc-console-agentexample).
Nella tabella seguente vengono elencate le differenze tra le versioni principali dello schema.
****
| Versione 1.2 | Versione 2.2 (versione più recente) | Informazioni |
| --- | --- | --- |
| runtimeConfig | mainSteps | Nella versione 2.2, la sezione `mainSteps` sostituisce `runtimeConfig`. La sezione `mainSteps` consente a Systems Manager di eseguire le fasi in sequenza. |
| properties | inputs | Nella versione 2.2, la sezione `inputs` sostituisce la sezione `properties`. La sezione `inputs` accetta parametri per le fasi. |
| commands | runCommand | Nella versione 2.2, la sezione `inputs` richiede il parametro `runCommand` anziché il parametro `commands`. |
| id | operazione | Nella versione 2.2, `Action` sostituisce `ID`. Si tratta di una semplice modifica di nome. |
| non applicabile | nome | Nella versione 2.2, `name` è un qualsiasi nome definito dall'utente per una fase. |
**Utilizzo del parametro Precondition**
Con la versione dello schema 2.2 o successiva, è possibile utilizzare il parametro `precondition` per specificare il sistema operativo di destinazione per ciascun plugin o convalidare i parametri di input definiti nel documento SSM. Il parametro `precondition` supporta il riferimento ai parametri di input del documento SSM e `platformType` utilizzando i valori di `Linux`, `MacOS`, e `Windows`. Soltanto l'operatore `StringEquals` è supportato.
Per i documenti che utilizzano la versione dello schema 2.2 o successiva, se `precondition` non è specificato, ogni plugin viene eseguito o ignorato in base alla relativa compatibilità con il sistema operativo. La compatibilità dei plugin con il sistema operativo viene valutata prima di `precondition`. Per i documenti che utilizzano la versione dello schema 2.0 o precedente, i plugin non compatibili generano un errore.
Ad esempio, in un documento che utilizza la versione dello schema 2.2, se `precondition` non è specificato e il plugin `aws:runShellScript` è presente, la fase viene eseguita sulle istanze Linux, ma il sistema la ignora sulle istanze Windows Server, poiché `aws:runShellScript` non è compatibile con le istanze Windows Server. Tuttavia, per un documento che utilizza la versione dello schema 2.0, se specifichi il plugin `aws:runShellScript` ed esegui il documento su istanze Windows Server, l'esecuzione non va a buon fine. Un esempio del parametro Precondition in un documento SSM è disponibile più avanti in questa sezione.
## Versione dello schema 2.2
**Elementi di primo livello**
L'esempio seguente mostra gli elementi di primo livello di un documento SSM che utilizza la versione dello schema 2.2.
------
#### [ YAML ]
```
---
schemaVersion: "2.2"
description: A description of the document.
parameters:
parameter 1:
property 1: "value"
property 2: "value"
parameter 2:
property 1: "value"
property 2: "value"
mainSteps:
- action: Plugin name
name: A name for the step.
inputs:
input 1: "value"
input 2: "value"
input 3: "{{ parameter 1 }}"
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "A description of the document.",
"parameters": {
"parameter 1": {
"property 1": "value",
"property 2": "value"
},
"parameter 2":{
"property 1": "value",
"property 2": "value"
}
},
"mainSteps": [
{
"action": "Plugin name",
"name": "A name for the step.",
"inputs": {
"input 1": "value",
"input 2": "value",
"input 3": "{{ parameter 1 }}"
}
}
]
}
```
------
**Esempio con per la versione dello schema 2.2**
L'esempio seguente utilizza il `aws:runPowerShellScript` plug-in per eseguire un PowerShell comando sulle istanze di destinazione.
------
#### [ YAML ]
```
---
schemaVersion: "2.2"
description: "Example document"
parameters:
Message:
type: "String"
description: "Example parameter"
default: "Hello World"
allowedValues:
- "Hello World"
mainSteps:
- action: "aws:runPowerShellScript"
name: "example"
inputs:
timeoutSeconds: '60'
runCommand:
- "Write-Output {{Message}}"
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "Example document",
"parameters": {
"Message": {
"type": "String",
"description": "Example parameter",
"default": "Hello World",
"allowedValues": ["Hello World"]
}
},
"mainSteps": [
{
"action": "aws:runPowerShellScript",
"name": "example",
"inputs": {
"timeoutSeconds": "60",
"runCommand": [
"Write-Output {{Message}}"
]
}
}
]
}
```
------
**Esempi del parametro Precondition per la versione dello schema 2.2**
La versione dello schema 2.2 offre il supporto multipiattaforma. Ciò significa che all'interno di un singolo documento SSM è possibile specificare sistemi operativi differenti per plugin differenti. Il supporto multipiattaforma utilizza il parametro `precondition` all'interno di una fase, come mostrato nel seguente esempio. È possibile utilizzare il parametro `precondition` anche per convalidare i parametri di input definiti nel documento SSM. Ne è la riprova il secondo dei seguenti esempi.
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: cross-platform sample
mainSteps:
- action: aws:runPowerShellScript
name: PatchWindows
precondition:
StringEquals:
- platformType
- Windows
inputs:
runCommand:
- cmds
- action: aws:runShellScript
name: PatchLinux
precondition:
StringEquals:
- platformType
- Linux
inputs:
runCommand:
- cmds
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "cross-platform sample",
"mainSteps": [
{
"action": "aws:runPowerShellScript",
"name": "PatchWindows",
"precondition": {
"StringEquals": [
"platformType",
"Windows"
]
},
"inputs": {
"runCommand": [
"cmds"
]
}
},
{
"action": "aws:runShellScript",
"name": "PatchLinux",
"precondition": {
"StringEquals": [
"platformType",
"Linux"
]
},
"inputs": {
"runCommand": [
"cmds"
]
}
}
]
}
```
------
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
parameters:
action:
type: String
allowedValues:
- Install
- Uninstall
confirmed:
type: String
allowedValues:
- True
- False
mainSteps:
- action: aws:runShellScript
name: InstallAwsCLI
precondition:
StringEquals:
- "{{ action }}"
- "Install"
inputs:
runCommand:
- sudo apt install aws-cli
- action: aws:runShellScript
name: UninstallAwsCLI
precondition:
StringEquals:
- "{{ action }} {{ confirmed }}"
- "Uninstall True"
inputs:
runCommand:
- sudo apt remove aws-cli
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"parameters": {
"action": {
"type": "String",
"allowedValues": [
"Install",
"Uninstall"
]
},
"confirmed": {
"type": "String",
"allowedValues": [
true,
false
]
}
},
"mainSteps": [
{
"action": "aws:runShellScript",
"name": "InstallAwsCLI",
"precondition": {
"StringEquals": [
"{{ action }}",
"Install"
]
},
"inputs": {
"runCommand": [
"sudo apt install aws-cli"
]
}
},
{
"action": "aws:runShellScript",
"name": "UninstallAwsCLI",
"precondition": {
"StringEquals": [
"{{ action }} {{ confirmed }}",
"Uninstall True"
]
},
"inputs": {
"runCommand": [
"sudo apt remove aws-cli"
]
}
}
]
}
```
------
**Esempio di interpolazione dello schema della versione 2.2 con versioni SSM Agent precedenti alla 3.3.2746.0**
Nelle versioni SSM Agent precedenti alla 3.3.2746.0, l'agente ignora il parametro `interpolationType` ed esegue invece una sostituzione di stringhe non elaborate. Se si fa riferimento in modo esplicito a `SSM_parameter-name`, è necessario impostarlo in modo esplicito. Nell'esempio seguente per Linux, la variabile di ambiente `SSM_Message` viene referenziata in modo esplicito.
```
{
"schemaVersion": "2.2",
"description": "An example document",
"parameters": {
"Message": {
"type": "String",
"description": "Message to be printed",
"default": "Hello",
"interpolationType" : "ENV_VAR",
"allowedPattern: "^[^"]*$"
}
},
"mainSteps": [{
"action": "aws:runShellScript",
"name": "printMessage",
"inputs": {
"runCommand": [
"if [ -z "${SSM_Message+x}" ]; then",
" export SSM_Message=\"{{Message}}\"",
"fi",
"",
"echo $SSM_Message"
]
}
}
}
```
**Nota**
`allowedPattern` non è tecnicamente necessario, se un documento SSM non utilizza le parentesi graffe: `{{ }}`
**Esempio con State Manager per la versione dello schema 2.2**
È possibile utilizzare il seguente documento SSM con State Manager, uno strumento di Systems Manager, per scaricare e installare il software antivirus ClamAV. State Manager applica una configurazione specifica, per cui ogni volta che viene eseguita l'associazione a State Manager, il sistema verifica, se il software ClamAV è installato. Se così non fosse, State Manager esegue nuovamente questo documento.
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: State Manager Bootstrap Example
parameters: {}
mainSteps:
- action: aws:runShellScript
name: configureServer
inputs:
runCommand:
- sudo yum install -y httpd24
- sudo yum --enablerepo=epel install -y clamav
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "State Manager Bootstrap Example",
"parameters": {},
"mainSteps": [
{
"action": "aws:runShellScript",
"name": "configureServer",
"inputs": {
"runCommand": [
"sudo yum install -y httpd24",
"sudo yum --enablerepo=epel install -y clamav"
]
}
}
]
}
```
------
**Esempio di versione dello schema 2.2 per un inventario**
È possibile utilizzare il seguente documento SSM con State Manager per raccogliere i metadati di inventario sulle istanze.
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: Software Inventory Policy Document.
parameters:
applications:
type: String
default: Enabled
description: "(Optional) Collect data for installed applications."
allowedValues:
- Enabled
- Disabled
awsComponents:
type: String
default: Enabled
description: "(Optional) Collect data for AWS Components like amazon-ssm-agent."
allowedValues:
- Enabled
- Disabled
networkConfig:
type: String
default: Enabled
description: "(Optional) Collect data for Network configurations."
allowedValues:
- Enabled
- Disabled
windowsUpdates:
type: String
default: Enabled
description: "(Optional) Collect data for all Windows Updates."
allowedValues:
- Enabled
- Disabled
instanceDetailedInformation:
type: String
default: Enabled
description: "(Optional) Collect additional information about the instance, including
the CPU model, speed, and the number of cores, to name a few."
allowedValues:
- Enabled
- Disabled
customInventory:
type: String
default: Enabled
description: "(Optional) Collect data for custom inventory."
allowedValues:
- Enabled
- Disabled
mainSteps:
- action: aws:softwareInventory
name: collectSoftwareInventoryItems
inputs:
applications: "{{ applications }}"
awsComponents: "{{ awsComponents }}"
networkConfig: "{{ networkConfig }}"
windowsUpdates: "{{ windowsUpdates }}"
instanceDetailedInformation: "{{ instanceDetailedInformation }}"
customInventory: "{{ customInventory }}"
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "Software Inventory Policy Document.",
"parameters": {
"applications": {
"type": "String",
"default": "Enabled",
"description": "(Optional) Collect data for installed applications.",
"allowedValues": [
"Enabled",
"Disabled"
]
},
"awsComponents": {
"type": "String",
"default": "Enabled",
"description": "(Optional) Collect data for AWS Components like amazon-ssm-agent.",
"allowedValues": [
"Enabled",
"Disabled"
]
},
"networkConfig": {
"type": "String",
"default": "Enabled",
"description": "(Optional) Collect data for Network configurations.",
"allowedValues": [
"Enabled",
"Disabled"
]
},
"windowsUpdates": {
"type": "String",
"default": "Enabled",
"description": "(Optional) Collect data for all Windows Updates.",
"allowedValues": [
"Enabled",
"Disabled"
]
},
"instanceDetailedInformation": {
"type": "String",
"default": "Enabled",
"description": "(Optional) Collect additional information about the instance, including\nthe CPU model, speed, and the number of cores, to name a few.",
"allowedValues": [
"Enabled",
"Disabled"
]
},
"customInventory": {
"type": "String",
"default": "Enabled",
"description": "(Optional) Collect data for custom inventory.",
"allowedValues": [
"Enabled",
"Disabled"
]
}
},
"mainSteps": [
{
"action": "aws:softwareInventory",
"name": "collectSoftwareInventoryItems",
"inputs": {
"applications": "{{ applications }}",
"awsComponents": "{{ awsComponents }}",
"networkConfig": "{{ networkConfig }}",
"windowsUpdates": "{{ windowsUpdates }}",
"instanceDetailedInformation": "{{ instanceDetailedInformation }}",
"customInventory": "{{ customInventory }}"
}
}
]
}
```
------
**Esempio con `AWS-ConfigureAWSPackage` per la versione dello schema 2.2**
L'esempio seguente mostra il documento `AWS-ConfigureAWSPackage`. La sezione `mainSteps` include il plugin `aws:configurePackage` nella fase `action`.
**Nota**
Sui sistemi operativi Linux sono supportati solo i pacchetti `AmazonCloudWatchAgent` e `AWSSupport-EC2Rescue`.
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: 'Install or uninstall the latest version or specified version of an AWS
package. Available packages include the following: AWSPVDriver, AwsEnaNetworkDriver,
AwsVssComponents, and AmazonCloudWatchAgent, and AWSSupport-EC2Rescue.'
parameters:
action:
description: "(Required) Specify whether or not to install or uninstall the package."
type: String
allowedValues:
- Install
- Uninstall
name:
description: "(Required) The package to install/uninstall."
type: String
allowedPattern: "^arn:[a-z0-9][-.a-z0-9]{0,62}:[a-z0-9][-.a-z0-9]{0,62}:([a-z0-9][-.a-z0-9]{0,62})?:([a-z0-9][-.a-z0-9]{0,62})?:package\\/[a-zA-Z][a-zA-Z0-9\\-_]{0,39}$|^[a-zA-Z][a-zA-Z0-9\\-_]{0,39}$"
version:
type: String
description: "(Optional) A specific version of the package to install or uninstall."
mainSteps:
- action: aws:configurePackage
name: configurePackage
inputs:
name: "{{ name }}"
action: "{{ action }}"
version: "{{ version }}"
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "Install or uninstall the latest version or specified version of an AWS package. Available packages include the following: AWSPVDriver, AwsEnaNetworkDriver, AwsVssComponents, and AmazonCloudWatchAgent, and AWSSupport-EC2Rescue.",
"parameters": {
"action": {
"description":"(Required) Specify whether or not to install or uninstall the package.",
"type":"String",
"allowedValues":[
"Install",
"Uninstall"
]
},
"name": {
"description": "(Required) The package to install/uninstall.",
"type": "String",
"allowedPattern": "^arn:[a-z0-9][-.a-z0-9]{0,62}:[a-z0-9][-.a-z0-9]{0,62}:([a-z0-9][-.a-z0-9]{0,62})?:([a-z0-9][-.a-z0-9]{0,62})?:package\\/[a-zA-Z][a-zA-Z0-9\\-_]{0,39}$|^[a-zA-Z][a-zA-Z0-9\\-_]{0,39}$"
},
"version": {
"type": "String",
"description": "(Optional) A specific version of the package to install or uninstall."
}
},
"mainSteps":[
{
"action": "aws:configurePackage",
"name": "configurePackage",
"inputs": {
"name": "{{ name }}",
"action": "{{ action }}",
"version": "{{ version }}"
}
}
]
}
```
------
## Versione dello schema 1.2
L'esempio seguente mostra gli elementi di primo livello di un documento che utilizza la versione dello schema 1.2.
```
{
"schemaVersion":"1.2",
"description":"A description of the SSM document.",
"parameters":{
"parameter 1":{
"one or more parameter properties"
},
"parameter 2":{
"one or more parameter properties"
},
"parameter 3":{
"one or more parameter properties"
}
},
"runtimeConfig":{
"plugin 1":{
"properties":[
{
"one or more plugin properties"
}
]
}
}
}
```
**Esempio con `aws:runShellScript` per la versione dello schema 1.2**
L'esempio seguente mostra il documento SSM `AWS-RunShellScript`. La sezione **runtimeConfig** include il plugin `aws:runShellScript`.
```
{
"schemaVersion":"1.2",
"description":"Run a shell script or specify the commands to run.",
"parameters":{
"commands":{
"type":"StringList",
"description":"(Required) Specify a shell script or a command to run.",
"minItems":1,
"displayType":"textarea"
},
"workingDirectory":{
"type":"String",
"default":"",
"description":"(Optional) The path to the working directory on your instance.",
"maxChars":4096
},
"executionTimeout":{
"type":"String",
"default":"3600",
"description":"(Optional) The time in seconds for a command to complete before it is considered to have failed. Default is 3600 (1 hour). Maximum is 172800 (48 hours).",
"allowedPattern":"([1-9][0-9]{0,3})|(1[0-9]{1,4})|(2[0-7][0-9]{1,3})|(28[0-7][0-9]{1,2})|(28800)"
}
},
"runtimeConfig":{
"aws:runShellScript":{
"properties":[
{
"id":"0.aws:runShellScript",
"runCommand":"{{ commands }}",
"workingDirectory":"{{ workingDirectory }}",
"timeoutSeconds":"{{ executionTimeout }}"
}
]
}
}
}
```
## Versione dello schema 0.3
**Elementi di primo livello**
L'esempio seguente mostra gli elementi di primo livello di un runbook Automation che utilizza la versione dello schema 0.3 in formato JSON.
```
{
"description": "document-description",
"schemaVersion": "0.3",
"assumeRole": "{{assumeRole}}",
"parameters": {
"parameter1": {
"type": "String",
"description": "parameter-1-description",
"default": ""
},
"parameter2": {
"type": "String",
"description": "parameter-2-description",
"default": ""
}
},
"variables": {
"variable1": {
"type": "StringMap",
"description": "variable-1-description",
"default": {}
},
"variable2": {
"type": "String",
"description": "variable-2-description",
"default": "default-value"
}
},
"mainSteps": [
{
"name": "myStepName",
"action": "action-name",
"maxAttempts": 1,
"inputs": {
"Handler": "python-only-handler-name",
"Runtime": "runtime-name",
"Attachment": "script-or-zip-name"
},
"outputs": {
"Name": "output-name",
"Selector": "selector.value",
"Type": "data-type"
}
}
],
"files": {
"script-or-zip-name": {
"checksums": {
"sha256": "checksum"
},
"size": 1234
}
}
}
```
**Esempio di runbook Automation YAML**
L'esempio seguente mostra il contenuto di un runbook Automation, in formato YAML. Questo esempio d'uso della versione 0.3 dello schema del documento dimostra anche l'utilizzo di Markdown per formattare le descrizioni dei documenti.
```
description: >-
##Title: LaunchInstanceAndCheckState
-----
**Purpose**: This Automation runbook first launches an EC2 instance
using the AMI ID provided in the parameter ```imageId```. The second step of
this document continuously checks the instance status check value for the
launched instance until the status ```ok``` is returned.
##Parameters:
-----
Name | Type | Description | Default Value
------------- | ------------- | ------------- | -------------
assumeRole | String | (Optional) The ARN of the role that allows Automation to
perform the actions on your behalf. | -
imageId | String | (Optional) The AMI ID to use for launching the instance.
The default value uses the latest Amazon Linux AMI ID available. | {{
ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64 }}
schemaVersion: '0.3'
assumeRole: 'arn:aws:iam::111122223333::role/AutomationServiceRole'
parameters:
imageId:
type: String
default: '{{ ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64 }}'
description: >-
(Optional) The AMI ID to use for launching the instance. The default value
uses the latest released Amazon Linux AMI ID.
tagValue:
type: String
default: ' LaunchedBySsmAutomation'
description: >-
(Optional) The tag value to add to the instance. The default value is
LaunchedBySsmAutomation.
instanceType:
type: String
default: t2.micro
description: >-
(Optional) The instance type to use for the instance. The default value is
t2.micro.
mainSteps:
- name: LaunchEc2Instance
action: 'aws:executeScript'
outputs:
- Name: payload
Selector: $.Payload
Type: StringMap
inputs:
Runtime: python3.11
Handler: launch_instance
Script: ''
InputPayload:
image_id: '{{ imageId }}'
tag_value: '{{ tagValue }}'
instance_type: '{{ instanceType }}'
Attachment: launch.py
description: >-
**About This Step**
This step first launches an EC2 instance using the ```aws:executeScript```
action and the provided python script.
- name: WaitForInstanceStatusOk
action: 'aws:executeScript'
inputs:
Runtime: python3.11
Handler: poll_instance
Script: |-
def poll_instance(events, context):
import boto3
import time
ec2 = boto3.client('ec2')
instance_id = events['InstanceId']
print('[INFO] Waiting for instance status check to report ok', instance_id)
instance_status = "null"
while True:
res = ec2.describe_instance_status(InstanceIds=[instance_id])
if len(res['InstanceStatuses']) == 0:
print("Instance status information is not available yet")
time.sleep(5)
continue
instance_status = res['InstanceStatuses'][0]['InstanceStatus']['Status']
print('[INFO] Polling to get status of the instance', instance_status)
if instance_status == 'ok':
break
time.sleep(10)
return {'Status': instance_status, 'InstanceId': instance_id}
InputPayload: '{{ LaunchEc2Instance.payload }}'
description: >-
**About This Step**
The python script continuously polls the instance status check value for
the instance launched in Step 1 until the ```ok``` status is returned.
files:
launch.py:
checksums:
sha256: 18871b1311b295c43d0f...[truncated]...772da97b67e99d84d342ef4aEXAMPLE
```
## Esempi di gestione sicura dei parametri
Gli esempi seguenti illustrano la gestione sicura dei parametri mediante variabili `interpolationType` di ambiente.
### Esecuzione sicura dei comandi di base
Questo esempio mostra come gestire in modo sicuro un parametro di comando:
**Nota**
`allowedPattern` non è tecnicamente necessario, se un documento SSM non utilizza le doppie parentesi graffe: `{{ }}`
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: An example document.
parameters:
Message:
type: String
description: "Message to be printed"
default: Hello
interpolationType: ENV_VAR
allowedPattern: "^[^"]*$"
mainSteps:
- action: aws:runShellScript
name: printMessage
precondition:
StringEquals:
- platformType
- Linux
inputs:
runCommand:
- echo {{Message}}
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "An example document.",
"parameters": {
"Message": {
"type": "String",
"description": "Message to be printed",
"default": "Hello",
"interpolationType": "ENV_VAR",
"allowedPattern": "^[^"]*$"
}
},
"mainSteps": [{
"action": "aws:runShellScript",
"name": "printMessage",
"precondition": {
"StringEquals": ["platformType", "Linux"]
},
"inputs": {
"runCommand": [
"echo {{Message}}"
]
}
}]
}
```
------
### Utilizzo dei parametri nei linguaggi interpretati
Questo esempio dimostra la gestione sicura dei parametri in Python:
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: 'Secure Python script execution'
parameters:
inputData:
type: String
description: 'Input data for processing'
interpolationType: 'ENV_VAR'
mainSteps:
- action: aws:runPowerShellScript
name: runPython
inputs:
runCommand:
- |
python3 -c '
import os
import json
# Safely access parameter through environment variable
input_data = os.environ.get("SSM_inputData", "")
# Process the data
try:
processed_data = json.loads(input_data)
print(f"Successfully processed: {processed_data}")
except json.JSONDecodeError:
print("Invalid JSON input")
'
```
------
### Esempio di compatibilità retroattiva
Questo esempio mostra come gestire i parametri in modo sicuro mantenendo la compatibilità retroattiva:
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: 'Backwards compatible secure parameter handling'
parameters:
userInput:
type: String
description: 'User input to process'
interpolationType: 'ENV_VAR'
allowedPattern: '^[^"]*$'
mainSteps:
- action: aws:runShellScript
name: processInput
inputs:
runCommand:
- |
# Handle both modern and legacy agent versions
if [ -z "${SSM_userInput+x}" ]; then
# Legacy agent - fall back to direct parameter reference
export SSM_userInput="{{userInput}}"
fi
# Process the input securely
echo "Processing input: $SSM_userInput"
```
------
**Nota**
`allowedPattern` non è tecnicamente necessario, se un documento SSM non utilizza le doppie parentesi graffe: `{{ }}`
## Best practice sulla sicurezza dei parametri
È necessario seguire queste best practice, quando si gestiscono i parametri nei documenti SSM:
+ **Utilizzo dell'interpolazione delle variabili di ambiente**: usare sempre `interpolationType: "ENV_VAR"` per i parametri di stringa che verranno utilizzati nelle esecuzioni dei comandi.
+ **Implementazione della convalida dell'input**: usare `allowedPattern` per limitare i valori dei parametri a modelli sicuri.
+ **Gestione dei sistemi legacy**: includere la logica di fallback per le versioni SSM Agent precedenti, che non supportano l'interpolazione delle variabili di ambiente.
+ **Evitare i caratteri speciali**: quando si utilizzano i valori dei parametri nei comandi, evitare adeguatamente i caratteri speciali, per impedire che la shell li interpreti.
+ **Limitazione dell'ambito dei parametri**: utilizzare i modelli di parametri più restrittivi possibili per il proprio caso d'uso.
# Elementi di dati e parametri
Questo argomento descrive gli elementi di dati utilizzati nei documenti SSM. La versione dello schema utilizzata per creare un documento definisce la sintassi e gli elementi di dati accettati. Per i documenti di comando è consigliabile utilizzare la versione dello schema 2.2 o successiva. I runbook Automation utilizzano la versione dello schema 0.3. Inoltre, i runbook Automation supportano l'uso di Markdown, un linguaggio di markup, che consente di aggiungere descrizioni in stile wiki ai documenti e alle singole fasi all'interno del documento. Per ulteriori informazioni sull'utilizzo di Markdown, consulta [Utilizzo di Markdown nella console](https://docs.aws.amazon.com/general/latest/gr/aws-markdown.html) nella *Guida alle operazioni di base di Console di gestione AWS *.
La sezione seguente descrive gli elementi di dati che si possono includere in un documento SSM.
## Elementi di dati di primo livello
**schemaVersion**
La versione dello schema da utilizzare.
Tipo: Versione
Obbligatorio: sì
**description**
Le informazioni fornite per descrivere lo scopo del documento. È inoltre possibile utilizzare questo campo per specificare se un parametro richiede un valore per l'esecuzione di un documento o se è facoltativo fornire un valore per il parametro. I parametri obbligatori e facoltativi possono essere visualizzati negli esempi in questo argomento.
▬Tipo: stringa
Obbligatorio: no
**parametri**
Una struttura che definisce i parametri accettati dal documento.
Per una maggiore sicurezza durante la gestione dei parametri delle stringhe, è possibile utilizzare l'interpolazione delle variabili di ambiente specificando la proprietà di `interpolationType`. Se impostato su `ENV_VAR`, l'agente crea una variabile di ambiente denominata `SSM_parameter-name`, che contiene il valore del parametro.
Di seguito è riportato un esempio di parametro che utilizza una variabile di ambiente di `interpolationType`:
```
{
"schemaVersion": "2.2",
"description": "An example document.",
"parameters": {
"Message": {
"type": "String",
"description": "Message to be printed",
"default": "Hello",
"interpolationType" : "ENV_VAR",
"allowedPattern": "^[^"]*$"
}
},
"mainSteps": [{
"action": "aws:runShellScript",
"name": "printMessage",
"precondition" : {
"StringEquals" : ["platformType", "Linux"]
},
"inputs": {
"runCommand": [
"echo {{Message}}"
]
}
}
}
```
`allowedPattern` non è tecnicamente necessario, se un documento SSM non utilizza le doppie parentesi graffe: `{{ }}`
Riguardo ai parametri che si utilizzano spesso, è consigliabile archiviarli in Parameter Store, uno strumento di AWS Systems Manager. Puoi quindi definire i parametri nel tuo documento che si riferiscono ai parametri Parameter Store come valore predefinito. Per fare riferimento al parametro Parameter Store, utilizza la sintassi seguente.
```
{{ssm:parameter-name}}
```
È possibile utilizzare un parametro che fa riferimento al parametro Parameter Store allo stesso modo di qualsiasi altro parametro del documento. Nell'esempio seguente, il valore predefinito per il parametro `commands` è il valore del parametro Parameter Store `myShellCommands`. Specificando il valore del parametro `commands` come stringa `runCommand`, il documento esegue i comandi memorizzati nel parametro `myShellCommands`.
```
---
schemaVersion: '2.2'
description: runShellScript with command strings stored as Parameter Store parameter
parameters:
commands:
type: StringList
description: "(Required) The commands to run on the instance."
default: ["{{ ssm:myShellCommands }}"],
interpolationType : 'ENV_VAR'
allowedPattern: '^[^"]*$'
mainSteps:
- action: aws:runShellScript
name: runShellScriptDefaultParams
inputs:
runCommand:"{{ commands }}"
```
```
{
"schemaVersion": "2.2",
"description": "runShellScript with command strings stored as Parameter Store parameter",
"parameters": {
"commands": {
"type": "StringList",
"description": "(Required) The commands to run on the instance.",
"default": ["{{ ssm:myShellCommands }}"],
"interpolationType" : "ENV_VAR"
}
},
"mainSteps": [
{
"action": "aws:runShellScript",
"name": "runShellScriptDefaultParams",
"inputs": {
"runCommand": [
"{{ commands }}"
]
}
}
]
}
```
Puoi fare riferimento ai parametri `String`, `StringList` e Parameter Store nella sezione `parameters` del documento. Non si può fare riferimento ai parametri `SecureString` Parameter Store.
Per ulteriori informazioni su Parameter Store, consultare [AWS Systems Manager Parameter Store](systems-manager-parameter-store.md).
Tipo: Struttura
La struttura `parameters` accetta i seguenti campi e valori:
+ `type`: (Obbligatorio) I valori consentiti sono i seguenti: `String`, `StringList`, `Integer`, `Boolean`, `MapList` e `StringMap`. Per visualizzare esempi di ciascun tipo, consulta [Esempi `type` di parametri di documenti SSM](#top-level-properties-type) nella sezione successiva.
**Nota**
I documenti di tipo di comando supportano solo i tipi di parametri `String` e `StringList`.
+ `description`: (facoltativo) una descrizione del parametro.
+ `default`: (facoltativo) il valore predefinito del parametro o un riferimento a un parametro in Parameter Store.
+ `allowedValues`: (facoltativo) una matrice dei valori consentiti per il parametro. La definizione dei valori consentiti per il parametro convalida l'input dell'utente. Se un utente inserisce un valore non consentito, l'esecuzione non viene avviata.
------
#### [ YAML ]
```
DirectoryType:
type: String
description: "(Required) The directory type to launch."
default: AwsMad
allowedValues:
- AdConnector
- AwsMad
- SimpleAd
```
------
#### [ JSON ]
```
"DirectoryType": {
"type": "String",
"description": "(Required) The directory type to launch.",
"default": "AwsMad",
"allowedValues": [
"AdConnector",
"AwsMad",
"SimpleAd"
]
}
```
------
+ `allowedPattern`: (facoltativo) un'espressione regolare che convalida se l'input dell'utente corrisponde al modello definito per il parametro. Se l'input dell'utente non corrisponde al modello consentito, l'esecuzione non viene avviata.
**Nota**
Systems Manager esegue due convalide per `allowedPattern`. La prima convalida viene eseguita utilizzando la [libreria Java regex](https://docs.oracle.com/javase/8/docs/api/java/util/regex/package-summary.html) a livello di API quando si utilizza un documento. La seconda convalida viene eseguita su SSM Agent utilizzando la [libreria di GO regexp](https://pkg.go.dev/regexp) prima di elaborare il documento.
------
#### [ YAML ]
```
InstanceId:
type: String
description: "(Required) The instance ID to target."
allowedPattern: "^i-(?:[a-f0-9]{8}|[a-f0-9]{17})$"
default: ''
```
------
#### [ JSON ]
```
"InstanceId": {
"type": "String",
"description": "(Required) The instance ID to target.",
"allowedPattern": "^i-(?:[a-f0-9]{8}|[a-f0-9]{17})$",
"default": ""
}
```
------
+ `displayType`: (Facoltativo) Utilizzato per visualizzare un `textfield` o un `textarea` in Console di gestione AWS. `textfield`è una casella di testo a riga singola. `textarea`è un'area di testo su più righe.
+ `minItems`: (facoltativo) il numero minimo di elementi consentiti.
+ `maxItems`: (facoltativo) il numero massimo di elementi consentiti.
+ `minChars`: (facoltativo) il numero minimo di caratteri del parametro consentiti.
+ `maxChars`: (facoltativo) il numero massimo di caratteri del parametro consentiti.
+ `interpolationType`: (facoltativo) definisce come i valori dei parametri vengono elaborati prima dell'esecuzione del comando. Se impostato su `ENV_VAR`, il valore del parametro viene reso disponibile come variabile di ambiente denominata `SSM_parameter-name`. Questa funzionalità previene l'iniezione di comandi trattando i valori di parametro come stringhe letterali.
Tipo: String
Valori validi: `ENV_VAR`
Campo obbligatorio: no
**variables**
(Solo versione 0.3 dello schema) Valori a cui è possibile fare riferimento o da aggiornare durante i passaggi di un runbook Automation. Le variabili sono simili ai parametri, ma presentano una differenza molto rilevante. Nel contesto di un runbook, i valori dei parametri sono statici mentre quelli delle variabili possono essere modificati. Quando si aggiorna il valore di una variabile, il tipo di dati deve corrispondere al tipo di dati definito. Per informazioni sull'aggiornamento dei valori delle variabili in un'automazione, consulta la pagina [`aws:updateVariable`: aggiorna un valore per una variabile di runbook](automation-action-update-variable.md)
Tipo: Boolean \$1 Integer \$1 \$1 String \$1 \$1 MapList StringList StringMap
Obbligatorio: no
```
variables:
payload:
type: StringMap
default: "{}"
```
```
{
"variables": [
"payload": {
"type": "StringMap",
"default": "{}"
}
]
}
```
**runtimeConfig**
(Solo versione dello schema 1.2) La configurazione per l'istanza applicata da uno o più plugin di Systems Manager. Non è garantito che l'esecuzione dei plugin avvenga in sequenza.
Tipo: Dictionary PluginConfiguration
Obbligatorio: no
**mainSteps**
(Solo versione dello schema 0.3, 2.0 e 2.2) Un oggetto che può includere più fasi (plugin). I plugin sono definiti all'interno delle fasi. Le fasi vengono eseguite nell'ordine sequenziale indicato nel documento.
Tipo: Dictionary PluginConfiguration
Obbligatorio: sì
**outputs**
(Solo versione dello schema 0.3) Dati generati dall'esecuzione di questo documento che possono essere utilizzati in altri processi. Ad esempio, se il documento ne crea uno nuovoAMI, puoi specificare ". CreateImage ImageId"come valore di output, quindi utilizzate questo output per creare nuove istanze in una successiva esecuzione di automazione. Per ulteriori informazioni sugli output, consulta [Utilizzo degli output delle operazioni come input](automation-action-outputs-inputs.md).
Tipo: dictionary OutputConfiguration
Obbligatorio: no
**files**
(Solo versione dello schema 0.3) I file di script (e i relativi checksum) collegati al documento ed eseguiti durante un'esecuzione dell'automazione. Si applica solo ai documenti che includono l'operazione `aws:executeScript` e per i quali gli allegati sono stati specificati in una o più fasi.
Per ulteriori informazioni sui runtime supportati dai runbook Automation, vedere [`aws:executeScript`: esecuzione di uno script](automation-action-executeScript.md). Per ulteriori informazioni sull'inclusione di script nei runbook Automation, consultare [Utilizzo di script nei runbook](automation-document-script-considerations.md) e [Esperienza di progettazione visiva per i runbook Automation](automation-visual-designer.md).
Quando si crea un runbook di automazione con allegati, è inoltre necessario specificare i file allegati utilizzando l'`--attachments`opzione (for AWS CLI) o `Attachments` (per API e SDK). È possibile specificare la posizione del file sia per i documenti SSM che per i file archiviati nei bucket Amazon Simple Storage Service (Amazon S3). Per ulteriori informazioni, consulta [Allegati](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateDocument.html#systemsmanager-CreateDocument-request-Attachments) nell'API Reference. AWS Systems Manager
```
---
files:
launch.py:
checksums:
sha256: 18871b1311b295c43d0f...[truncated]...772da97b67e99d84d342ef4aEXAMPLE
```
```
"files": {
"launch.py": {
"checksums": {
"sha256": "18871b1311b295c43d0f...[truncated]...772da97b67e99d84d342ef4aEXAMPLE"
}
}
}
```
Tipo: dictionary FilesConfiguration
Obbligatorio: no
## Esempi `type` di parametri di documenti SSM
I tipi di parametri nei documenti SSM sono statici. Ciò significa che il tipo di parametro non può essere modificato dopo che è stato definito. Quando si utilizzano parametri con plugin del documento SSM, il tipo di parametro non può essere modificato dinamicamente all'interno dell'input di un plugin. Ad esempio, non è possibile fare riferimento a un parametro `Integer` all'interno dell'input `runCommand` del plugin `aws:runShellScript` perché questo input accetta una stringa o un elenco di stringhe. Per utilizzare un parametro per un input di plugin, il tipo di parametro deve corrispondere al tipo accettato. Ad esempio, è necessario specificare un tipo di parametro `Boolean` per l'input `allowDowngrade` del plugin `aws:updateSsmAgent`. Se il tipo di parametro non corrisponde al tipo di input per un plugin, il documento SSM non viene convalidato e il sistema non crea il documento. Questo vale anche quando si utilizzano parametri a valle all'interno degli input per altri plugin o azioni di automazione. AWS Systems Manager Ad esempio, non è possibile fare riferimento a un parametro di `StringList` nell'input `documentParameters` del plugin `aws:runDocument`. L'input di `documentParameters` accetta una mappa di stringhe anche se il tipo di parametro del documento SSM a valle è un parametro `StringList` e corrisponde al parametro a cui si fa riferimento.
Quando si utilizzano parametri con operazioni di automazione di , nella maggior parte dei casi i tipi di parametro non vengono convalidati quando si crea il documento SSM. Solo quando si utilizza l'operazione `aws:runCommand`, i tipi di parametro vengono convalidati quando si crea il documento SSM. In tutti gli altri casi, la convalida dei parametri avviene durante l'esecuzione dell'automazione quando l'input di un'operazione viene verificato prima dell'esecuzione. Ad esempio, se il parametro di input è `String` e si fa riferimento ad esso come valore per l'input `MaxInstanceCount` dell'operazione `aws:runInstances`, viene creato il documento SSM. Tuttavia, quando si esegue il documento, l'automazione non riesce durante la convalida dell'operazione `aws:runInstances` perché l'input `MaxInstanceCount` richiede un valore `Integer`.
Di seguito sono riportati alcuni esempi di ciascun parametro `type`.
Stringa
Una sequenza di zero o più caratteri Unicode inclusa tra virgolette. Ad esempio, "i-1234567890abcdef0". Utilizza barre rovesciate come caratteri di escape.
I parametri di stringa possono includere un campo di `interpolationType` opzionale con il valore `ENV_VAR`, per abilitare l'interpolazione delle variabili di ambiente per una maggiore sicurezza.
```
---
InstanceId:
type: String
description: "(Optional) The target EC2 instance ID."
interpolationType: ENV_VAR
```
```
"InstanceId":{
"type":"String",
"description":"(Optional) The target EC2 instance ID.",
"interpolationType": "ENV_VAR"
}
```
StringList
Un elenco di elementi String separati da virgole. Ad esempio, ["cd \$1", "pwd"].
```
---
commands:
type: StringList
description: "(Required) Specify a shell script or a command to run."
default: ""
minItems: 1
displayType: textarea
```
```
"commands":{
"type":"StringList",
"description":"(Required) Specify a shell script or a command to run.",
"minItems":1,
"displayType":"textarea"
}
```
Booleano
Accetta solo `true` o `false`. Non accetta "true" o 0.
```
---
canRun:
type: Boolean
description: ''
default: true
```
```
"canRun": {
"type": "Boolean",
"description": "",
"default": true
}
```
Numero intero
Numeri interi. Non accetta numeri decimali, ad esempio 3,14159, o numeri inclusi tra virgolette, ad esempio "3".
```
---
timeout:
type: Integer
description: The type of action to perform.
default: 100
```
```
"timeout": {
"type": "Integer",
"description": "The type of action to perform.",
"default": 100
}
```
StringMap
Mappatura di chiavi a valori. Le chiavi e i valori devono essere stringhe. Ad esempio, \$1"Env": "Prod"\$1.
```
---
notificationConfig:
type: StringMap
description: The configuration for events to be notified about
default:
NotificationType: 'Command'
NotificationEvents:
- 'Failed'
NotificationArn: "$dependency.topicArn"
maxChars: 150
```
```
"notificationConfig" : {
"type" : "StringMap",
"description" : "The configuration for events to be notified about",
"default" : {
"NotificationType" : "Command",
"NotificationEvents" : ["Failed"],
"NotificationArn" : "$dependency.topicArn"
},
"maxChars" : 150
}
```
MapList
Un elenco di oggetti. StringMap
```
blockDeviceMappings:
type: MapList
description: The mappings for the create image inputs
default:
- DeviceName: "/dev/sda1"
Ebs:
VolumeSize: "50"
- DeviceName: "/dev/sdm"
Ebs:
VolumeSize: "100"
maxItems: 2
```
```
"blockDeviceMappings":{
"type":"MapList",
"description":"The mappings for the create image inputs",
"default":[
{
"DeviceName":"/dev/sda1",
"Ebs":{
"VolumeSize":"50"
}
},
{
"DeviceName":"/dev/sdm",
"Ebs":{
"VolumeSize":"100"
}
}
],
"maxItems":2
}
```
## Visualizzazione del contenuto del documento Command SSM
Per visualizzare in anteprima i parametri obbligatori e facoltativi per un documento di comando AWS Systems Manager (SSM), oltre alle azioni eseguite dal documento, è possibile visualizzare il contenuto del documento nella console Systems Manager.
**Per visualizzare il contenuto del documento Command SSM**
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 **Documenti**.
1. Nella casella di ricerca selezionare **Document type (Tipo di documento)** e quindi selezionare **Command (Comando)**.
1. Scegli il nome di un documento, quindi la scheda **Contenuto**.
1. Nel campo del contenuto esaminare i parametri e i passaggi delle operazioni disponibili per il documento.
Ad esempio, l'immagine seguente mostra che (1) `version` e (2) `allowDowngrade`sono parametri opzionali per il documento `AWS-UpdateSSMAgent` e che la prima operazione eseguita dal documento è (3) `aws:updateSsmAgent`.
![\[Visualizzare il contenuto dei documenti SSM nella console di Systems Manager\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/images/view-document-content.png)
# Documentazione di riferimento del plugin per i documenti di comando
Questo riferimento descrive i plugin che è possibile specificare in un documento di tipo Command AWS Systems Manager (SSM). Questi plugin non possono essere utilizzati nei runbook Automation SSM che usano operazioni di Automation. Per informazioni sulle azioni di AWS Systems Manager automazione, vedere. [Riferimento alle operazioni del servizio di automazione di Systems Manager](automation-actions.md)
Systems Manager determina le operazioni da eseguire su un'istanza gestita mediante la lettura dei contenuti di un documento SSM. Ogni documento include una sezione di esecuzione di codice. A seconda della versione dello schema del documento, questa sezione di esecuzione di codice può includere uno o più plugin o fasi. Ai fini di questo argomento della Guida, i plugin e le fasi sono chiamati *plugin*. Questa sezione include informazioni su ciascun plugin di Systems Manager. Per ulteriori informazioni sui documenti, incluse informazioni sulla creazione di documenti e sulle differenze tra le versioni dello schema, consulta [Documenti di AWS Systems Manager](documents.md).
Per i plugin che accettano parametri String, come `aws:runShellScript` e `aws:runPowerShellScript`, il parametro `interpolationType` è utilizzabile per migliorare la sicurezza trattando gli input dei parametri come stringhe letterali, invece di comandi potenzialmente eseguibili. Esempio:
```
{
"schemaVersion": "2.2",
"description": "runShellScript with command strings stored as Parameter Store parameter",
"parameters": {
"commands": {
"type": "StringList",
"description": "(Required) The commands to run on the instance.",
"default": ["{{ ssm:myShellCommands }}"],
"interpolationType" : "ENV_VAR"
}
},
//truncated
}
```
**Nota**
Alcuni dei plugin illustrati in questa sezione possono essere eseguiti soltanto su istanze Windows Server o Linux. Sono riportate le dipendenze della piattaforma per ogni plugin.
I seguenti plugin di documenti sono supportati nelle istanze di Amazon Elastic Compute Cloud (Amazon EC2) per macOS:
`aws:refreshAssociation`
`aws:runShellScript`
`aws:runPowerShellScript`
`aws:softwareInventory`
`aws:updateSsmAgent`
**Topics**
+ [
## Input condivisi
](#shared-inputs)
+ [
## `aws:applications`
](#aws-applications)
+ [
## `aws:cloudWatch`
](#aws-cloudWatch)
+ [
## `aws:configureDocker`
](#aws-configuredocker)
+ [
## `aws:configurePackage`
](#aws-configurepackage)
+ [
## `aws:domainJoin`
](#aws-domainJoin)
+ [
## `aws:downloadContent`
](#aws-downloadContent)
+ [
## `aws:psModule`
](#aws-psModule)
+ [
## `aws:refreshAssociation`
](#aws-refreshassociation)
+ [
## `aws:runDockerAction`
](#aws-rundockeraction)
+ [
## `aws:runDocument`
](#aws-rundocument)
+ [
## `aws:runPowerShellScript`
](#aws-runPowerShellScript)
+ [
## `aws:runShellScript`
](#aws-runShellScript)
+ [
## `aws:softwareInventory`
](#aws-softwareinventory)
+ [
## `aws:updateAgent`
](#aws-updateagent)
+ [
## `aws:updateSsmAgent`
](#aws-updatessmagent)
## Input condivisi
Solo con la versione 3.0.502 e successive di SSM Agent tutti i plugin possono utilizzare i seguenti input:
**finallyStep**
L'ultimo passaggio è l'esecuzione del documento. Se questo input è definito per un passaggio, ha la precedenza su un valore `exit` specificato negli input `onFailure` o `onSuccess`. Affinché un passaggio con questo input sia eseguito come previsto, il passaggio deve essere l'ultimo definito nel `mainSteps` del documento.
Tipo: Booleano
Valori validi: `true` \$1 `false`
Obbligatorio: no
**onFailure**
Se si specifica questo input per un plugin con il valore `exit` e il passaggio non riesce, lo stato del passaggio riflette l'errore e il documento non esegue i passaggi rimanenti a meno che non sia stato definito un `finallyStep`. Se si specifica questo input per un plugin con il valore `successAndExit` e il passaggio non riesce, lo stato del passaggio riflette l'errore e il documento non esegue i passaggi rimanenti a meno che non sia stato definito un `finallyStep`.
Tipo: String
Valori validi: `exit` \$1 `successAndExit`
Obbligatorio: no
**onSuccess**
Se si specifica questo input per un plugin e il passaggio viene eseguito correttamente, il documento non esegue i passaggi rimanenti a meno che non sia stato definito un `finallyStep`.
Tipo: String
Valori validi: `exit`
Campo obbligatorio: no
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: Shared inputs example
parameters:
customDocumentParameter:
type: String
description: Example parameter for a custom Command-type document.
mainSteps:
- action: aws:runDocument
name: runCustomConfiguration
inputs:
documentType: SSMDocument
documentPath: "yourCustomDocument"
documentParameters: '"documentParameter":{{customDocumentParameter}}'
onSuccess: exit
- action: aws:runDocument
name: ifConfigurationFailure
inputs:
documentType: SSMDocument
documentPath: "yourCustomRepairDocument"
onFailure: exit
- action: aws:runDocument
name: finalConfiguration
inputs:
documentType: SSMDocument
documentPath: "yourCustomFinalDocument"
finallyStep: true
```
------
#### [ JSON ]
```
{
"schemaVersion": "2.2",
"description": "Shared inputs example",
"parameters": {
"customDocumentParameter": {
"type": "String",
"description": "Example parameter for a custom Command-type document."
}
},
"mainSteps":[
{
"action": "aws:runDocument",
"name": "runCustomConfiguration",
"inputs": {
"documentType": "SSMDocument",
"documentPath": "yourCustomDocument",
"documentParameters": "\"documentParameter\":{{customDocumentParameter}}",
"onSuccess": "exit"
}
},
{
"action": "aws:runDocument",
"name": "ifConfigurationFailure",
"inputs": {
"documentType": "SSMDocument",
"documentPath": "yourCustomRepairDocument",
"onFailure": "exit"
}
},
{
"action": "aws:runDocument",
"name":"finalConfiguration",
"inputs": {
"documentType": "SSMDocument",
"documentPath": "yourCustomFinalDocument",
"finallyStep": true
}
}
]
}
```
------
## `aws:applications`
Installa, ripara o disinstalla applicazioni su un'istanza EC2. Questo plugin può essere eseguito solo su sistemi operativi Windows Server.
### Sintassi
#### Schema 2.2
------
#### [ YAML ]
```
---
schemaVersion: '2.2'
description: aws:applications plugin
parameters:
source:
description: "(Required) Source of msi."
type: String
mainSteps:
- action: aws:applications
name: example
inputs:
action: Install
source: "{{ source }}"
```
------
#### [ JSON ]
```
{
"schemaVersion":"2.2",
"description":"aws:applications",
"parameters":{
"source":{
"description":"(Required) Source of msi.",
"type":"String"
}
},
"mainSteps":[
{
"action":"aws:applications",
"name":"example",
"inputs":{
"action":"Install",
"source":"{{ source }}"
}
}
]
}
```
------
#### Schema 1.2
------
#### [ YAML ]
```
---
runtimeConfig:
aws:applications:
properties:
- id: 0.aws:applications
action: "{{ action }}"
parameters: "{{ parameters }}"
source: "{{ source }}"
sourceHash: "{{ sourceHash }}"
```
------
#### [ JSON ]
```
{
"runtimeConfig":{
"aws:applications":{
"properties":[
{
"id":"0.aws:applications",
"action":"{{ action }}",
"parameters":"{{ parameters }}",
"source":"{{ source }}",
"sourceHash":"{{ sourceHash }}"
}
]
}
}
}
```
------
### Properties
**operazione**
L'operazione da eseguire.
Tipo: Enum
Valori validi: `Install` \$1 `Repair` \$1 `Uninstall`
Obbligatorio: sì
**parametri**
I parametri per il programma di installazione.
Tipo: stringa
Obbligatorio: no
**origine**
L'URL del file `.msi` per l'applicazione.
Tipo: stringa
Obbligatorio: sì
**sourceHash**
L' SHA256 hash del `.msi` file.
▬Tipo: stringa
Obbligatorio: no
## `aws:cloudWatch`
Esporta i dati Windows Server da Amazon CloudWatch o Amazon CloudWatch Logs e monitora i dati utilizzando le CloudWatch metriche. Questo plugin può essere eseguito solo su sistemi operativi Windows Server. *Per ulteriori informazioni sulla configurazione CloudWatch dell'integrazione con Amazon Elastic Compute Cloud (Amazon EC2)[, consulta Collecting metrics, logs and trace with CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) the agent nella Amazon User Guide. CloudWatch *
**Importante**
L' CloudWatch agente unificato è stato sostituito SSM Agent come strumento per l'invio dei dati di log ad Amazon CloudWatch Logs. Il plugin aws:cloudWatch SSM Agent non è supportato. Ti consigliamo di utilizzare solo l' CloudWatch agente unificato per i processi di raccolta dei log. Per ulteriori informazioni, consulta i seguenti argomenti:
[Invio dei log dei nodi a CloudWatch registri unificati (agente) CloudWatch](monitoring-cloudwatch-agent.md)
[Esegui la migrazione della raccolta di log dei nodi di Windows Server all'agente CloudWatch](monitoring-cloudwatch-agent.md#monitoring-cloudwatch-agent-migrate)
[Raccolta di metriche, log e tracce con l' CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) nella *Amazon CloudWatch User* Guide.
Puoi esportare e monitorare i seguenti tipi di dati:
**ApplicationEventLog**
Invia i dati del registro degli eventi dell'applicazione a CloudWatch Logs.
**CustomLogs**
Invia qualsiasi file di registro basato su testo ad Amazon CloudWatch Logs. Il CloudWatch plug-in crea un'impronta digitale per i file di registro. Quindi, il sistema associa un offset dei dati con ciascun ID digitale. Il plugin carica i file quando sono presenti modifiche, registra l'offset e lo associa a un ID digitale. Questo metodo viene utilizzato per evitare una situazione in cui un utente attiva il plugin, associa il servizio a una directory che contiene un numero elevato di file e il sistema carica tutti i file.
Se l'applicazione tronca o tenta di eliminare i log durante il polling, qualsiasi log specificato per `LogDirectoryPath` può perdere voci. Se, ad esempio, desideri limitare le dimensioni del file di log, devi creare un nuovo file di log quando viene raggiunto il limite, quindi devi continuare a scrivere i dati sul nuovo file.
**ETW**
Invia i dati di Event Tracing for Windows (ETW) ai registri. CloudWatch
**IIS**
Invia i dati di registro IIS ai registri. CloudWatch
**PerformanceCounter**
Invia i contatori delle prestazioni di Windows a. CloudWatch Puoi selezionare diverse categorie in cui caricare CloudWatch come metriche. Per ogni contatore delle prestazioni che desideri caricare, crea una **PerformanceCounter**sezione con un ID univoco (ad esempio, "PerformanceCounter2"," PerformanceCounter 3" e così via) e configurane le proprietà.
Se il plug-in AWS Systems Manager SSM Agent o il CloudWatch plug-in sono interrotti, i dati del contatore delle prestazioni non vengono registrati. CloudWatch Questo comportamento è diverso rispetto ai log personalizzati o ai log di eventi di Windows. I registri personalizzati e i registri degli eventi di Windows conservano i dati del contatore delle prestazioni e li caricano su after, CloudWatch SSM Agent altrimenti il CloudWatch plug-in sarà disponibile.
**SecurityEventLog**
Invia i dati del registro degli eventi di sicurezza ai CloudWatch registri.
**SystemEventLog**
Invia i dati del registro degli eventi di sistema ai CloudWatch registri.
Puoi definire le seguenti destinazioni per i dati:
**CloudWatch**
La destinazione in cui vengono inviati i dati dei parametri del contatore delle prestazioni. È possibile aggiungere altre sezioni con caratteri univoci IDs (ad esempio, "CloudWatch2", CloudWatch 3" e così via) e specificare una regione diversa per ogni nuovo ID per inviare gli stessi dati a posizioni diverse.
**CloudWatchLogs**
La destinazione in cui vengono inviati i dati di log. Puoi aggiungere altre sezioni con un valore univoco IDs (ad esempio, "CloudWatchLogs2", CloudWatchLogs 3" e così via) e specificare una regione diversa per ogni nuovo ID per inviare gli stessi dati a posizioni diverse.
### Sintassi
```
"runtimeConfig":{
"aws:cloudWatch":{
"settings":{
"startType":"{{ status }}"
},
"properties":"{{ properties }}"
}
}
```
### Impostazioni e proprietà
**AccessKey**
L'ID chiave di accesso . Questa proprietà è obbligatoria, a meno che l'utente non abbia avviato l'istanza usando un ruolo IAM. Questa proprietà non può essere utilizzata con SSM.
▬Tipo: stringa
Obbligatorio: no
**CategoryName**
La categoria del contatore delle prestazioni da Performance Monitor.
Tipo: stringa
Obbligatorio: sì
**CounterName**
Il nome del contatore delle prestazioni da Performance Monitor.
Tipo: stringa
Obbligatorio: sì
**CultureName**
L'impostazione locale in cui viene registrato il timestamp. Se **CultureName**è vuoto, il valore predefinito è lo stesso locale usato dall'istanza. Windows Server
Tipo: String
Valori validi: per un elenco dei valori supportati, consulta [National Language Support (NLS)](https://msdn.microsoft.com/en-us/library/cc233982.aspx) sul sito Web Microsoft. I valori **div**, **div-MV**, **hu** e **hu-HU** non sono supportati.
Obbligatorio: no
**DimensionName**
Una dimensione per la tua CloudWatch metrica Amazon. Se specifichi `DimensionName`, devi specificare `DimensionValue`. Questi parametri forniscono un'altra vista al momento della creazione di elenchi di parametri. Puoi utilizzare la stessa dimensione per più parametri per poter visualizzare tutti i parametri appartenenti a una dimensione specifica.
▬Tipo: stringa
Obbligatorio: no
**DimensionValue**
Un valore dimensionale per la tua CloudWatch metrica Amazon.
▬Tipo: stringa
Obbligatorio: no
**Encoding**
La codifica del file da utilizzare (ad esempio, UTF-8). Utilizza il nome di codifica, non il nome di visualizzazione.
Tipo: String
Valori validi: per un elenco dei valori supportati, consulta l'argomento relativo alla [classe di codifica](https://learn.microsoft.com/en-us/dotnet/api/system.text.encoding?view=net-7.0) nella libreria di Microsoft Learn.
Obbligatorio: sì
**Filtro**
Il prefisso dei nomi di log. Lascia questo parametro bianco per monitorare tutti i file.
Tipo: String
Valori validi: per un elenco dei valori supportati, consulta la [FileSystemWatcherFilter proprietà](http://msdn.microsoft.com/en-us/library/system.io.filesystemwatcher.filter.aspx) nella libreria MSDN.
Obbligatorio: no
**Flussi**
Ogni tipo di dati da caricare, insieme alla destinazione dei dati (CloudWatch o dei CloudWatch registri). Ad esempio, per inviare un contatore delle prestazioni definito in `"Id": "PerformanceCounter"` alla CloudWatch destinazione definita in`"Id": "CloudWatch"`, inserisci **CloudWatch"PerformanceCounter,»**. Analogamente, per inviare il registro personalizzato, il registro ETW e il registro di sistema alla destinazione dei CloudWatch registri definita in`"Id": "ETW"`, immettete **«(ETW)**,". CloudWatchLogs Inoltre, puoi inviare lo stesso contatore delle prestazioni o file di log a più destinazioni. Ad esempio, per inviare il registro dell'applicazione a due diverse destinazioni definite in `"Id": "CloudWatchLogs"` e`"Id": "CloudWatchLogs2"`, immettete **", (ApplicationEventLogCloudWatchLogs, CloudWatchLogs 2**)».
Tipo: String
Valori validi (origine): `ApplicationEventLog` \$1 `CustomLogs` \$1 `ETW` \$1 `PerformanceCounter` \$1 `SystemEventLog` \$1 `SecurityEventLog`
Valori validi (destinazione): `CloudWatch` \$1 `CloudWatchLogs` \$1 `CloudWatch` *n* \$1 `CloudWatchLogs` *n*
Obbligatorio: sì
**FullName**
Il nome completo del componente.
Tipo: stringa
Obbligatorio: sì
**Id**
Identifica l'origine o la destinazione dei dati. Questo identificatore deve essere univoco all'interno del file di configurazione.
Tipo: stringa
Obbligatorio: sì
**InstanceName**
Il nome dell'istanza del contatore delle prestazioni. Non utilizzare un asterisco (\$1) per indicare tutte le istanze perché ciascun componente del contatore delle prestazioni supporta solo un parametro. Tuttavia, puoi utilizzare **\$1Total**.
Tipo: stringa
Obbligatorio: sì
**Levels**
I tipi di messaggi da inviare ad Amazon CloudWatch.
Tipo: String
Valori validi:
+ **1**: solo i messaggi di errore caricati.
+ **2**: solo i messaggi di avviso caricati.
+ **4**: solo i messaggi informativi caricati.
È possibile aggiungere valori per includere più di un tipo di messaggio. Ad esempio, **3** indica che i messaggi di errore (**1**) e i messaggi di avviso (**2**) sono inclusi. Un valore pari a **7** indica che i messaggi di errore (**1**), i messaggi di avviso (**2**) e i messaggi informativi (**4**) sono inclusi.
Obbligatorio: sì
I log di sicurezza di Windows dovrebbero impostare livelli fino a 7.
**LineCount**
Il numero di righe dell'intestazione per identificare il file di log. Ad esempio, i file di log IIS dispongono di intestazioni praticamente identiche. Puoi inserire **3**, che può leggere le prime tre righe dell'intestazione del file di log per identificarlo. Nei file di log IIS, la terza riga è costituita dalla data e dal timestamp, che è diverso tra i file di log.
Tipo: Integer
Obbligatorio: no
**LogDirectoryPath**
Per CustomLogs, il percorso in cui vengono archiviati i log sull'istanza EC2. Per i registri IIS, la cartella in cui sono archiviati i registri IIS per un singolo sito (ad esempio, **C:\$1\$1 inetpub\$1\$1 logs\$1\$1\$1\$1 W3SVC**). LogFiles *n* Per i log di IIS, è supportato solo il formato di log W3C. I formati IIS, NCSA e quelli personalizzati non sono supportati.
Tipo: stringa
Obbligatorio: sì
**LogGroup**
Nome del gruppo di log. Questo nome viene visualizzato sulla schermata **Log Groups (Gruppi di log)** nella console CloudWatch.
Tipo: stringa
Obbligatorio: sì
**LogName**
Nome del file di log.
1. Per individuare il nome del log, in Visualizzatore eventi, nel riquadro di navigazione, scegli **Log di applicazioni e servizi**.
1. Nell'elenco dei registri, fai clic con il pulsante destro del mouse sul log che desideri caricare (ad esempio, `Microsoft` > `Windows` > `Backup` > `Operational`), quindi seleziona **Crea visualizzazione personalizzata**.
1. Nella finestra di dialogo **Crea visualizzazione personalizzata**, scegli la scheda **XML**. **LogName**Si trova nel tag