• 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 seguenti ti consentono di utilizzare Automazione AWS Systems Manager per i casi d'uso più comuni. Questi tutorial illustrano come utilizzare i runbook personali, quelli predefiniti forniti da Automazione e altri strumenti di Systems Manager con altri Servizi AWS.
**Contents**
+ [Aggiornamento degli AMIs](automation-tutorial-update-ami.md)
+ [Aggiornamento di un'AMI Linux](automation-tutorial-update-patch-linux-ami.md)
+ [Aggiornamento di un'AMI Linux (AWS CLI)](automation-tutorial-update-ami.md#update-patch-linux-ami-cli)
+ [Aggiornamento di un'Windows Server AMI](automation-tutorial-update-patch-windows-ami.md)
+ [Aggiorna un golden AMI usando Automation AWS Lambda, e Parameter Store](automation-tutorial-update-patch-golden-ami.md)
+ [Processo 1: creazione di un parametro nel Parameter Store di Systems Manager](automation-tutorial-update-patch-golden-ami.md#create-parameter-ami)
+ [Attività 2: creare un ruolo IAM per AWS Lambda](automation-tutorial-update-patch-golden-ami.md#create-lambda-role)
+ [Attività 3: Creare una AWS Lambda funzione](automation-tutorial-update-patch-golden-ami.md#create-lambda-function)
+ [Processo 4: creazione di un runbook e applicazione di patch all'AMI](automation-tutorial-update-patch-golden-ami.md#create-custom-ami-update-runbook)
+ [Aggiornamento delle AMIs tramite automazione e Jenkins](automation-tutorial-update-patch-ami-jenkins-integration.md)
+ [Aggiornamento delle AMIs per i gruppi Auto Scaling](automation-tutorial-update-patch-windows-ami-autoscaling.md)
+ [Crea il runbook **Patch AMIAnd UpdateASG**](automation-tutorial-update-patch-windows-ami-autoscaling.md#create-autoscaling-update-runbook)
+ [Utilizzo dei Supporto AWS runbook self-service](automation-tutorial-support-runbooks.md)
+ [Esegui lo strumento EC2 Rescue su istanze irraggiungibili](automation-ec2rescue.md)
+ [Come funziona](automation-ec2rescue.md#automation-ec2rescue-how)
+ [Prima di iniziare](automation-ec2rescue.md#automation-ec2rescue-begin)
+ [Concessione delle autorizzazioni `AWSSupport-EC2Rescue` per eseguire operazioni sulle istanze](automation-ec2rescue.md#automation-ec2rescue-access)
+ [Concessione delle autorizzazioni mediante policy IAM](automation-ec2rescue.md#automation-ec2rescue-access-iam)
+ [Concessione delle autorizzazioni utilizzando un modello CloudFormation](automation-ec2rescue.md#automation-ec2rescue-access-cfn)
+ [Esecuzione del servizio di automazione](automation-ec2rescue.md#automation-ec2rescue-executing)
+ [Ripristino di password e chiavi SSH sulle istanze EC2](automation-ec2reset.md)
+ [Come funziona](automation-ec2reset.md#automation-ec2reset-how)
+ [Prima di iniziare](automation-ec2reset.md#automation-ec2reset-begin)
+ [Concessione delle autorizzazioni a AWSSupport-EC 2Rescue per eseguire azioni sulle istanze](automation-ec2reset.md#automation-ec2reset-access)
+ [Concessione delle autorizzazioni mediante policy IAM](automation-ec2reset.md#automation-ec2reset-access-iam)
+ [Concessione delle autorizzazioni utilizzando un modello CloudFormation](automation-ec2reset.md#automation-ec2reset-access-cfn)
+ [Esecuzione del servizio di automazione](automation-ec2reset.md#automation-ec2reset-executing)
+ [Trasmissione dei dati ad Automazione tramite trasformatori di input](automation-tutorial-eventbridge-input-transformers.md)
# Aggiornamento degli AMIs
I tutorial seguenti illustrano come aggiornare le Amazon Machine Image (AMIs) per includere le patch più recenti.
**Topics**
+ [Aggiornamento di un'AMI Linux](automation-tutorial-update-patch-linux-ami.md)
+ [Aggiornamento di un'AMI Linux (AWS CLI)](#update-patch-linux-ami-cli)
+ [Aggiornamento di un'Windows Server AMI](automation-tutorial-update-patch-windows-ami.md)
+ [Aggiorna un golden AMI usando Automation AWS Lambda, e Parameter Store](automation-tutorial-update-patch-golden-ami.md)
+ [Aggiornamento delle AMIs tramite automazione e Jenkins](automation-tutorial-update-patch-ami-jenkins-integration.md)
+ [Aggiornamento delle AMIs per i gruppi Auto Scaling](automation-tutorial-update-patch-windows-ami-autoscaling.md)
# Aggiornamento di un'AMI Linux
Questa procedura guidata di Automazione Systems Manager illustra come utilizzare la console o la AWS CLI e il runbook `AWS-UpdateLinuxAmi` per aggiornare un'AMI Linux con le patch più recenti dei pacchetti specificati. L'automazione è uno strumento di AWS Systems Manager. Il runbook `AWS-UpdateLinuxAmi` automatizza l'installazione anche di altri pacchetti e configurazioni specifici del sito. È possibile aggiornare un'ampia gamma di distribuzioni Linux utilizzando questa procedura guidata, tra cui Ubuntu Server, Red Hat Enterprise Linux (RHEL) oppure Amazon Linux AMIs. Per un elenco completo delle versioni Linux supportate, consulta [Prerequisiti di Patch Manager](patch-manager-prerequisites.md).
Il runbook `AWS-UpdateLinuxAmi` ti permette di automatizzare i processi di manutenzione delle immagini senza dover creare il runbook in JSON o YAML. È possibile utilizzare il runbook `AWS-UpdateLinuxAmi` per eseguire i tipi di processi seguenti.
+ Aggiornamento di tutti i pacchetti di distribuzione e del software Amazon su Amazon Linux, Red Hat Enterprise Linux o Ubuntu Server Amazon Machine Image (AMI). Questo è il comportamento predefinito del runbook.
+ Installa AWS Systems Manager SSM Agent su un'immagine esistente per abilitare gli strumenti di Systems Manager, come l'esecuzione di comandi remoti utilizzando AWS Systems Manager Run Command o la raccolta dell'inventario software utilizzando Inventory.
+ Installazione di pacchetti software aggiuntivi.
**Prima di iniziare**
Prima di iniziare a lavorare con i runbook, configurate i ruoli e, facoltativamente, EventBridge per l'automazione. Per ulteriori informazioni, consulta [Configurazione del servizio di automazione](automation-setup.md). Questa procedura dettagliata richiede inoltre di specificare il nome di un profilo di istanza AWS Identity and Access Management (IAM). Per ulteriori informazioni sulla creazione di un profilo dell'istanza IAM, consulta la pagina [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md).
Il runbook `AWS-UpdateLinuxAmi` accetta i parametri di input seguenti.
****
| Parametro | Tipo | Description |
| --- | --- | --- |
| SourceAmiId | Stringa | (Obbligatorio) L'ID origine di AMI. |
| IamInstanceProfileName | Stringa | (Obbligatorio) Il nome del ruolo del profilo dell'istanza IAM creato in [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md). Il ruolo del profilo dell'istanza concede le autorizzazioni al servizio di automazione per eseguire operazioni sulle istanze, ad esempio l'esecuzione di comandi o l'avvio e l'arresto dei servizi. Il runbook utilizza solo il nome del ruolo del profilo dell'istanza. Se si specifica l'Amazon Resource Name (ARN), l'automazione ha esito negativo. |
| AutomationAssumeRole | Stringa | (Obbligatorio) Nome del ruolo di servizio IAM creato in [Configurazione del servizio di automazione](automation-setup.md). Il ruolo di servizio (definito anche ruolo presunto) concede l'autorizzazione al servizio di automazione di assumere il ruolo IAM e di eseguire operazioni a nome dell'utente. Ad esempio, il ruolo di servizio permette al servizio di automazione di creare una nuova AMI quando viene eseguita l'operazione `aws:createImage` in un runbook. Per questo parametro, è necessario specificare l'ARN completo. |
| TargetAmiName | Stringa | (Facoltativo) Nome della nuova AMI dopo la creazione. Il nome predefinito è una stringa generata dal sistema contenente l'ID dell'AMI di origine e la data/ora di creazione. |
| InstanceType | Stringa | (Facoltativo) Tipo di istanza da avviare come host del workspace. I tipi di istanza variano in base alla regione. Il tipo predefinito è t2.micro. |
| PreUpdateScript | Stringa | (Facoltativo) URL di uno script da eseguire prima dell'applicazione degli aggiornamenti. L'impostazione predefinita (\$1"none\$1") non prevede l'esecuzione di uno script. |
| PostUpdateScript | Stringa | (Facoltativo) URL di uno script da eseguire dopo l'applicazione degli aggiornamenti ai pacchetti. L'impostazione predefinita (\$1"none\$1") non prevede l'esecuzione di uno script. |
| IncludePackages | Stringa | (Facoltativo) Vengono aggiornati solo i pacchetti specificati. Per impostazione predefinita (\$1"all\$1"), vengono applicati tutti gli aggiornamenti disponibili. |
| ExcludePackages | Stringa | (Facoltativo) Nomi dei pacchetti da non aggiornare, in tutte le condizioni. Per impostazione predefinita (\$1"none\$1"), non viene escluso alcun pacchetto. |
**Fasi di automazione**
Il runbook `AWS-UpdateLinuxAmi` include le seguenti operazioni di automazione, per impostazione predefinita.
**Fase 1: launchInstance (operazione `aws:runInstances`) **
Questa fase avvia un'istanza utilizzando i dati utente di Amazon Elastic Compute Cloud (Amazon EC2) e un ruolo del profilo dell'istanza IAM. I dati utente installano l'SSM Agent appropriato, in base al sistema operativo. L'installazione di SSM Agent consente di utilizzare gli strumenti di Systems Manager, ad esempio Run Command, State Manager e Inventario.
**Fase 2: aggiornamento OSSoftware (`aws:runCommand`azione) **
Questa fase esegue i comandi seguenti sull'istanza avviata:
+ Scarica uno script di aggiornamento da Amazon S3.
+ Esegue uno script facoltativo prima dell'aggiornamento.
+ Aggiorna i pacchetti di distribuzione e il software di Amazon.
+ Esegue uno script facoltativo dopo l'aggiornamento.
Il log di esecuzione viene memorizzato nella cartella /tmp in modo che l'utente possa visualizzarlo in un secondo momento.
Se si desidera aggiornare uno specifico set di pacchetti, è possibile specificare l'elenco di pacchetti utilizzando il parametro `IncludePackages`. Quando tale elenco viene specificato, il sistema tenta di aggiornare solo i pacchetti specificati e le relative dipendenze. Non verrà eseguito alcun altro aggiornamento. Per impostazione predefinita, quando non vengono specificati pacchetti da *includere*, il programma aggiorna tutti i pacchetti disponibili.
Se si desidera escludere dall'aggiornamento uno specifico set di pacchetti, è possibile specificare l'elenco di pacchetti utilizzando il parametro `ExcludePackages`. Quando tale elenco viene specificato, questi pacchetti conservano la propria versione corrente, indipendente dalle altre opzioni specificate. Per impostazione predefinita, quando non sono vengono specificati pacchetti da *escludere*, non verrà escluso alcun pacchetto.
**Fase 3: stopInstance (operazione `aws:changeInstanceState`)**
Questa fase arresta l'istanza aggiornata.
**Fase 4: createImage (operazione `aws:createImage`) **
Questa fase crea una nuova AMI con un nome dettagliato che lo lega all'ID di origine e all'ora di creazione. Ad esempio: «AMIGenerato da EC2 Automation su \$1\$1global:DATE\$1time\$1\$1 da \$1\$1\$1SourceAmiId\$1» dove DATE\$1TIME e SourceID rappresentano le variabili di automazione.
**Fase 5: terminateInstance (operazione `aws:changeInstanceState`) **
Questa fase esegue la pulizia dell'automazione mediante l'arresto dell'istanza in esecuzione.
**Output**
L'automazione restituisce il nuovo ID dell'AMI come output.
**Nota**
Per impostazione predefinita, quando il servizio di automazione esegue il runbook `AWS-UpdateLinuxAmi`, il sistema crea un'istanza temporanea nel VPC predefinito (172.30.0.0/16). Se il VPC predefinito è stato eliminato, verrà restituito l'errore seguente:
`VPC not defined 400`
Per risolvere questo problema, è necessario creare una copia del runbook `AWS-UpdateLinuxAmi` e specificare un ID di sottorete. Per ulteriori informazioni, consulta [VPC non definito 400](automation-troubleshooting.md#automation-trbl-common-vpc).
**Per creare un'AMI con patch applicate utilizzando il servizio di automazione (AWS Systems Manager)**
1. Apri la console all'indirizzo. AWS Systems Manager [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)
1. Nel pannello di navigazione, scegli **Automazione**.
1. Scegli **Esegui automazione**.
1. Nell'elenco **Automation document (Documento di automazione)** scegliere `AWS-UpdateLinuxAmi`.
1. Nella sezione **Dettagli del documento**, verifica che l'opzione **Versione del documento** sia impostata su **Versione predefinita al runtime**.
1. Scegliere **Next (Successivo)**.
1. Nella sezione **Execution Mode (Modalità esecuzione)**, scegliere **Simple Execution (Esecuzione semplice)**.
1. Nella sezione **Input parameters (Inserisci parametri)** inserire le informazioni raccolte nella sezione **Before you begin (Prima di iniziare)**.
1. Scegliere **Execute (Esegui)**. La console visualizza lo stato dell'esecuzione del servizio di automazione.
Al termine dell'automazione, avviare un'istanza di test dall'AMI aggiornata per verificare le modifiche.
**Nota**
Se una fase qualsiasi dell'automazione ha esito negativo, le informazioni sul malfunzionamento vengono elencate nella pagina **Automation Executions (Esecuzioni di automazioni)**. L'automazione è stata progettata per terminare l'istanza temporanea dopo il corretto completamento di tutti i processi. Se una fase ha esito negativo, il sistema potrebbe non terminare l'istanza. Pertanto, se una fase ha esito negativo, terminare manualmente l'istanza temporanea.
## Aggiornamento di un'AMI Linux (AWS CLI)
Questa procedura dettagliata di AWS Systems Manager automazione mostra come utilizzare il `AWS-UpdateLinuxAmi` runbook AWS Command Line Interface (AWS CLI) e Systems Manager per applicare automaticamente patch a Linux Amazon Machine Image (AMI) con le versioni più recenti dei pacchetti specificati. L'automazione è uno strumento di AWS Systems Manager. Il runbook `AWS-UpdateLinuxAmi` automatizza l'installazione anche di altri pacchetti e configurazioni specifici del sito. È possibile aggiornare un'ampia gamma di distribuzioni Linux utilizzando questa procedura guidata, tra cui Ubuntu Server, Red Hat Enterprise Linux (RHEL) oppure Amazon Linux AMIs. Per un elenco completo delle versioni Linux supportate, consulta [Prerequisiti di Patch Manager](patch-manager-prerequisites.md).
Il runbook `AWS-UpdateLinuxAmi` permette di automatizzare i processi di manutenzione delle immagini senza dover creare il runbook in JSON o YAML. È possibile utilizzare il runbook `AWS-UpdateLinuxAmi` per eseguire i tipi di processi seguenti.
+ Aggiornamento di tutti i pacchetti di distribuzione e del software Amazon su Amazon Linux, RHEL o Ubuntu Server Amazon Machine Image (AMI). Questo è il comportamento predefinito del runbook.
+ Installa AWS Systems Manager SSM Agent su un'immagine esistente per abilitare le funzionalità di Systems Manager, come l'esecuzione di comandi remoti utilizzando AWS Systems Manager Run Command o la raccolta dell'inventario software utilizzando Inventory.
+ Installazione di pacchetti software aggiuntivi.
**Prima di iniziare**
Prima di iniziare a lavorare con i runbook, configurate i ruoli e, facoltativamente, EventBridge per l'automazione. Per ulteriori informazioni, consulta [Configurazione del servizio di automazione](automation-setup.md). Questa procedura dettagliata richiede inoltre di specificare il nome di un profilo di istanza AWS Identity and Access Management (IAM). Per ulteriori informazioni sulla creazione di un profilo dell'istanza IAM, consulta la pagina [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md).
Il runbook `AWS-UpdateLinuxAmi` accetta i parametri di input seguenti.
****
| Parametro | Tipo | Description |
| --- | --- | --- |
| SourceAmiId | Stringa | (Obbligatorio) L'ID origine di AMI. Puoi fare riferimento automaticamente all'ID più recente di un Amazon EC2 AMI per Linux utilizzando un parametro AWS Systems Manager Parameter Store *pubblico*. Per ulteriori informazioni, consulta [Query per l'AMI IDs utilizzo più recente di Amazon Linux AWS Systems ManagerParameter Store](https://aws.amazon.com/blogs/compute/query-for-the-latest-amazon-linux-ami-ids-using-aws-systems-manager-parameter-store/). |
| IamInstanceProfileName | Stringa | (Obbligatorio) Il nome del ruolo del profilo dell'istanza IAM creato in [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md). Il ruolo del profilo dell'istanza concede le autorizzazioni al servizio di automazione per eseguire operazioni sulle istanze, ad esempio l'esecuzione di comandi o l'avvio e l'arresto dei servizi. Il runbook utilizza solo il nome del ruolo del profilo dell'istanza. |
| AutomationAssumeRole | Stringa | (Obbligatorio) Nome del ruolo di servizio IAM creato in [Configurazione del servizio di automazione](automation-setup.md). Il ruolo di servizio (definito anche ruolo presunto) concede l'autorizzazione al servizio di automazione di assumere il ruolo IAM e di eseguire operazioni a nome dell'utente. Ad esempio, il ruolo di servizio permette al servizio di automazione di creare una nuova AMI quando viene eseguita l'operazione `aws:createImage` in un runbook. Per questo parametro, è necessario specificare l'ARN completo. |
| TargetAmiName | Stringa | (Facoltativo) Nome della nuova AMI dopo la creazione. Il nome predefinito è una stringa generata dal sistema contenente l'ID dell'AMI di origine e la data/ora di creazione. |
| InstanceType | Stringa | (Facoltativo) Tipo di istanza da avviare come host del workspace. I tipi di istanza variano in base alla regione. Il tipo predefinito è t2.micro. |
| PreUpdateScript | Stringa | (Facoltativo) URL di uno script da eseguire prima dell'applicazione degli aggiornamenti. L'impostazione predefinita (\$1"none\$1") non prevede l'esecuzione di uno script. |
| PostUpdateScript | Stringa | (Facoltativo) URL di uno script da eseguire dopo l'applicazione degli aggiornamenti ai pacchetti. L'impostazione predefinita (\$1"none\$1") non prevede l'esecuzione di uno script. |
| IncludePackages | Stringa | (Facoltativo) Vengono aggiornati solo i pacchetti specificati. Per impostazione predefinita (\$1"all\$1"), vengono applicati tutti gli aggiornamenti disponibili. |
| ExcludePackages | Stringa | (Facoltativo) Nomi dei pacchetti da non aggiornare, in tutte le condizioni. Per impostazione predefinita (\$1"none\$1"), non viene escluso alcun pacchetto. |
**Fasi di automazione**
Per impostazione predefinita, il runbook `AWS-UpdateLinuxAmi` include le seguenti fasi.
**Fase 1: launchInstance (operazione `aws:runInstances`) **
Questo passaggio avvia un'istanza utilizzando i dati utente di Amazon Elastic Compute Cloud EC2 (Amazon) e un ruolo di profilo dell'istanza IAM. I dati utente installano l'SSM Agent appropriato, in base al sistema operativo. L'installazione di SSM Agent consente di utilizzare gli strumenti di Systems Manager, ad esempio Run Command, State Manager e Inventario.
**Fase 2: aggiornamento OSSoftware (`aws:runCommand`azione) **
Questa fase esegue i comandi seguenti sull'istanza avviata:
+ Scarica uno script di aggiornamento da Amazon Simple Storage Service (Amazon S3).
+ Esegue uno script facoltativo prima dell'aggiornamento.
+ Aggiorna i pacchetti di distribuzione e il software di Amazon.
+ Esegue uno script facoltativo dopo l'aggiornamento.
Il log di esecuzione viene memorizzato nella cartella /tmp in modo che l'utente possa visualizzarlo in un secondo momento.
Se si desidera aggiornare uno specifico set di pacchetti, è possibile specificare l'elenco di pacchetti utilizzando il parametro `IncludePackages`. Quando tale elenco viene specificato, il sistema tenta di aggiornare solo i pacchetti specificati e le relative dipendenze. Non verrà eseguito alcun altro aggiornamento. Per impostazione predefinita, quando non vengono specificati pacchetti da *includere*, il programma aggiorna tutti i pacchetti disponibili.
Se si desidera escludere dall'aggiornamento uno specifico set di pacchetti, è possibile specificare l'elenco di pacchetti utilizzando il parametro `ExcludePackages`. Quando tale elenco viene specificato, questi pacchetti conservano la propria versione corrente, indipendente dalle altre opzioni specificate. Per impostazione predefinita, quando non sono vengono specificati pacchetti da *escludere*, non verrà escluso alcun pacchetto.
**Fase 3: stopInstance (operazione `aws:changeInstanceState`)**
Questa fase arresta l'istanza aggiornata.
**Fase 4: createImage (operazione `aws:createImage`) **
Questa fase crea una nuova AMI con un nome dettagliato che lo lega all'ID di origine e all'ora di creazione. Ad esempio: «AMI generato dall' EC2 automazione su \$1\$1global:DATE\$1time\$1\$1 da \$1\$1\$1\$1» dove DATE\$1TIME e SourceAmiId SourceID rappresentano le variabili di automazione.
**Fase 5: terminateInstance (operazione `aws:changeInstanceState`) **
Questa fase esegue la pulizia dell'automazione mediante l'arresto dell'istanza in esecuzione.
**Output**
L'automazione restituisce il nuovo ID dell'AMI come output.
**Nota**
Per impostazione predefinita, quando il servizio di automazione esegue il runbook `AWS-UpdateLinuxAmi`, il sistema crea un'istanza temporanea nel VPC predefinito (172.30.0.0/16). Se il VPC predefinito è stato eliminato, verrà restituito l'errore seguente:
`VPC not defined 400`
Per risolvere questo problema, è necessario creare una copia del runbook `AWS-UpdateLinuxAmi` e specificare un ID di sottorete. Per ulteriori informazioni, consulta [VPC non definito 400](automation-troubleshooting.md#automation-trbl-common-vpc).
**Per creare un'AMI con patch applicate utilizzando il servizio di automazione**
1. Installa e configura (), se non l'hai già fatto. AWS Command Line Interface AWS CLI
Per informazioni, consulta la pagina [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Eseguire il comando seguente per eseguire il runbook `AWS-UpdateLinuxAmi`. Sostituisci ogni *example resource placeholder* con le tue informazioni.
```
aws ssm start-automation-execution \
--document-name "AWS-UpdateLinuxAmi" \
--parameters \
SourceAmiId=AMI ID, \
IamInstanceProfileName=IAM instance profile, \
AutomationAssumeRole='arn:aws:iam::{{global:ACCOUNT_ID}}:role/AutomationServiceRole'
```
Il comando restituisce un ID di esecuzione. Copia questo ID negli appunti. L'ID può essere utilizzato per visualizzare lo stato dell'automazione.
```
{
"AutomationExecutionId": "automation execution ID"
}
```
1. Per visualizzare l'automazione utilizzando il AWS CLI, esegui il seguente comando:
```
aws ssm describe-automation-executions
```
1. Eseguire il comando seguente per visualizzare i dettagli relativi al progresso dell'automazione. Sostituiscila *automation execution ID* con le tue informazioni.
```
aws ssm get-automation-execution --automation-execution-id automation execution ID
```
Il completamento del processo di aggiornamento può richiedere 30 minuti o un intervallo maggiore.
**Nota**
È inoltre possibile monitorare lo stato dell'automazione nella console. Nell'elenco, scegliere l'automazione appena eseguita e quindi scegliere la scheda **Steps (Fasi)**. In questa scheda è riportato lo stato delle operazioni dell'automazione.
Al termine dell'automazione, avviare un'istanza di test dall'AMI aggiornata per verificare le modifiche.
**Nota**
Se una fase qualsiasi dell'automazione ha esito negativo, le informazioni sul malfunzionamento vengono elencate nella pagina **Automation Executions (Esecuzioni di automazioni)**. L'automazione è stata progettata per terminare l'istanza temporanea dopo il corretto completamento di tutti i processi. Se una fase ha esito negativo, il sistema potrebbe non terminare l'istanza. Pertanto, se una fase ha esito negativo, terminare manualmente l'istanza temporanea.
# Aggiornamento di un'Windows Server AMI
Il runbook `AWS-UpdateWindowsAmi` consente di automatizzare i processi di manutenzione delle immagini sull'Amazon Machine Image (AMI) di Amazon Windows senza dover creare il runbook in formato JSON o YAML. Questo runbook è supportato per Windows Server 2008 R2 o versioni successive. È possibile utilizzare il runbook `AWS-UpdateWindowsAmi` per eseguire i tipi di processi seguenti.
+ Installazione di tutti gli aggiornamenti di Windows e aggiornamento del software Amazon (comportamento predefinito).
+ Installazione di aggiornamenti di Windows specifici e aggiornamento del software Amazon.
+ Personalizzazione di un'AMI tramite script.
**Prima di iniziare**
Prima di iniziare a lavorare con i runbook, [configurare i ruoli per il servizio di automazione](automation-setup-iam.md) per aggiungere una policy `iam:PassRole` che fa riferimento all'ARN del profilo dell'istanza a cui si desidera concedere l'accesso. Facoltativamente, configura Amazon EventBridge for Automation, uno strumento in AWS Systems Manager. Per ulteriori informazioni, consulta [Configurazione del servizio di automazione](automation-setup.md). Questa procedura dettagliata richiede anche di specificare il nome di un profilo di istanza AWS Identity and Access Management (IAM). Per ulteriori informazioni sulla creazione di un profilo dell'istanza IAM, consulta la pagina [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md).
**Nota**
Gli aggiornamenti di AWS Systems Manager SSM Agent sono in genere distribuiti in regioni diverse in momenti diversi. Quando personalizzi o aggiorni un'AMI, usa solo il codice sorgente AMIs pubblicato per la regione in cui lavori. Questo assicura di utilizzare la versione più recente di SSM Agent rilasciato per tale regione e pertanto di evitare problemi di compatibilità.
Il runbook `AWS-UpdateWindowsAmi` accetta i parametri di input seguenti.
****
| Parametro | Tipo | Description |
| --- | --- | --- |
| SourceAmiId | Stringa | (Obbligatorio) L'ID origine di AMI. È possibile fare automaticamente riferimento alla versione più recente di ID dell'AMI di Windows Server utilizzando un parametro *pubblico* di Parameter Store di Systems Manager. Per ulteriori informazioni, consulta [Query for the latest Windows AMI IDs using AWS Systems ManagerParameter Store](https://aws.amazon.com/blogs/mt/query-for-the-latest-windows-ami-using-systems-manager-parameter-store/). |
| SubnetId | Stringa | (Facoltativo) La sottorete in cui si desidera avviare l'istanza temporanea. Se è stato eliminato il VPC predefinito, è necessario specificare un valore per questo parametro. |
| IamInstanceProfileName | Stringa | (Obbligatorio) Il nome del ruolo del profilo dell'istanza IAM creato in [Configurazione delle autorizzazioni dell'istanza richieste per Systems Manager](setup-instance-permissions.md). Il ruolo del profilo dell'istanza concede le autorizzazioni al servizio di automazione per eseguire operazioni sulle istanze, ad esempio l'esecuzione di comandi o l'avvio e l'arresto dei servizi. Il runbook utilizza solo il nome del ruolo del profilo dell'istanza. |
| AutomationAssumeRole | Stringa | (Obbligatorio) Nome del ruolo di servizio IAM creato in [Configurazione del servizio di automazione](automation-setup.md). Il ruolo di servizio (definito anche ruolo presunto) concede l'autorizzazione al servizio di automazione di assumere il ruolo IAM e di eseguire operazioni a nome dell'utente. Ad esempio, il ruolo di servizio permette al servizio di automazione di creare una nuova AMI quando viene eseguita l'operazione `aws:createImage` in un runbook. Per questo parametro, è necessario specificare l'ARN completo. |
| TargetAmiName | Stringa | (Facoltativo) Nome della nuova AMI dopo la creazione. Il nome predefinito è una stringa generata dal sistema contenente l'ID dell'AMI di origine e la data/ora di creazione. |
| InstanceType | Stringa | (Facoltativo) Tipo di istanza da avviare come host del workspace. I tipi di istanza variano in base alla regione. Il tipo predefinito è t2.medium. |
| PreUpdateScript | Stringa | (Facoltativo) Script da eseguire prima di aggiornare l' AMI. Inserisci uno script come parametro nel runbook oppure al runtime. |
| PostUpdateScript | Stringa | (Facoltativo) Script da eseguire dopo l'aggiornamento dell'AMI. Inserisci uno script come parametro nel runbook oppure al runtime. |
| IncludeKbs | Stringa | (Facoltativo) Specificare uno o più articoli della Microsoft Knowledge Base (KB) IDs da includere. È possibile installarne più di IDs uno utilizzando valori separati da virgole. Formati validi: KB9876543 o 9876543. |
| ExcludeKbs | Stringa | (Facoltativo) Specificare uno o più articoli della Microsoft Knowledge Base (KB) IDs da escludere. È possibile escluderne più di IDs uno utilizzando valori separati da virgole. Formati validi: KB9876543 o 9876543. |
| Categories | Stringa | (Facoltativo) Specificare una o più categorie di aggiornamento. È possibile filtrare le categorie utilizzando valori separati da virgole. Opzioni: Critical Update, Security Update, Definition Update, Update Rollup, Service Pack, Tool, Update o Driver. I formati validi includono una singola voce, ad esempio: Critical Update. In alternativa, è possibile specificare un elenco di valori separati da virgole: Critical Update,Security Update,Definition Update. |
| SeverityLevels | Stringa | (Facoltativo) Specificare uno o più livelli di gravità MSRC associati a un aggiornamento. È possibile filtrare i livello di gravità utilizzando valori separati da virgole. Opzioni: Critical, Important, Low, Moderate o Unspecified. I formati validi includono una singola voce, ad esempio: Critical. In alternativa, è possibile specificare un elenco di valori separati da virgole: Critical,Important,Low. |
**Fasi di automazione**
Per impostazione predefinita, il runbook `AWS-UpdateWindowsAmi` include le seguenti fasi.
**Fase 1: launchInstance (operazione `aws:runInstances`)**
Questa fase avvia un'istanza con un ruolo del profilo dell'istanza IAM dal parametro `SourceAmiID` specificato.
**Fase 2: runPreUpdate Script (`aws:runCommand`azione)**
Questa fase consente di specificare uno script come stringa che viene eseguita prima dell'installazione degli aggiornamenti.
**Passaggio 3: aggiorna EC2 Config (`aws:runCommand`azione)**
Questo passaggio utilizza il `AWS-InstallPowerShellModule` runbook per scaricare un modulo AWS pubblico PowerShell . Systems Manager verifica l'integrità del modulo utilizzando un hash SHA-256. Systems Manager controlla quindi il sistema operativo per determinare se aggiornare EC2 Config o EC2 Launch. EC2Config viene eseguito su Windows Server 2008 R2 tramite Windows Server 2012 R2. EC2Launch viene eseguito su Windows Server 2016.
**Fase 4: aggiornamento SSMAgent (`aws:runCommand`azione)**
Questa fase aggiorna SSM Agent utilizzando il runbook `AWS-UpdateSSMAgent`.
**Fase 5: aggiornamento AWSPVDriver (`aws:runCommand`azione)**
Questo passaggio aggiorna i driver AWS PV utilizzando il `AWS-ConfigureAWSPackage` runbook.
**Fase 6: updateAwsEna NetworkDriver (azione) `aws:runCommand`**
Questo passaggio aggiorna i driver AWS ENA Network utilizzando il `AWS-ConfigureAWSPackage` runbook.
**Fase 7: installWindowsUpdates (`aws:runCommand`azione) **
Questa fase installa gli aggiornamenti di Windows utilizzando il runbook `AWS-InstallWindowsUpdates`. Per impostazione predefinita, Systems Manager cerca e installa tutti gli aggiornamenti mancanti. È possibile modificare il comportamento predefinito specificando uno dei parametri seguenti: `IncludeKbs`, `ExcludeKbs`, `Categories` o `SeverityLevels`.
**Fase 8: runPostUpdate Script (`aws:runCommand`azione)**
Questa fase consente di specificare uno script come stringa che viene eseguita dopo l'installazione degli aggiornamenti.
**Fase 9: runSysprepGeneralize (`aws:runCommand`azione) **
Questo passaggio utilizza il `AWS-InstallPowerShellModule` runbook per scaricare un PowerShell modulo AWS pubblico. Systems Manager verifica l'integrità del modulo utilizzando un hash SHA-256. Systems Manager esegue quindi sysprep utilizzando metodi AWS supportati per EC2 Launch (Windows Server 2016) o EC2 Config (da Windows Server 2008 R2 a 2012 R2).
**Fase 10: stopInstance (operazione `aws:changeInstanceState`) **
Questa fase arresta l'istanza aggiornata.
**Fase 11: createImage (operazione `aws:createImage`) **
Questa fase crea una nuova AMI con un nome dettagliato che lo lega all'ID di origine e all'ora di creazione. Ad esempio: «AMI generata da EC2 Automation su \$1\$1global:DATE\$1time\$1\$1 da \$1\$1\$1SourceAmiId\$1» dove DATE\$1TIME e SourceID rappresentano le variabili di automazione.
**Fase 12: (azione) TerminateInstance `aws:changeInstanceState` **
Questa fase esegue la pulizia dell'automazione mediante l'arresto dell'istanza in esecuzione.
**Output**
Questa sezione consente di definire gli output delle varie fasi o dei vari valori di qualsiasi parametro come l'output di automazione. Per impostazione predefinita, l'output è l'ID dell'AMI aggiornata di Windows creata dall'automazione.
**Nota**
Per impostazione predefinita, quando il servizio di automazione esegue il runbook `AWS-UpdateWindowsAmi` e crea un'istanza temporanea, il sistema usa il VPC predefinito (172.30.0.0/16). Se il VPC predefinito è stato eliminato, verrà restituito l'errore seguente:
VPC non definito 400
Per risolvere questo problema, è necessario creare una copia del runbook `AWS-UpdateWindowsAmi` e specificare un ID di sottorete. Per ulteriori informazioni, consulta [VPC non definito 400](automation-troubleshooting.md#automation-trbl-common-vpc).
**Per creare un'AMI Windows con patch applicate utilizzando il servizio di automazione**
1. Installa e configura AWS Command Line Interface (AWS CLI), se non l'hai già fatto.
Per informazioni, consulta la pagina [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Eseguire il comando seguente per eseguire il runbook `AWS-UpdateWindowsAmi`. Sostituisci ogni *example resource placeholder* con le tue informazioni. Il comando di esempio seguente utilizza un'AMI recente di Amazon EC2 per ridurre il numero di patch da applicare. Se si esegue il comando più di una volta, è necessario specificare un valore univoco per `targetAMIname`. I nomi per l'AMI devono essere univoci.
```
aws ssm start-automation-execution \
--document-name="AWS-UpdateWindowsAmi" \
--parameters SourceAmiId='AMI ID',IamInstanceProfileName='IAM instance profile',AutomationAssumeRole='arn:aws:iam::{{global:ACCOUNT_ID}}:role/AutomationServiceRole'
```
Il comando restituisce un ID di esecuzione. Copia questo ID negli appunti. L'ID può essere utilizzato per visualizzare lo stato dell'automazione.
```
{
"AutomationExecutionId": "automation execution ID"
}
```
1. Per visualizzare l'automazione utilizzando il AWS CLI, esegui il seguente comando:
```
aws ssm describe-automation-executions
```
1. Eseguire il comando seguente per visualizzare i dettagli relativi al progresso dell'automazione.
```
aws ssm get-automation-execution
--automation-execution-id automation execution ID
```
**Nota**
A seconda del numero di patch applicate, il processo di applicazione delle patch di Windows eseguito in questa automazione di esempio può richiedere 30 minuti o più.
# Aggiorna un golden AMI usando Automation AWS Lambda, e Parameter Store
L'esempio seguente utilizza il modello in cui un'organizzazione gestisce e periodicamente applica patch ad AMIs di proprietà anziché crearle da AMIs di Amazon Elastic Compute Cloud (Amazon EC2).
*La procedura seguente mostra come applicare automaticamente le patch del sistema operativo (OS) a un sistema AMI che è già considerato la più recente up-to-date o la più recente.* AMI Nell'esempio, il valore predefinito del parametro `SourceAmiId` è definito da un AWS Systems Manager Parameter Store parametro chiamato`latestAmi`. Il valore di `latestAmi` viene aggiornato da una AWS Lambda funzione richiamata alla fine dell'automazione. Come risultato di questo processo di automazione, il tempo e l'impegno dedicati all'applicazione delle patch AMIs sono ridotti al minimo perché l'applicazione delle patch viene sempre applicata nella maggior parte dei casi. up-to-date AMI Parameter Storee l'automazione sono strumenti di. AWS Systems Manager
**Prima di iniziare**
Configura i ruoli di automazione e, facoltativamente, Amazon EventBridge for Automation. Per ulteriori informazioni, consulta [Configurazione del servizio di automazione](automation-setup.md).
**Topics**
+ [Processo 1: creazione di un parametro nel Parameter Store di Systems Manager](#create-parameter-ami)
+ [Attività 2: creare un ruolo IAM per AWS Lambda](#create-lambda-role)
+ [Attività 3: Creare una AWS Lambda funzione](#create-lambda-function)
+ [Processo 4: creazione di un runbook e applicazione di patch all'AMI](#create-custom-ami-update-runbook)
## Processo 1: creazione di un parametro nel Parameter Store di Systems Manager
In Parameter Store creare un parametro di stringa che utilizza le seguente informazioni:
+ **Nome (Nome)**: `latestAmi`.
+ **Valore**: Un ID AMI. Ad esempio: ` ami-188d6e0e`.
Per informazioni su come creare un parametro di stringa di Parameter Store, consulta [Creazione di parametri Parameter Store in Systems Manager](sysman-paramstore-su-create.md).
## Attività 2: creare un ruolo IAM per AWS Lambda
Utilizzare la procedura seguente per creare un ruolo di servizio IAM per AWS Lambda. Queste policy forniscono l'autorizzazione a Lambda per aggiornare il valore del parametro `latestAmi` utilizzando una funzione Lambda e Systems Manager.
**Per creare un ruolo di servizio IAM per Lambda**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione, scegliere **Policies (Policy)** e **Create Policy (Crea policy)**.
1. Scegli la scheda **JSON**.
1. Sostituisci il contenuto predefinito con la seguente policy. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "arn:aws:logs:us-east-1:111122223333:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/lambda/function name:*"
]
}
]
}
```
------
1. Scegli **Successivo: Tag**.
1. (Facoltativo) Aggiungere una o più coppie tag chiave-valore per organizzare, monitorare o controllare l'accesso per questa policy.
1. Scegli **Prossimo: Rivedi**.
1. Nella pagina **Rivedi policy**, per l'opzione **Nome** specifica un nome per la policy inline, ad esempio **amiLambda**.
1. Scegli **Crea policy**.
1. Ripetere le fasi 2 e 3.
1. Quindi incollare la policy seguente. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ssm:PutParameter",
"Resource": "arn:aws:ssm:us-east-1:111122223333:parameter/latestAmi"
},
{
"Effect": "Allow",
"Action": "ssm:DescribeParameters",
"Resource": "*"
}
]
}
```
------
1. Scegli **Successivo: Tag**.
1. (Facoltativo) Aggiungere una o più coppie tag chiave-valore per organizzare, monitorare o controllare l'accesso per questa policy.
1. Scegli **Prossimo: Rivedi**.
1. Nella pagina **Rivedi policy**, per l'opzione **Nome** specifica un nome per la policy inline, ad esempio **amiParameter**.
1. Scegli **Crea policy**.
1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**.
1. In **Caso d'uso**, scegli **Lambda**, quindi scegli **Successivo**.
1. Nella pagina **Collega autorizzazioni**, utilizza il campo **Cerca** per individuare le due policy create in precedenza.
1. Seleziona la casella di controllo accanto alle policy, quindi scegli **Successivo: Tag**.
1. Per **Role name (Nome ruolo)**, inserire un nome per il nuovo ruolo, ad esempio **lambda-ssm-role** o un altro nome che preferisci.
**Nota**
Poiché varie entità possono fare riferimento al ruolo, non è possibile modificare il nome del ruolo dopo averlo creato.
1. (Facoltativo) Aggiungi una o più coppie di tag chiave-valore per organizzare, monitorare o controllare l'accesso per questo ruolo, quindi scegli **Crea ruolo**.
## Attività 3: Creare una AWS Lambda funzione
Utilizzare la procedura seguente per creare una funzione Lambda che aggiorna automaticamente il valore del parametro `latestAmi`.
**Come creare una funzione Lambda**
1. Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Scegli **Crea funzione**.
1. Nella pagina **Create function (Crea funzione)**, scegliere **Author from scratch (Crea da zero)**.
1. Nel campo **Function name (Nome funzione)**, immettere **Automation-UpdateSsmParam**.
1. Per **Runtime**, scegli **Python 3.11**.
1. Per **Architettura**, seleziona il tipo di processore del computer che Lambda deve utilizzare per eseguire la funzione, **x86\$164** o **arm64**.
1. Nella sezione **Autorizzazioni**, espandi **Modifica ruolo di esecuzione predefinito**.
1. Scegli **Utilizza un ruolo esistente**, quindi scegli il ruolo di servizio creato per Lambda nell'attività 2.
1. Scegli **Crea funzione**.
1. Nella sezione **Origine codice**, nella scheda **lambda\$1function**, elimina il codice precompilato nel campo, quindi incolla il seguente codice di esempio.
```
from __future__ import print_function
import json
import boto3
print('Loading function')
#Updates an SSM parameter
#Expects parameterName, parameterValue
def lambda_handler(event, context):
print("Received event: " + json.dumps(event, indent=2))
# get SSM client
client = boto3.client('ssm')
#confirm parameter exists before updating it
response = client.describe_parameters(
Filters=[
{
'Key': 'Name',
'Values': [ event['parameterName'] ]
},
]
)
if not response['Parameters']:
print('No such parameter')
return 'SSM parameter not found.'
#if parameter has a Description field, update it PLUS the Value
if 'Description' in response['Parameters'][0]:
description = response['Parameters'][0]['Description']
response = client.put_parameter(
Name=event['parameterName'],
Value=event['parameterValue'],
Description=description,
Type='String',
Overwrite=True
)
#otherwise just update Value
else:
response = client.put_parameter(
Name=event['parameterName'],
Value=event['parameterValue'],
Type='String',
Overwrite=True
)
responseString = 'Updated parameter %s with value %s.' % (event['parameterName'], event['parameterValue'])
return responseString
```
1. Scegli **File, Salva**.
1. Per testare la funzione Lambda, dal menu **Test** scegli **Configura evento di test**.
1. Nel campo **Event name (Nome evento)**, inserire un nome per l'evento di test, ad esempio **MyTestEvent**.
1. Sostituire il testo esistente con il seguente esempio JSON. *AMI ID*Sostituiscilo con le tue informazioni per impostare il `latestAmi` valore del parametro.
```
{
"parameterName":"latestAmi",
"parameterValue":"AMI ID"
}
```
1. Scegli **Save** (Salva).
1. Scegliere **Test** per testare la funzione. Nella scheda **Risultato dell'esecuzione**, lo stato deve essere riportato come **Completato**, insieme ad altri dettagli sull'aggiornamento.
## Processo 4: creazione di un runbook e applicazione di patch all'AMI
Utilizzare la procedura seguente per creare ed eseguire un runbook che applica patch all'AMI specificata per il parametro **latestAmi**. Al termine dell'automazione, il valore del parametro **latestAmi** viene aggiornato con l'ID dell'AMI con patch applicate. Le automazioni successive utilizzano l'AMI creata dall'esecuzione precedente.
**Per creare ed eseguire il runbook**
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. Per **Crea documento**, scegli **Automazione**.
1. In **Nome**, inserisci **UpdateMyLatestWindowsAmi**.
1. Scegliere la scheda **Editor**, quindi **Edit (Modifica)**.
1. Scegli **OK** quando richiesto.
1. Nel campo **Editor di documenti**, sostituisci il contenuto predefinito con il seguente runbook di esempio YAML.
```
---
description: Systems Manager Automation Demo - Patch AMI and Update ASG
schemaVersion: '0.3'
assumeRole: '{{ AutomationAssumeRole }}'
parameters:
AutomationAssumeRole:
type: String
description: '(Required) The ARN of the role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to execute this document.'
default: ''
SourceAMI:
type: String
description: The ID of the AMI you want to patch.
default: '{{ ssm:latestAmi }}'
SubnetId:
type: String
description: The ID of the subnet where the instance from the SourceAMI parameter is launched.
SecurityGroupIds:
type: StringList
description: The IDs of the security groups to associate with the instance that's launched from the SourceAMI parameter.
NewAMI:
type: String
description: The name of of newly patched AMI.
default: 'patchedAMI-{{global:DATE_TIME}}'
InstanceProfile:
type: String
description: The name of the IAM instance profile you want the source instance to use.
SnapshotId:
type: String
description: (Optional) The snapshot ID to use to retrieve a patch baseline snapshot.
default: ''
RebootOption:
type: String
description: '(Optional) Reboot behavior after a patch Install operation. If you choose NoReboot and patches are installed, the instance is marked as non-compliant until a subsequent reboot and scan.'
allowedValues:
- NoReboot
- RebootIfNeeded
default: RebootIfNeeded
Operation:
type: String
description: (Optional) The update or configuration to perform on the instance. The system checks if patches specified in the patch baseline are installed on the instance. The install operation installs patches missing from the baseline.
allowedValues:
- Install
- Scan
default: Install
mainSteps:
- name: startInstances
action: 'aws:runInstances'
timeoutSeconds: 1200
maxAttempts: 1
onFailure: Abort
inputs:
ImageId: '{{ SourceAMI }}'
InstanceType: m5.large
MinInstanceCount: 1
MaxInstanceCount: 1
IamInstanceProfileName: '{{ InstanceProfile }}'
SubnetId: '{{ SubnetId }}'
SecurityGroupIds: '{{ SecurityGroupIds }}'
- name: verifyInstanceManaged
action: 'aws:waitForAwsResourceProperty'
timeoutSeconds: 600
inputs:
Service: ssm
Api: DescribeInstanceInformation
InstanceInformationFilterList:
- key: InstanceIds
valueSet:
- '{{ startInstances.InstanceIds }}'
PropertySelector: '$.InstanceInformationList[0].PingStatus'
DesiredValues:
- Online
onFailure: 'step:terminateInstance'
- name: installPatches
action: 'aws:runCommand'
timeoutSeconds: 7200
onFailure: Abort
inputs:
DocumentName: AWS-RunPatchBaseline
Parameters:
SnapshotId: '{{SnapshotId}}'
RebootOption: '{{RebootOption}}'
Operation: '{{Operation}}'
InstanceIds:
- '{{ startInstances.InstanceIds }}'
- name: stopInstance
action: 'aws:changeInstanceState'
maxAttempts: 1
onFailure: Continue
inputs:
InstanceIds:
- '{{ startInstances.InstanceIds }}'
DesiredState: stopped
- name: createImage
action: 'aws:createImage'
maxAttempts: 1
onFailure: Continue
inputs:
InstanceId: '{{ startInstances.InstanceIds }}'
ImageName: '{{ NewAMI }}'
NoReboot: false
ImageDescription: Patched AMI created by Automation
- name: terminateInstance
action: 'aws:changeInstanceState'
maxAttempts: 1
onFailure: Continue
inputs:
InstanceIds:
- '{{ startInstances.InstanceIds }}'
DesiredState: terminated
- name: updateSsmParam
action: aws:invokeLambdaFunction
timeoutSeconds: 1200
maxAttempts: 1
onFailure: Abort
inputs:
FunctionName: Automation-UpdateSsmParam
Payload: '{"parameterName":"latestAmi", "parameterValue":"{{createImage.ImageId}}"}'
outputs:
- createImage.ImageId
```
1. Scegli **Crea automazione**.
1. Nel pannello di navigazione, scegli **Automazione**, quindi **Esegui automazione**.
1. Nella pagina **Choose document (Scegli il documento)**, scegli la scheda **Owned by me (Di mia proprietà)**.
1. Cerca il **UpdateMyLatestWindowsAmi**runbook e seleziona il pulsante nella **UpdateMyLatestWindowsAmi**scheda.
1. Scegli **Next (Successivo)**.
1. Scegliere **Simple execution (Esecuzione semplice)**.
1. Specifica i valori per il parametro di input.
1. Scegliere **Execute (Esegui)**.
1. Una volta completata l'esecuzione, scegliere **Parameter Store** nel pannello di navigazione e confermare che il nuovo valore del parametro `latestAmi` corrisponde al valore restituito dall'automazione. Puoi anche verificare che il nuovo AMI ID corrisponda all'output di Automation nella **AMIs**sezione della console Amazon EC2.
# Aggiornamento delle AMIs tramite automazione e Jenkins
Se la tua organizzazione utilizza Jenkins software in una CI/CD pipeline, puoi aggiungere Automation come fase successiva alla compilazione per preinstallare le versioni delle applicazioni in (). Amazon Machine Images AMIs L'automazione è uno strumento di AWS Systems Manager. È inoltre possibile utilizzare la funzionalità di pianificazione di Jenkins per chiamare il servizio di automazione e creare un piano personalizzato per l'applicazione di patch del sistema operativo (SO).
L'esempio seguente mostra come invocare il servizio di automazione da un server Jenkins in esecuzione on-premises o in Amazon Elastic Compute Cloud (Amazon EC2). Per l'autenticazione, il Jenkins server utilizza AWS credenziali basate su una policy IAM creata nell'esempio e allegata al profilo dell'istanza.
**Nota**
Assicurati di seguire le best practice di sicurezza Jenkins durante la configurazione dell'istanza.
**Prima di iniziare**
Prima di configurare il servizio di automazione con Jenkins, completa le seguenti attività:
+ Completare l'esempio descritto nell'argomento [Aggiorna un golden AMI usando Automation AWS Lambda, e Parameter Store](automation-tutorial-update-patch-golden-ami.md). L'esempio seguente utilizza il **UpdateMyLatestWindowsAmi**runbook creato in quell'esempio.
+ Configurare i ruoli IAM per il servizio di automazione. Systems Manager richiede un ruolo del profilo dell'istanza e un ARN del ruolo di servizio per elaborare le automazioni. Per ulteriori informazioni, consulta [Configurazione del servizio di automazione](automation-setup.md).
**Per creare una policy IAM per il server Jenkins**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione, scegliere **Policies (Policy)** e **Create Policy (Crea policy)**.
1. Scegli la scheda **JSON**.
1. Sostituisci ogni *example resource placeholder* con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ssm:StartAutomationExecution",
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/UpdateMyLatestWindowsAmi",
"arn:aws:ssm:us-east-1:111122223333:automation-execution/*"
]
}
]
}
```
------
1. Scegli **Review policy (Rivedi policy)**.
1. Nella pagina **Review policy (Rivedi policy)**, per l'opzione **Name (Nome)** specificare un nome per la policy inline, ad esempio **JenkinsPolicy**.
1. Scegli **Crea policy**.
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Scegli il profilo dell'istanza collegato al server Jenkins.
1. Nella scheda **Autorizzazioni**, scegli **Aggiungi autorizzazioni**, quindi scegli **Collega policy**.
1. Nella sezione **Altre policy di autorizzazione**, inserisci il nome della policy creata nei passaggi precedenti. Ad esempio, **JenkinsPolicy**.
1. Seleziona la casella di controllo accanto alla policy, quindi scegli **Collega policy**.
Utilizza la seguente procedura per configurarla AWS CLI sul tuo Jenkins server.
**Per configurare il server Jenkins per l'automazione**
1. Collegati al server Jenkins sulla porta 8080 utilizzando il browser preferito per accedere all'interfaccia di gestione.
1. Inserire la password trovata in `/var/lib/jenkins/secrets/initialAdminPassword`. Per visualizzare la password, eseguire il comando seguente.
```
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```
1. Lo script di installazione di Jenkins indirizza alla pagina **Personalizzazione di Jenkins**. Selezionare **Install suggested plugins (Installazione dei plug-in suggeriti)**.
1. Al termine dell'installazione, scegli **Credenziali amministratore**, seleziona **Salva credenziali** e successivamente **Inizia a usare Jenkins**.
1. Nel pannello di navigazione a sinistra, scegli **Gestione di Jenkins** e successivamente seleziona **Gestione dei plug-in**.
1. Scegliere la scheda **Available (Disponibilità)** e quindi inserire **Amazon EC2 plugin**.
1. Selezionare la casella di controllo relativa a **Amazon EC2 plugin** e quindi selezionare **Install without restart (Installazione senza riavvio)**.
1. Al termine dell'installazione, selezionare **Go back to the top page (Torna alla pagina iniziale)**.
1. Scegli **GestisciJenkins**, quindi seleziona **Gestisci nodi e cloud**.
1. Nella sezione **Cloud**, seleziona **Aggiungi un nuovo cloud**, quindi scegli **Amazon EC2**.
1. Inserisci le tue informazioni nei campi rimanenti. Assicurati di selezionare l'opzione **Utilizza il profilo dell'istanza EC2 per ottenere le credenziali**.
Utilizza la procedura seguente per configurare il progetto Jenkins in modo che invochi il servizio di automazione.
**Per configurare il server Jenkins in modo che invochi il servizio di automazione**
1. Apri la console Jenkins nel browser Web.
1. Scegliere il progetto che si desidera configurare con il servizio di automazione, quindi scegliere **Configure (Configura)**.
1. Nella scheda **Build (Compilazione)** scegliere **Add Build Step (Aggiungi fase di compilazione)**.
1. Scegliere **Execute shell (Esegui shell)** o **Execute Windows batch command (Esegui comando batch Windows)** (a seconda del sistema operativo in uso).
1. Nel campo **Comando**, esegui un AWS CLI comando come il seguente. Sostituisci ogni *example resource placeholder* con le tue informazioni.
```
aws ssm start-automation-execution \
--document-name runbook name \
--region Regione AWS of your source AMI \
--parameters runbook parameters
```
Il comando di esempio seguente utilizza il **UpdateMyLatestWindowsAmi**runbook e il parametro Systems Manager `latestAmi` creati in[Aggiorna un golden AMI usando Automation AWS Lambda, e Parameter Store](automation-tutorial-update-patch-golden-ami.md).
```
aws ssm start-automation-execution \
--document-name UpdateMyLatestWindowsAmi \
--parameters \
"sourceAMIid='{{ssm:latestAmi}}'"
--region region
```
In Jenkins, il comando è simile all'esempio illustrato nel seguente screenshot.
![\[Un comando di esempio nel software Jenkins.\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/images/sysman-ami-jenkins2.png)
1. Nel progetto Jenkins, scegli **Crea ora**. Jenkins restituisce un output simile al seguente.
![\[Esempio di output di comando nel software Jenkins.\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/images/sysman-ami-jenkins.png)
# Aggiornamento delle AMIs per i gruppi Auto Scaling
Nell'esempio seguente aggiorna un gruppo Auto Scaling con una nuova AMI con patch applicate. Questo approccio garantisce che le nuove immagini vengano automaticamente rese disponibili nei vari ambienti di calcolo che usano gruppi Auto Scaling.
La fase finale dell'automazione in questo esempio utilizza una funzione Python per creare un nuovo modello di avvio che utilizza la nuova AMI con patch applicate. Quindi il gruppo Auto Scaling è aggiornato per utilizzare il nuovo modello di avvio. In questo tipo di scenario con dimensionamento automatico, gli utenti possono terminare le istanze esistenti nel gruppo Auto Scaling per forzare l'avvio di una nuova istanza che utilizza la nuova immagine. In alternativa, gli utenti possono attendere che siano gli eventi di scalabilità verticale o orizzontale ad avviare le istanze più recenti.
**Prima di iniziare**
Prima di iniziare a utilizzare questo esempio, completare le attività descritte di seguito.
+ Configura i ruoli IAM per Automation, uno strumento in AWS Systems Manager. Systems Manager richiede un ruolo del profilo dell'istanza e un ARN del ruolo di servizio per elaborare le automazioni. Per ulteriori informazioni, consulta [Configurazione del servizio di automazione](automation-setup.md).
## Crea il runbook **Patch AMIAnd UpdateASG**
**Utilizzate la procedura seguente per creare il runbook **Patch AMIAnd UpdateASG che applica le patch** specificate per il AMI parametro SourceAMI.** Il runbook aggiorna anche un gruppo Auto Scaling utilizzando l'AMI con patch applicate più recente.
**Per creare ed eseguire il runbook**
1. [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)Aprire la console all'indirizzo. AWS Systems Manager
1. Nel pannello di navigazione, scegli **Documenti**.
1. Nel menu a disces **Create document (Crea un documento)**, scegliere **Automation (Automazione)**.
1. Nel campo **Name (Nome)**, inserire **PatchAMIAndUpdateASG**.
1. Scegliere la scheda **Editor**, quindi **Edit (Modifica)**.
1. Scegliere **OK** quando richiesto ed eliminare il contenuto nel campo **Document editor (Editor di documenti)**.
1. Nel campo **Document editor (Editor di documenti)** incollare il seguente contenuto del runbook di esempio YAML.
```
---
description: Systems Manager Automation Demo - Patch AMI and Update ASG
schemaVersion: '0.3'
assumeRole: '{{ AutomationAssumeRole }}'
parameters:
AutomationAssumeRole:
type: String
description: '(Required) The ARN of the role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to execute this document.'
default: ''
SourceAMI:
type: String
description: '(Required) The ID of the AMI you want to patch.'
SubnetId:
type: String
description: '(Required) The ID of the subnet where the instance from the SourceAMI parameter is launched.'
SecurityGroupIds:
type: StringList
description: '(Required) The IDs of the security groups to associate with the instance launched from the SourceAMI parameter.'
NewAMI:
type: String
description: '(Optional) The name of of newly patched AMI.'
default: 'patchedAMI-{{global:DATE_TIME}}'
TargetASG:
type: String
description: '(Required) The name of the Auto Scaling group you want to update.'
InstanceProfile:
type: String
description: '(Required) The name of the IAM instance profile you want the source instance to use.'
SnapshotId:
type: String
description: (Optional) The snapshot ID to use to retrieve a patch baseline snapshot.
default: ''
RebootOption:
type: String
description: '(Optional) Reboot behavior after a patch Install operation. If you choose NoReboot and patches are installed, the instance is marked as non-compliant until a subsequent reboot and scan.'
allowedValues:
- NoReboot
- RebootIfNeeded
default: RebootIfNeeded
Operation:
type: String
description: (Optional) The update or configuration to perform on the instance. The system checks if patches specified in the patch baseline are installed on the instance. The install operation installs patches missing from the baseline.
allowedValues:
- Install
- Scan
default: Install
mainSteps:
- name: startInstances
action: 'aws:runInstances'
timeoutSeconds: 1200
maxAttempts: 1
onFailure: Abort
inputs:
ImageId: '{{ SourceAMI }}'
InstanceType: m5.large
MinInstanceCount: 1
MaxInstanceCount: 1
IamInstanceProfileName: '{{ InstanceProfile }}'
SubnetId: '{{ SubnetId }}'
SecurityGroupIds: '{{ SecurityGroupIds }}'
- name: verifyInstanceManaged
action: 'aws:waitForAwsResourceProperty'
timeoutSeconds: 600
inputs:
Service: ssm
Api: DescribeInstanceInformation
InstanceInformationFilterList:
- key: InstanceIds
valueSet:
- '{{ startInstances.InstanceIds }}'
PropertySelector: '$.InstanceInformationList[0].PingStatus'
DesiredValues:
- Online
onFailure: 'step:terminateInstance'
- name: installPatches
action: 'aws:runCommand'
timeoutSeconds: 7200
onFailure: Abort
inputs:
DocumentName: AWS-RunPatchBaseline
Parameters:
SnapshotId: '{{SnapshotId}}'
RebootOption: '{{RebootOption}}'
Operation: '{{Operation}}'
InstanceIds:
- '{{ startInstances.InstanceIds }}'
- name: stopInstance
action: 'aws:changeInstanceState'
maxAttempts: 1
onFailure: Continue
inputs:
InstanceIds:
- '{{ startInstances.InstanceIds }}'
DesiredState: stopped
- name: createImage
action: 'aws:createImage'
maxAttempts: 1
onFailure: Continue
inputs:
InstanceId: '{{ startInstances.InstanceIds }}'
ImageName: '{{ NewAMI }}'
NoReboot: false
ImageDescription: Patched AMI created by Automation
- name: terminateInstance
action: 'aws:changeInstanceState'
maxAttempts: 1
onFailure: Continue
inputs:
InstanceIds:
- '{{ startInstances.InstanceIds }}'
DesiredState: terminated
- name: updateASG
action: 'aws:executeScript'
timeoutSeconds: 300
maxAttempts: 1
onFailure: Abort
inputs:
Runtime: python3.11
Handler: update_asg
InputPayload:
TargetASG: '{{TargetASG}}'
NewAMI: '{{createImage.ImageId}}'
Script: |-
from __future__ import print_function
import datetime
import json
import time
import boto3
# create auto scaling and ec2 client
asg = boto3.client('autoscaling')
ec2 = boto3.client('ec2')
def update_asg(event, context):
print("Received event: " + json.dumps(event, indent=2))
target_asg = event['TargetASG']
new_ami = event['NewAMI']
# get object for the ASG we're going to update, filter by name of target ASG
asg_query = asg.describe_auto_scaling_groups(AutoScalingGroupNames=[target_asg])
if 'AutoScalingGroups' not in asg_query or not asg_query['AutoScalingGroups']:
return 'No ASG found matching the value you specified.'
# gets details of an instance from the ASG that we'll use to model the new launch template after
source_instance_id = asg_query.get('AutoScalingGroups')[0]['Instances'][0]['InstanceId']
instance_properties = ec2.describe_instances(
InstanceIds=[source_instance_id]
)
source_instance = instance_properties['Reservations'][0]['Instances'][0]
# create list of security group IDs
security_groups = []
for group in source_instance['SecurityGroups']:
security_groups.append(group['GroupId'])
# create a list of dictionary objects for block device mappings
mappings = []
for block in source_instance['BlockDeviceMappings']:
volume_query = ec2.describe_volumes(
VolumeIds=[block['Ebs']['VolumeId']]
)
volume_details = volume_query['Volumes']
device_name = block['DeviceName']
volume_size = volume_details[0]['Size']
volume_type = volume_details[0]['VolumeType']
device = {'DeviceName': device_name, 'Ebs': {'VolumeSize': volume_size, 'VolumeType': volume_type}}
mappings.append(device)
# create new launch template using details returned from instance in the ASG and specify the newly patched AMI
time_stamp = time.time()
time_stamp_string = datetime.datetime.fromtimestamp(time_stamp).strftime('%m-%d-%Y_%H-%M-%S')
new_template_name = f'{new_ami}_{time_stamp_string}'
try:
ec2.create_launch_template(
LaunchTemplateName=new_template_name,
LaunchTemplateData={
'BlockDeviceMappings': mappings,
'ImageId': new_ami,
'InstanceType': source_instance['InstanceType'],
'IamInstanceProfile': {
'Arn': source_instance['IamInstanceProfile']['Arn']
},
'KeyName': source_instance['KeyName'],
'SecurityGroupIds': security_groups
}
)
except Exception as e:
return f'Exception caught: {str(e)}'
else:
# update ASG to use new launch template
asg.update_auto_scaling_group(
AutoScalingGroupName=target_asg,
LaunchTemplate={
'LaunchTemplateName': new_template_name
}
)
return f'Updated ASG {target_asg} with new launch template {new_template_name} which uses AMI {new_ami}.'
outputs:
- createImage.ImageId
```
1. Scegli **Crea automazione**.
1. Nel pannello di navigazione, scegli **Automazione**, quindi **Esegui automazione**.
1. Nella pagina **Choose document (Scegli il documento)**, scegli la scheda **Owned by me (Di mia proprietà)**.
1. Cerca il runbook **Patch AMIAnd UpdateASG** e seleziona il pulsante nella scheda **Patch AMIAnd** UpdateASG.
1. Scegli **Next (Successivo)**.
1. Scegliere **Simple execution (Esecuzione semplice)**.
1. Specifica i valori per il parametro di input. Assicurarsi che `SubnetId` e `SecurityGroupIds` da te specificati consentano l'accesso agli endpoint pubblici di Systems Manager o agli endpoint dell'interfaccia per Systems Manager.
1. Scegli **Esegui**.
1. Una volta completata l'automazione, nella console di Amazon EC2 scegli **Dimensionamento automatico**, quindi scegli **Modelli di avvio**. Controllare che il nuovo modello di avvio sia visualizzato e utilizzato dalla nuova AMI.
1. Scegli **Dimensionamento automatico**, quindi scegli **Gruppi Auto Scaling**. Accertati che il gruppo Auto Scaling utilizzi il nuovo modello di avvio.
1. Termina una o più istanze nel gruppo Auto Scaling. Le istanze di sostituzione verranno avviate utilizzando la nuova AMI.
# Utilizzo dei Supporto AWS runbook self-service
Questa sezione descrive come utilizzare alcune delle automazioni self-service create dal team. Supporto AWS Queste automazioni ti aiutano a gestire le tue risorse. AWS
**Support Automation Workflows**
Support Automation Workflows (SAW) sono runbook di automazione scritti e gestiti dal Supporto AWS team. Questi runbook consentono di risolvere i problemi più comuni relativi alle AWS risorse, monitorare e identificare in modo proattivo i problemi di rete, raccogliere e analizzare i log e altro ancora.
I runbook SAW utilizzano il prefisso **`AWSSupport`**. Ad esempio, [https://docs.aws.amazon.com/systems-manager-automation-runbooks/latest/userguide/automation-awssupport-activatewindowswithamazonlicense.html](https://docs.aws.amazon.com/systems-manager-automation-runbooks/latest/userguide/automation-awssupport-activatewindowswithamazonlicense.html).
Inoltre, i clienti con piani di supporto Business Support\$1 e superiori AWS hanno accesso anche ai runbook che utilizzano il **`AWSPremiumSupport`**prefisso. Ad esempio, [https://docs.aws.amazon.com/systems-manager-automation-runbooks/latest/userguide/automation-awspremiumsupport-troubleshootEC2diskusage.html](https://docs.aws.amazon.com/systems-manager-automation-runbooks/latest/userguide/automation-awspremiumsupport-troubleshootEC2diskusage.html).
Per ulteriori informazioni Supporto AWS, consulta [Guida introduttiva](https://docs.aws.amazon.com/awssupport/latest/user/getting-started.html) a. Supporto AWS
**Topics**
+ [Esegui lo strumento EC2 Rescue su istanze irraggiungibili](automation-ec2rescue.md)
+ [Ripristino di password e chiavi SSH sulle istanze EC2](automation-ec2reset.md)
# Esegui lo strumento EC2 Rescue su istanze irraggiungibili
EC2Rescue consente di diagnosticare e risolvere i problemi relativi alle istanze di Amazon Elastic Compute Cloud (Amazon EC2) per Linux e Windows Server. È possibile eseguire lo strumento manualmente, come descritto in [Uso di Rescue per Linux Server e Utilizzo di EC2 EC2 Rescue](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Linux-Server-EC2Rescue.html) [per](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/Windows-Server-EC2Rescue.html) Windows Server. In alternativa, è possibile eseguire lo strumento automaticamente utilizzando il servizio di automazione di Systems Manager e il runbook **`AWSSupport-ExecuteEC2Rescue`**. L'automazione è uno strumento di AWS Systems Manager. Il **`AWSSupport-ExecuteEC2Rescue`**runbook è progettato per eseguire una combinazione di azioni di Systems Manager, CloudFormation azioni e funzioni Lambda che automatizzano i passaggi normalmente necessari per utilizzare Rescue. EC2
È possibile utilizzare il runbook **`AWSSupport-ExecuteEC2Rescue`** per risolvere e potenzialmente correggere i vari tipi di problemi a livello di sistema operativo (SO). Le istanze con volumi root crittografati non sono supportate. Per un elenco completo, consulta i seguenti argomenti:
**Windows**: vedi *Rescue Action* in [Using EC2 Rescue for Windows Server con la](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2rw-cli.html#ec2rw-rescue) riga di comando.
**Linux** e **macOS**: alcuni moduli EC2 Rescue for Linux rilevano e tentano di risolvere i problemi. Per ulteriori informazioni, consulta la documentazione relativa a [https://github.com/awslabs/aws-ec2rescue-linux/tree/master/docs](https://github.com/awslabs/aws-ec2rescue-linux/tree/master/docs) per ciascun modulo su GitHub.
## Come funziona
Risoluzione dei problemi di un'istanza con il servizio di automazione e il runbook **`AWSSupport-ExecuteEC2Rescue`** funziona nel seguente modo:
+ L'utente specifica l'ID dell'istanza non raggiungibile e avvia il runbook.
+ Il sistema crea un VPC temporaneo e quindi esegue una serie di funzioni Lambda per configurare il VPC.
+ Il sistema identifica una sottorete per il VPC temporaneo nella stessa zona di disponibilità dell'istanza originale.
+ Il sistema avvia un'istanza helper temporanea e abilitata per SSM.
+ Il sistema arresta l'istanza originale e crea un backup. Collega quindi il volume root originale all'istanza helper.
+ Il sistema esegue EC2 Rescue sull'istanza helper. Run Command EC2Rescue identifica e tenta di risolvere i problemi sul volume root originale allegato. Al termine, EC2 Rescue ricollega il volume root all'istanza originale.
+ Il sistema riavvia l'istanza originale e termina l'istanza temporanea. Il sistema termina anche il VPC temporaneo e le funzioni Lambda create all'inizio dell'automazione.
## Prima di iniziare
Prima di eseguire la seguente automazione, esegui le seguenti operazioni:
+ Copiare l'ID istanza dell'istanza non raggiungibile. Questo ID verrà specificato nella procedura.
+ Facoltativamente, recuperare l'ID di una sottorete nella stessa zona di disponibilità dell'istanza non raggiungibile. L'istanza EC2 Rescue verrà creata in questa sottorete. Se non specifichi una sottorete, Automation crea un nuovo VPC temporaneo nel tuo. Account AWS Verifica di Account AWS avere almeno un VPC disponibile. Per impostazione predefinita, puoi crearne cinque VPCs in una regione. Se ne hai già creati cinque VPCs nella regione, l'automazione fallisce senza apportare modifiche all'istanza. Per ulteriori informazioni sulle quote di Amazon VPC, consulta l'argomento relativo a [VPC e sottoreti](https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html#vpc-limits-vpcs-subnets) nella *Guida utente Amazon VPC*.
+ Facoltativamente, puoi creare e specificare un ruolo AWS Identity and Access Management (IAM) per l'automazione. Se non si specifica questo ruolo, il servizio di automazione viene eseguito nel contesto dell'utente che ha eseguito l'automazione.
### Concessione delle autorizzazioni `AWSSupport-EC2Rescue` per eseguire operazioni sulle istanze
EC2Rescue necessita dell'autorizzazione per eseguire una serie di azioni sulle istanze durante l'automazione. Queste azioni richiamano i AWS Lambda servizi IAM e Amazon EC2 per tentare in modo sicuro di risolvere i problemi con le istanze. Se disponi di autorizzazioni a livello di amministratore nel tuo e/o Account AWS VPC, potresti essere in grado di eseguire l'automazione senza configurare le autorizzazioni, come descritto in questa sezione. Se non si dispone delle autorizzazioni a livello di amministratore, l'utente corrente o un amministratore deve configurare tali autorizzazioni mediante una delle opzioni riportate di seguito.
+ [Concessione delle autorizzazioni mediante policy IAM](#automation-ec2rescue-access-iam)
+ [Concessione delle autorizzazioni utilizzando un modello CloudFormation](#automation-ec2rescue-access-cfn)
#### Concessione delle autorizzazioni mediante policy IAM
È possibile collegare la seguente policy IAM all'utente, al gruppo o al ruolo come policy inline. In alternativa, è possibile creare una nuova policy gestita IAM e collegarla all'utente, al gruppo o al ruolo. Per ulteriori informazioni sull'aggiunta di una policy inline all'utente, al gruppo o al ruolo, consulta la pagina [Utilizzo delle policy inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html). Per ulteriori informazioni sulla creazione di una nuova policy gestita, consulta la sezione relativa all'[uso di policy gestite](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html).
**Nota**
Se crei una nuova policy gestita da IAM, devi anche allegare la policy gestita di **Amazon SSMAutomation Role** in modo che le tue istanze possano comunicare con l'API Systems Manager.
**Policy IAM per AWSSupport-EC 2Rescue**
*account ID*Sostituiscila con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"lambda:InvokeFunction",
"lambda:DeleteFunction",
"lambda:GetFunction"
],
"Resource": "arn:aws:lambda:*:111122223333:function:AWSSupport-EC2Rescue-*",
"Effect": "Allow"
},
{
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::awssupport-ssm.*/*.template",
"arn:aws:s3:::awssupport-ssm.*/*.zip"
],
"Effect": "Allow"
},
{
"Action": [
"iam:CreateRole",
"iam:CreateInstanceProfile",
"iam:GetRole",
"iam:GetInstanceProfile",
"iam:PutRolePolicy",
"iam:DetachRolePolicy",
"iam:AttachRolePolicy",
"iam:PassRole",
"iam:AddRoleToInstanceProfile",
"iam:RemoveRoleFromInstanceProfile",
"iam:DeleteRole",
"iam:DeleteRolePolicy",
"iam:DeleteInstanceProfile"
],
"Resource": [
"arn:aws:iam::111122223333:role/AWSSupport-EC2Rescue-*",
"arn:aws:iam::111122223333:instance-profile/AWSSupport-EC2Rescue-*"
],
"Effect": "Allow"
},
{
"Action": [
"lambda:CreateFunction",
"ec2:CreateVpc",
"ec2:ModifyVpcAttribute",
"ec2:DeleteVpc",
"ec2:CreateInternetGateway",
"ec2:AttachInternetGateway",
"ec2:DetachInternetGateway",
"ec2:DeleteInternetGateway",
"ec2:CreateSubnet",
"ec2:DeleteSubnet",
"ec2:CreateRoute",
"ec2:DeleteRoute",
"ec2:CreateRouteTable",
"ec2:AssociateRouteTable",
"ec2:DisassociateRouteTable",
"ec2:DeleteRouteTable",
"ec2:CreateVpcEndpoint",
"ec2:DeleteVpcEndpoints",
"ec2:ModifyVpcEndpoint",
"ec2:Describe*",
"autoscaling:DescribeAutoScalingInstances"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
```
------
#### Concessione delle autorizzazioni utilizzando un modello CloudFormation
CloudFormation automatizza il processo di creazione di ruoli e policy IAM utilizzando un modello preconfigurato. Utilizza la seguente procedura per creare i ruoli e le policy IAM richiesti per EC2 Rescue Automation utilizzando. CloudFormation
**Per creare i ruoli e le politiche IAM richiesti per EC2 Rescue**
1. Scaricare [https://docs.aws.amazon.com/systems-manager/latest/userguide/samples/AWSSupport-EC2RescueRole.zip](https://docs.aws.amazon.com/systems-manager/latest/userguide/samples/AWSSupport-EC2RescueRole.zip) ed estrarre il file `AWSSupport-EC2RescueRole.json` in una directory sul computer locale.
1. Se ti Account AWS trovi in una partizione speciale, modifica il modello per cambiare i valori ARN con quelli della tua partizione.
Ad esempio, per le regioni della Cina, modificare i casi da `arn:aws` a `arn:aws-cn`.
1. [Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, **With new resources (standard) (Con nuove risorse (standard))**.
1. Nella pagina **Create stack (Crea stack)** per **Prerequisite - Prepare template (Prerequisito - Prepara modello)**, scegliere **Template is ready (Il modello è pronto)**.
1. In **Specify template (Specifica il modello)**, scegliere **Upload a template file (Carica un file modello)**.
1. Scegliere **Choose file (Scegli file)**, quindi individuare e selezionare il file `AWSSupport-EC2RescueRole.json` dalla directory in cui è stato estratto.
1. Scegliere **Next (Successivo)**.
1. Nella pagina **Specify stack details (Specifica i dettagli dello stack)**, per il campo **Stack name (Nome stack)** inserire un nome per identificare lo stack, quindi scegliere **Next (Successivo)**.
1. (Facoltativo) Nell'area **Tag**, applica una o più name/value coppie di chiavi di tag allo stack.
I tag sono metadati facoltativi assegnati a una risorsa. I tag 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 uno stack per identificare il tipo di attività che esegue, i tipi di destinazioni o altre risorse coinvolte e l'ambiente in cui viene eseguito.
1. Seleziona **Next** (Successivo).
1. Nella pagina **Revisione**, esamina i dettagli dello stack, quindi scorri verso il basso e scegli l'opzione **Riconosco che CloudFormation potrebbe creare risorse IAM**.
1. Seleziona **Crea stack**.
CloudFormation mostra lo **stato CREATE\$1IN\$1PROGRESS** per alcuni minuti. Dopo la creazione dello stack, lo stato diventa **CREATE\$1COMPLETE**. È inoltre possibile scegliere l'icona di aggiornamento per verificare lo stato del processo di creazione.
1. Nell'elenco **Stacks**, scegliere il pulsane di opzione accanto allo stack appena creato e quindi scegliere la scheda **Outputs**.
1. Annotare il **valore**. È l'ARN di. AssumeRole Si specifica questo ARN quando si esegue l'automazione nella procedura successiva, [Esecuzione del servizio di automazione](#automation-ec2rescue-executing).
## Esecuzione del servizio di automazione
**Importante**
La seguente automazione arresta l'istanza non raggiungibile. L'arresto dell'istanza può causare la perdita di dati sui volumi dell'archivio dell'istanza collegati (se presenti). L'arresto dell'istanza può causare anche la modifica dell'indirizzo IP pubblico se non è associato alcun indirizzo IP elastico.
**Esecuzione del servizio di automazione `AWSSupport-ExecuteEC2Rescue`.**
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 **Automazione**.
1. Scegli **Esegui automazione**.
1. Nella sezione **Automation document (Documento di automazione)** scegliere **Owned by Amazon (Di proprietà di Amazon)** nell'elenco.
1. Nell'elenco dei runbook scegliere il pulsante nella scheda per `AWSSupport-ExecuteEC2Rescue`, quindi scegliere **Next (Successivo)**.
1. Nella pagina **Execute automation document (Esegui documento di automazione)**, scegliere **Simple execution (Esecuzione semplice)**.
1. Nella sezione **Document details (Dettagli documento)** verificare che l'opzione **Document version (Versione documento)** sia impostata sulla versione predefinita con il numero più alto. Ad esempio, **\$1DEFAULT** o **3 (default)**.
1. Nella sezione **Input parameters (Parametri di input)**, specificare i seguenti parametri:
1. Per **UnreachableInstanceId**, specifica l'ID dell'istanza irraggiungibile.
1. (Facoltativo) Per **EC2RescueInstanceType**, specifica un tipo di istanza per l'istanza EC2 Rescue. Il tipo di istanza di default è `t2.medium`.
1. Infatti **AutomationAssumeRole**, se hai creato ruoli per questa automazione utilizzando la CloudFormation procedura descritta in precedenza in questo argomento, scegli l'ARN di AssumeRole quello che hai creato nella CloudFormation console.
1. (Facoltativo) Per **LogDestination**, specifica un bucket S3 se desideri raccogliere i log a livello di sistema operativo durante la risoluzione dei problemi dell'istanza. I log vengono automaticamente caricati nel bucket specificato.
1. Per **SubnetId**, specifica una sottorete in un VPC esistente nella stessa zona di disponibilità dell'istanza irraggiungibile. Per impostazione predefinita, Systems Manager crea un nuovo VPC, ma è possibile specificare una sottorete in un VPC esistente.
**Nota**
Se l'opzione per specificare un bucket o un ID di sottorete non è disponibile, verificare nel campo **Default (Impostazione predefinita)** che si stia utilizzando la versione più recente del runbook.
1. (Facoltativo) Nell'area **Tag**, applica una o più name/value coppie di chiavi di tag per identificare l'automazione, ad esempio. `Key=Purpose,Value=EC2Rescue`
1. Scegliere **Execute (Esegui)**.
Il runbook crea un backup dell'AMI come parte dell'automazione. Tutte le altre risorse create dall'automazione vengono eliminate automaticamente, ma questa AMI rimane nell'account in uso. All'AMI viene assegnato un nome utilizzando la seguente convenzione:
AMI di backup: AWSSupport-EC 2Rescue: *UnreachableInstanceId*
È possibile individuare questa AMI nella console Amazon EC2 cercando l'ID di esecuzione dell'automazione.
# Ripristino di password e chiavi SSH sulle istanze EC2
È possibile utilizzare il runbook `AWSSupport-ResetAccess` per riabilitare automaticamente la generazione della password dell'amministratore locale sulle istanze Amazon Elastic Compute Cloud (Amazon EC2) per Windows Server e per generare una nuova chiave SSH sulle istanze EC2 per Linux. Il `AWSSupport-ResetAccess` runbook è progettato per eseguire una combinazione di AWS Systems Manager azioni, AWS CloudFormation azioni e AWS Lambda funzioni che automatizzano i passaggi normalmente necessari per reimpostare la password dell'amministratore locale.
È possibile utilizzare Automation, uno strumento incluso nel `AWSSupport-ResetAccess` runbook AWS Systems Manager, per risolvere i seguenti problemi:
**Windows**
*Hai perso la coppia di chiavi EC2*: per risolvere questo problema, puoi usare il **AWSSupport-ResetAccess**runbook per creare una password abilitata AMI dall'istanza corrente, avviare una nuova istanza dall'AMI e selezionare una coppia di chiavi di tua proprietà.
*Perdita della password dell'amministratore locale*: per risolvere questo problema, è possibile utilizzare il runbook `AWSSupport-ResetAccess` per generare una nuova password che può essere decrittografata mediante la coppia di chiavi EC2 corrente.
**Linux**
*Perdita della coppia di chiavi EC2 oppure configurazione dell'accesso SSH all'istanza con una chiave perduta*: per risolvere questo problema, è possibile utilizzare il runbook `AWSSupport-ResetAccess` per creare una nuova chiave SSH per l'istanza corrente. Tale chiave consente di connettersi di nuovo all'istanza.
**Nota**
Se l'istanza EC2 per Windows Server è configurata per Systems Manager, puoi anche reimpostare la password dell'amministratore locale utilizzando EC2 Rescue and AWS Systems Manager Run Command. Per ulteriori informazioni, consulta [Using EC2 Rescue for Windows Server with Systems Manager Run Command](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2rw-ssm.html) nella *Amazon EC2 User Guide*.
**Informazioni correlate**
[Connessione all'istanza Linux da Windows tramite PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) nella *Guida per l'utente di Amazon EC2*
## Come funziona
Risoluzione dei problemi di un'istanza con il servizio di automazione e il runbook `AWSSupport-ResetAccess` funziona nel seguente modo:
+ L'utente specifica l'ID dell'istanza ed esegue il runbook.
+ Il sistema crea un VPC temporaneo e quindi esegue una serie di funzioni Lambda per configurare il VPC.
+ Il sistema identifica una sottorete per il VPC temporaneo nella stessa zona di disponibilità dell'istanza originale.
+ Il sistema avvia un'istanza helper temporanea e abilitata per SSM.
+ Il sistema arresta l'istanza originale e crea un backup. Collega quindi il volume root originale all'istanza helper.
+ Il sistema utilizza Rescue Run Command per eseguire EC2 Rescue sull'istanza helper. In Windows, EC2 Rescue consente la generazione di password per l'amministratore locale utilizzando EC2 Config o EC2 Launch sul volume root originale allegato. Su Linux, EC2 Rescue genera e inietta una nuova chiave SSH e salva la chiave privata, crittografata, in. Parameter Store Al termine, EC2 Rescue ricollega il volume root all'istanza originale.
+ Il sistema crea una nuova Amazon Machine Image (AMI) dell'istanza, ora che la generazione delle password è abilitata. È possibile usare questa AMI per creare una nuova istanza EC2 e associare una nuova coppia di chiavi, se necessario.
+ Il sistema riavvia l'istanza originale e termina l'istanza temporanea. Il sistema termina anche il VPC temporaneo e le funzioni Lambda create all'inizio dell'automazione.
+ **Windows**: l'istanza genera una nuova password che è possibile decodificare dalla console Amazon EC2 utilizzando la coppia di chiavi corrente assegnata all'istanza.
**Linux**: è possibile accedere all'istanza tramite SSH utilizzando la chiave SSH memorizzata in Systems Manager Parameter Store come **/ec2rl/openssh/ *instance ID* /key.**
## Prima di iniziare
Prima di eseguire la seguente automazione, esegui le seguenti operazioni:
+ Copiare l'ID istanza dell'istanza per la quale si desidera reimpostare la password dell'amministratore. Questo ID verrà specificato nella procedura.
+ Facoltativamente, recuperare l'ID di una sottorete nella stessa zona di disponibilità dell'istanza non raggiungibile. L'istanza Rescue verrà creata in questa sottorete. EC2 Se non specifichi una sottorete, Automation crea un nuovo VPC temporaneo nel tuo. Account AWS Verifica di Account AWS avere almeno un VPC disponibile. Per impostazione predefinita, puoi crearne cinque VPCs in una regione. Se ne hai già creati cinque VPCs nella regione, l'automazione fallisce senza apportare modifiche all'istanza. Per ulteriori informazioni sulle quote di Amazon VPC, consulta l'argomento relativo a [VPC e sottoreti](https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html#vpc-limits-vpcs-subnets) nella *Guida utente Amazon VPC*.
+ Facoltativamente, puoi creare e specificare un ruolo AWS Identity and Access Management (IAM) per l'automazione. Se non si specifica questo ruolo, il servizio di automazione viene eseguito nel contesto dell'utente che ha eseguito l'automazione.
### Concessione delle autorizzazioni a AWSSupport-EC 2Rescue per eseguire azioni sulle istanze
EC2Rescue necessita dell'autorizzazione per eseguire una serie di azioni sulle istanze durante l'automazione. Queste azioni richiamano i AWS Lambda servizi IAM e Amazon EC2 per tentare in modo sicuro di risolvere i problemi con le istanze. Se disponi di autorizzazioni a livello di amministratore nel tuo e/o Account AWS VPC, potresti essere in grado di eseguire l'automazione senza configurare le autorizzazioni, come descritto in questa sezione. Se non si dispone delle autorizzazioni a livello di amministratore, l'utente corrente o un amministratore deve configurare tali autorizzazioni mediante una delle opzioni riportate di seguito.
+ [Concessione delle autorizzazioni mediante policy IAM](#automation-ec2reset-access-iam)
+ [Concessione delle autorizzazioni utilizzando un modello CloudFormation](#automation-ec2reset-access-cfn)
#### Concessione delle autorizzazioni mediante policy IAM
È possibile collegare la seguente policy IAM all'utente, al gruppo o al ruolo come policy inline. In alternativa, è possibile creare una nuova policy gestita IAM e collegarla all'utente, al gruppo o al ruolo. Per ulteriori informazioni sull'aggiunta di una policy inline all'utente, al gruppo o al ruolo, consulta la pagina [Utilizzo delle policy inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html). Per ulteriori informazioni sulla creazione di una nuova policy gestita, consulta la sezione relativa all'[uso di policy gestite](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html).
**Nota**
Se crei una nuova policy gestita da IAM, devi anche allegare la policy gestita di **Amazon SSMAutomation Role** in modo che le tue istanze possano comunicare con l'API Systems Manager.
**Policy IAM per `AWSSupport-ResetAccess`**
*account ID*Sostituiscila con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"lambda:InvokeFunction",
"lambda:DeleteFunction",
"lambda:GetFunction"
],
"Resource": "arn:aws:lambda:*:111122223333:function:AWSSupport-EC2Rescue-*",
"Effect": "Allow"
},
{
"Action": [
"s3:GetObject",
"s3:GetObjectVersion"
],
"Resource": [
"arn:aws:s3:::awssupport-ssm.*/*.template",
"arn:aws:s3:::awssupport-ssm.*/*.zip"
],
"Effect": "Allow"
},
{
"Action": [
"iam:CreateRole",
"iam:CreateInstanceProfile",
"iam:GetRole",
"iam:GetInstanceProfile",
"iam:PutRolePolicy",
"iam:DetachRolePolicy",
"iam:AttachRolePolicy",
"iam:PassRole",
"iam:AddRoleToInstanceProfile",
"iam:RemoveRoleFromInstanceProfile",
"iam:DeleteRole",
"iam:DeleteRolePolicy",
"iam:DeleteInstanceProfile"
],
"Resource": [
"arn:aws:iam::111122223333:role/AWSSupport-EC2Rescue-*",
"arn:aws:iam::111122223333:instance-profile/AWSSupport-EC2Rescue-*"
],
"Effect": "Allow"
},
{
"Action": [
"lambda:CreateFunction",
"ec2:CreateVpc",
"ec2:ModifyVpcAttribute",
"ec2:DeleteVpc",
"ec2:CreateInternetGateway",
"ec2:AttachInternetGateway",
"ec2:DetachInternetGateway",
"ec2:DeleteInternetGateway",
"ec2:CreateSubnet",
"ec2:DeleteSubnet",
"ec2:CreateRoute",
"ec2:DeleteRoute",
"ec2:CreateRouteTable",
"ec2:AssociateRouteTable",
"ec2:DisassociateRouteTable",
"ec2:DeleteRouteTable",
"ec2:CreateVpcEndpoint",
"ec2:DeleteVpcEndpoints",
"ec2:ModifyVpcEndpoint",
"ec2:Describe*"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
```
------
#### Concessione delle autorizzazioni utilizzando un modello CloudFormation
CloudFormation automatizza il processo di creazione di ruoli e policy IAM utilizzando un modello preconfigurato. Utilizza la seguente procedura per creare i ruoli e le policy IAM richiesti per EC2 Rescue Automation utilizzando. CloudFormation
**Per creare i ruoli e le politiche IAM richiesti per EC2 Rescue**
1. Scaricare [https://docs.aws.amazon.com/systems-manager/latest/userguide/samples/AWSSupport-EC2RescueRole.zip](https://docs.aws.amazon.com/systems-manager/latest/userguide/samples/AWSSupport-EC2RescueRole.zip) ed estrarre il file `AWSSupport-EC2RescueRole.json` in una directory sul computer locale.
1. Se ti Account AWS trovi in una partizione speciale, modifica il modello per cambiare i valori ARN con quelli della tua partizione.
Ad esempio, per le regioni della Cina, modificare i casi da `arn:aws` a `arn:aws-cn`.
1. [Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, **With new resources (standard) (Con nuove risorse (standard))**.
1. Nella pagina **Create stack (Crea stack)** per **Prerequisite - Prepare template (Prerequisito - Prepara modello)**, scegliere **Template is ready (Il modello è pronto)**.
1. In **Specify template (Specifica il modello)**, scegliere **Upload a template file (Carica un file modello)**.
1. Scegliere **Choose file (Scegli file)**, quindi individuare e selezionare il file `AWSSupport-EC2RescueRole.json` dalla directory in cui è stato estratto.
1. Scegliere **Next (Successivo)**.
1. Nella pagina **Specify stack details (Specifica i dettagli dello stack)**, per il campo **Stack name (Nome stack)** inserire un nome per identificare lo stack, quindi scegliere **Next (Successivo)**.
1. (Facoltativo) Nell'area **Tag**, applica una o più name/value coppie di chiavi di tag allo stack.
I tag sono metadati facoltativi assegnati a una risorsa. I tag 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 uno stack per identificare il tipo di attività che esegue, i tipi di destinazioni o altre risorse coinvolte e l'ambiente in cui viene eseguito.
1. Seleziona **Next** (Successivo).
1. Nella pagina **Revisione**, esamina i dettagli dello stack, quindi scorri verso il basso e scegli l'opzione **Riconosco che CloudFormation potrebbe creare risorse IAM**.
1. CloudFormation mostra lo **stato CREATE\$1IN\$1PROGRESS** per alcuni minuti. Dopo la creazione dello stack, lo stato diventa **CREATE\$1COMPLETE**. È inoltre possibile scegliere l'icona di aggiornamento per verificare lo stato del processo di creazione.
1. Nell'elenco degli stack, scegliere l'opzione accanto allo stack appena creato e quindi scegliere la scheda **Outputs (Output)**.
1. Copiare il valore visualizzato nel campo **Value (Valore)**. È l'ARN di. AssumeRole È possibile specificare questo ARN quando si esegue il servizio di automazione.
## Esecuzione del servizio di automazione
La procedura seguente descrive come seguire runbook `AWSSupport-ResetAccess` tramite la console AWS Systems Manager .
**Importante**
L'esecuzione della seguente automazione arresta l'istanza. L'arresto dell'istanza può causare la perdita di dati sui volumi dell'archivio dell'istanza collegati (se presenti). L'arresto dell'istanza può causare anche la modifica dell'indirizzo IP pubblico se non è associato alcun indirizzo IP elastico. Per evitare queste modifiche di configurazione, utilizza Run Command per ripristinare l'accesso. Per ulteriori informazioni, consulta [Using EC2 Rescue for Windows Server with Systems Manager Run Command](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2rw-ssm.html) nella *Amazon EC2 User Guide*.
**Per eseguire l'automazione AWSSupport-ResetAccess**
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 **Automazione**.
1. Scegli **Esegui automazione**.
1. Nella sezione **Automation document (Documento di automazione)** scegliere **Owned by Amazon (Di proprietà di Amazon)** nell'elenco.
1. Nell'elenco dei runbook scegliere il pulsante nella scheda per **AWSSupport-ResetAccess**, quindi scegliere **Next (Successivo)**.
1. Nella pagina **Execute automation document (Esegui documento di automazione)**, scegliere **Simple execution (Esecuzione semplice)**.
1. Nella sezione **Document details (Dettagli documento)** verificare che l'opzione **Document version (Versione documento)** sia impostata sulla versione predefinita con il numero più alto. Ad esempio, **\$1DEFAULT** o **3 (default)**.
1. Nella sezione **Input parameters (Parametri di input)**, specificare i seguenti parametri:
1. Per **InstanceID**, specificare l'ID dell'istanza non raggiungibile.
1. Per **SubnetId**, specifica una sottorete in un VPC esistente nella stessa zona di disponibilità dell'istanza specificata. Per impostazione predefinita, Systems Manager crea un nuovo VPC, ma è possibile specificare una sottorete in un VPC esistente.
**Nota**
Se l'opzione per specificare un ID sottorete non è disponibile, verificare nel campo **Default (Impostazione predefinita)** che si stia utilizzando la versione più recente del runbook.
1. Per **EC2RescueInstanceType**, specifica un tipo di istanza per l'istanza EC2 Rescue. Il tipo di istanza di default è `t2.medium`.
1. Infatti **AssumeRole**, se hai creato ruoli per questa automazione utilizzando la CloudFormation procedura descritta in precedenza in questo argomento, specifica l' AssumeRole ARN che hai annotato nella CloudFormation console.
1. (Facoltativo) Nell'area **Tag**, applicate una o più name/value coppie di chiavi di tag per identificare l'automazione, ad esempio`Key=Purpose,Value=ResetAccess`.
1. Scegliere **Execute (Esegui)**.
1. Per monitorare lo stato di avanzamento dell'automazione, scegliere l'automazione in esecuzione e quindi scegliere la scheda **Steps (Fasi)**. Al termine dell'automazione, scegliere la scheda **Descriptions (Descrizioni)**, quindi **View output (Visualizza output)** per visualizzare i risultati. Per visualizzare l'output delle singole fasi, scegliere la scheda **Steps (Fasi)**, quindi scegliere **View Outputs (Visualizza output)** accanto a una fase.
Il runbook crea un backup di AMI e un'AMI abilitata mediante password come parte dell'automazione. Tutte le altre risorse create dall'automazione vengono eliminate automaticamente, ma queste AMIs rimangono nell'account in uso. Alle AMIs viene assegnato un nome utilizzando le seguenti convenzioni:
+ Backup AMI: `AWSSupport-EC2Rescue:InstanceID`
+ AMI abilitata tramite password AWSSupport-EC: 2Rescue: AMI abilitata tramite password da *Instance ID*
È possibile individuare queste AMIs nella console cercando l'ID di esecuzione dell servizio di automazione.
Per Linux, la nuova chiave SSH privata per l'istanza viene salvato e crittografati in Parameter Store. **Il nome del parametro è /ec2rl/openssh/ /key. *instance ID***
# Trasmissione dei dati ad Automazione tramite trasformatori di input
Questo tutorial di AWS Systems Manager automazione mostra come utilizzare la funzionalità di trasformazione di input di Amazon EventBridge per estrarre un'istanza Amazon Elastic Compute Cloud (Amazon EC2) da un evento di modifica dello stato dell'istanza. `instance-id` L’automazione è uno strumento di AWS Systems Manager. Usiamo il trasformatore di input per passare i dati alla destinazione del runbook `AWS-CreateImage` come parametro di input `InstanceId`. La regola viene attivata quando un'istanza passa allo stato `stopped`.
Per ulteriori informazioni sull'[utilizzo dei trasformatori di input, consulta Tutorial: Use Input Transformer per personalizzare ciò che viene passato all'Event Target nella](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-input-transformer-tutorial.html) *Amazon EventBridge * User Guide.
**Prima di iniziare**
Verificare di aver aggiunto le autorizzazioni e i criteri di attendibilità richiesti EventBridge per il ruolo di servizio Systems Manager Automation. Per ulteriori informazioni, consulta [Panoramica della gestione delle autorizzazioni di accesso alle EventBridge risorse](https://docs.aws.amazon.com/eventbridge/latest/userguide/iam-access-control-identity-based-eventbridge.html) nella *Amazon EventBridge User Guide*.
**Per utilizzare i trasformatori di input con il servizio di automazione**
1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).
1. Nel pannello di navigazione, scegli **Regole**.
1. Scegli **Crea regola**.
1. Inserisci un nome e una descrizione per la regola.
Una regola non può avere lo stesso nome di un'altra regola nella stessa Regione e sullo stesso router di eventi.
1. Per **Router di eventi**, seleziona il router di eventi che desideri associare a questa regola. Se desideri che questa regola risponda agli eventi corrispondenti generati dai tuoi Account AWS, seleziona **Predefinito**. Quando un Servizio AWS utente del tuo account emette un evento, questo passa sempre al bus eventi predefinito del tuo account.
1. Per **Tipo di regola**, scegli **Regola con un modello di eventi**.
1. Scegli **Next (Successivo)**.
1. Per **Event source**, scegli **AWS eventi o eventi EventBridge partner**.
1. Nella sezione **Modello di eventi**, scegli **Modulo di modello di eventi**.
1. Per **Event source** (Origine evento), scegli **AWS services** (Servizi ).
1. Per **Servizio AWS **, scegli **EC2**.
1. Per **Tipo di evento**, scegli **Notifica variazione di stato istanze EC2**.
1. Per **Specifica del tipo di evento 1**, seleziona **Stati specifici**, quindi scegli **arrestato**.
1. Per **Event Type Specification 2**, seleziona **Qualsiasi istanza** **o seleziona Id specifici** IDs dell'istanza e inserisci le istanze da monitorare.
1. Scegli **Next (Successivo)**.
1. Per **Tipi di destinazione**, scegli **servizio AWS **.
1. Per **Seleziona destinazione**, scegli **Automazione di Systems Manager**.
1. Per **Document**, scegli **AWS- CreateImage**.
1. Nella sezione **Configure automation parameter(s)** (Configurazione dei parametri di automazione), **Input Transformer** (Trasformatore di input).
1. Per **Input path** (Percorso di input) inserisci **\$1"instance":"\$1.detail.instance-id"\$1**.
1. Per **Template** (Modello) inserisci **\$1"InstanceId":[]\$1**.
1. Per **Ruolo di esecuzione**, scegli **Utilizza ruolo esistente** e quindi il ruolo di servizio di automazione.
1. Scegli **Next (Successivo)**.
1. (Facoltativo) Inserire uno o più tag per la regola. Per ulteriori informazioni, consulta [Tagging Your Amazon EventBridge Resources](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-tagging.html) nella *Amazon EventBridge User Guide*.
1. Scegli **Next (Successivo)**.
1. Rivedi i dettagli della regola e scegli **Crea regola**.