• La AWS Systems Manager CloudWatch dashboard non sarà più disponibile dopo il 30 aprile 2026. I clienti possono continuare a utilizzare la CloudWatch console Amazon per visualizzare, creare e gestire le proprie CloudWatch dashboard Amazon, proprio come fanno oggi. Per ulteriori informazioni, consulta la [documentazione di Amazon CloudWatch Dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # `aws:executeScript`: esecuzione di uno script Esegue il Python o PowerShell lo script fornito utilizzando il runtime e il gestore specificati. Ogni operazione `aws:executeScript` può durare al massimo 600 secondi (10 minuti). Puoi limitare il timeout specificando il parametro `timeoutSeconds` per una fase `aws:executeScript`. Usa le istruzioni return nella funzione per aggiungere output al payload di output. Per esempi di definizione degli output per l'operazione `aws:executeScript`, consulta [Esempio 2: Runbook con script](automation-authoring-runbooks-scripted-example.md). Puoi anche inviare l'output `aws:executeScript` delle azioni nei tuoi runbook al gruppo di log Amazon CloudWatch Logs da te specificato. Per ulteriori informazioni, consulta [Registrazione dell'output dell'azione di automazione con CloudWatch Logs](automation-action-logging.md). Se desideri inviare l'output `aws:executeScript` delle azioni ai CloudWatch log o se gli script che specifichi per `aws:executeScript` le azioni richiamano le operazioni AWS API, è sempre necessario un ruolo di servizio AWS Identity and Access Management (IAM) (o assumi un ruolo) per eseguire il runbook. **Nota** L'azione `aws:executeScript` non supporta il nuovo tentativo di limitazione (della larghezza di banda della rete) automatico. Se lo script effettua chiamate AWS API che potrebbero essere limitate, è necessario implementare la propria logica di riprova nel codice dello script. L'`aws:executeScript`azione contiene i seguenti moduli Core PowerShell preinstallati: + Microsoft. PowerShell.Host + Microsoft. PowerShell.Gestione + Microsoft. PowerShell.Sicurezza + Microsoft. PowerShell.Utilità + PackageManagement + PowerShellGet Per utilizzare i moduli PowerShell Core che non sono preinstallati, lo script deve installare il modulo con il `-Force` flag, come mostrato nel comando seguente. Il modulo `AWSPowerShell.NetCore` non è supportato. Sostituiscilo *ModuleName* con il modulo che desideri installare. ``` Install-Module ModuleName -Force ``` Per utilizzare i cmdlet PowerShell Core nello script, è consigliabile utilizzare i `AWS.Tools` moduli, come illustrato nei comandi seguenti. Sostituisci ogni *example resource placeholder* con le tue informazioni. + Cmdlet Amazon S3 ``` Install-Module AWS.Tools.S3 -Force Get-S3Bucket -BucketName amzn-s3-demo-bucket ``` + Cmdlet Amazon EC2 ``` Install-Module AWS.Tools.EC2 -Force Get-EC2InstanceStatus -InstanceId instance-id ``` + Cmdlet comuni o indipendenti dal AWS Tools for Windows PowerShell servizio. ``` Install-Module AWS.Tools.Common -Force Get-AWSRegion ``` Se lo script inizializza nuovi oggetti oltre a utilizzare i cmdlet PowerShell Core, è necessario importare anche il modulo come illustrato nel comando seguente. ``` Install-Module AWS.Tools.EC2 -Force Import-Module AWS.Tools.EC2 $tag = New-Object Amazon.EC2.Model.Tag $tag.Key = "Tag" $tag.Value = "TagValue" New-EC2Tag -Resource i-02573cafcfEXAMPLE -Tag $tag ``` Per esempi di installazione e importazione di `AWS.Tools` moduli e utilizzo dei cmdlet PowerShell Core nei runbook, vedere. [Esperienza di progettazione visiva per i runbook Automation](automation-visual-designer.md) **Input** Fornisci le informazioni necessarie per eseguire lo script. Sostituisci ogni *example resource placeholder* con le tue informazioni. **Nota** L'allegato per uno script Python può essere un file.py o un file.zip che contiene lo script. PowerShell gli script devono essere archiviati in file.zip. ------ #### [ YAML ] ``` action: "aws:executeScript" inputs: Runtime: runtime Handler: "functionName" InputPayload: scriptInput: '{{parameterValue}}' Script: |- def functionName(events, context): ... Attachment: "scriptAttachment.zip" ``` ------ #### [ JSON ] ``` { "action": "aws:executeScript", "inputs": { "Runtime": "runtime", "Handler": "functionName", "InputPayload": { "scriptInput": "{{parameterValue}}" }, "Attachment": "scriptAttachment.zip" } } ``` ------ Runtime Il linguaggio di runtime da utilizzare per eseguire lo script fornito. `aws:executeScript`supporta i runtime riportati nella tabella seguente. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/systems-manager/latest/userguide/automation-action-executeScript.html) Tipo: stringa Obbligatorio: sì Per i runtime di Python, l'ambiente fornisce 512 MB di memoria e 512 MB di spazio su disco. Per quanto riguarda i PowerShell runtime, l'ambiente fornisce 1024 MB di memoria e 512 MB di spazio su disco. Gestore Il nome della funzione. È necessario assicurarsi che la funzione definita nel gestore abbia due parametri, `events` e `context`. Il PowerShell runtime non supporta questo parametro. Tipo: String Obbligatorio: Sì (Python) \$1 Non supportato () PowerShell InputPayload Un oggetto JSON o YAML che verrà passato al primo parametro del gestore. Questo può essere usato per passare i dati di input allo script. ▬Tipo: stringa Obbligatorio: no ``` description: Tag an instance schemaVersion: '0.3' assumeRole: '{{AutomationAssumeRole}}' parameters: AutomationAssumeRole: type: String description: '(Required) The Amazon Resource Name (ARN) of the IAM role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to operate this runbook.' InstanceId: type: String description: (Required) The ID of the EC2 instance you want to tag. mainSteps: - name: tagInstance action: 'aws:executeScript' inputs: Runtime: "python3.11" Handler: tagInstance InputPayload: instanceId: '{{InstanceId}}' Script: |- def tagInstance(events,context): import boto3 #Initialize client ec2 = boto3.client('ec2') instanceId = events['instanceId'] tag = { "Key": "Env", "Value": "ExamplePython" } print(f"Adding tag {tag} to instance id {instanceId}") ec2.create_tags( Resources=[instanceId], Tags=[tag] ) return tag outputs: - Type: String Name: TagKey Selector: $.Payload.Key outputs: - tagInstance.TagKey ``` ``` description: Tag an instance schemaVersion: '0.3' assumeRole: '{{AutomationAssumeRole}}' parameters: AutomationAssumeRole: type: String description: (Required) The Amazon Resource Name (ARN) of the IAM role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to operate this runbook. InstanceId: type: String description: (Required) The ID of the EC2 instance you want to tag. mainSteps: - name: tagInstance action: aws:executeScript isEnd: true inputs: Runtime: PowerShell 7.4 InputPayload: instanceId: '{{InstanceId}}' Script: |- Install-Module AWS.Tools.EC2 -Force Import-Module AWS.Tools.EC2 $input = $env:InputPayload | ConvertFrom-Json $tag = New-Object Amazon.EC2.Model.Tag $tag.Key = "Env" $tag.Value = "ExamplePowerShell" Write-Information "Adding tag key: $($tag.Key) and value: $($tag.Value) to instance id $($input.instanceId)" New-EC2Tag -Resource $input.instanceId -Tag $tag return $tag outputs: - Type: String Name: TagKey Selector: $.Payload.Key outputs: - tagInstance.TagKey ``` Script Uno script incorporato che si desidera eseguire durante l'automazione. Tipo: String Obbligatorio: No (Python) \$1 Sì () PowerShell Allegato Il nome di un file di script standalone o di un file .zip che può essere richiamato dall'operazione. Specifica lo stesso valore del `Name` del file allegato del documento che specifichi nel parametro della richiesta `Attachments`. Per ulteriori informazioni, consulta la sezione [Allegati](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateDocument.html#systemsmanager-CreateDocument-request-Attachments) nella *Documentazione di riferimento API di AWS Systems Manager *. Se stai fornendo uno script utilizzando un allegato, devi anche definire una sezione `files` negli elementi di primo livello del runbook. Per ulteriori informazioni, consulta [Versione dello schema 0.3](documents-schemas-features.md#automation-doc-syntax-examples). Per richiamare un file per python, utilizzare il formato `filename.method_name` in `Handler`. L'allegato per uno script Python può essere un file.py o un file.zip che contiene lo script. PowerShell gli script devono essere archiviati in file.zip. Quando si includono librerie Python nell'allegato, si consiglia di aggiungere un file `__init__.py` vuoto in ogni directory del modulo. Ciò consente di importare i moduli dalla libreria nell'allegato all'interno del contenuto dello script. Ad esempio: `from library import module` ▬Tipo: stringa Obbligatorio: noOutput Carico utile Rappresentazione JSON dell'oggetto restituito dalla funzione. Vengono restituiti fino a 100 KB. Se si genera un elenco, viene restituito un massimo di 100 elementi. ## Utilizzo degli allegati con aws:executeScript Gli allegati forniscono un modo efficace per impacchettare e riutilizzare script complessi, moduli multipli e dipendenze esterne nelle tue azioni `aws:executeScript`. Utilizza gli allegati quando devi: + Package di più moduli o PowerShell script Python. + Riutilizzare la stessa logica di script su più runbook. + Includi librerie o dipendenze esterne nei tuoi script. + Mantieni pulita la definizione del runbook separando la logica degli script complessi. + Condividi pacchetti di script tra team o flussi di lavoro di automazione. ### Struttura degli allegati e creazione del pacchetto È possibile allegare file singoli o pacchetti zip contenenti più file. La struttura varia a seconda del caso d'uso: **Singoli file allegati** Per script semplici, puoi allegare un singolo `.py` file (Python) o `.zip` un file contenente un PowerShell singolo script. **Pacchetti multimodulo** Per un'automazione complessa che richiede numerosi moduli, crea un pacchetto zip con la seguente struttura consigliata: ``` my-automation-package.zip ├── main.py # Entry point script ├── utils/ │ ├── __init__.py # Required for Python module imports │ ├── helper_functions.py # Utility functions │ └── aws_operations.py # AWS-specific operations ├── config/ │ ├── __init__.py │ └── settings.py # Configuration settings └── requirements.txt # Optional: document dependencies ``` **Importante** Per i pacchetti Python, è necessario includere un file `__init__.py` vuoto in ogni directory che contiene i moduli Python. Ciò consente di importare moduli utilizzando la sintassi di importazione Python standard come `from utils import helper_functions`. **PowerShell struttura del pacchetto** PowerShell gli allegati devono essere impacchettati in file zip con la seguente struttura: ``` my-powershell-package.zip ├── Main.ps1 # Entry point script ├── Modules/ │ ├── HelperFunctions.ps1 # Utility functions │ └── AWSOperations.ps1 # AWS-specific operations └── Config/ └── Settings.ps1 # Configuration settings ``` ### Creazione di runbook con allegati Segui questi passaggi per creare runbook che utilizzano allegati: 1. **Carica il tuo allegato su Amazon S3** Carica il file di script o il pacchetto zip in un bucket S3, a cui può accedere il tuo ruolo di automazione. Annota l'URI S3 per l'utilizzo nel passaggio successivo. ``` aws s3 cp my-automation-package.zip s3://my-automation-bucket/scripts/ ``` 1. **Calcola il checksum degli allegati** Calcola il checksum SHA-256 del file allegato per la verifica di sicurezza: ``` # Linux/macOS shasum -a 256 my-automation-package.zip # Windows PowerShell Get-FileHash -Algorithm SHA256 my-automation-package.zip ``` 1. **Definisci la sezione dei file nel tuo runbook** Aggiungi una sezione `files` al livello superiore del runbook, per fare riferimento all'allegato: ``` files: my-automation-package.zip: checksums: sha256: "your-calculated-checksum-here" ``` 1. **Fai riferimento all'allegato nel passaggio executeScript** Utilizza il parametro `Attachment`, per fare riferimento al file caricato: ``` - name: runMyScript action: aws:executeScript inputs: Runtime: python3.11 Handler: main.process_data Attachment: my-automation-package.zip InputPayload: inputData: "{{InputParameter}}" ``` ## aws:executeScript (esempi di allegati) Gli esempi seguenti mostrano diversi modi di utilizzare gli allegati con l'azione `aws:executeScript`. ### Esempio 1: singolo file allegato Questo esempio mostra come utilizzare un singolo file Python come allegato, per elaborare i dati delle istanze EC2. **File allegato: process\$1instance.py** Crea un file Python con i seguenti contenuti: ``` import boto3 import json def process_instance_data(events, context): """Process EC2 instance data and return formatted results.""" try: instance_id = events.get('instanceId') if not instance_id: raise ValueError("instanceId is required") ec2 = boto3.client('ec2') # Get instance details response = ec2.describe_instances(InstanceIds=[instance_id]) instance = response['Reservations'][0]['Instances'][0] # Format the response result = { 'instanceId': instance_id, 'instanceType': instance['InstanceType'], 'state': instance['State']['Name'], 'availabilityZone': instance['Placement']['AvailabilityZone'], 'tags': {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])} } print(f"Successfully processed instance {instance_id}") return result except Exception as e: print(f"Error processing instance: {str(e)}") raise ``` **Runbook completo** Ecco il runbook completo che utilizza il singolo file allegato: ``` description: Process EC2 instance data using single file attachment schemaVersion: '0.3' assumeRole: '{{AutomationAssumeRole}}' parameters: AutomationAssumeRole: type: String description: (Required) IAM role for automation execution InstanceId: type: String description: (Required) EC2 instance ID to process files: process_instance.py: checksums: sha256: "abc123def456..." mainSteps: - name: processInstance action: aws:executeScript inputs: Runtime: python3.11 Handler: process_instance.process_instance_data Attachment: process_instance.py InputPayload: instanceId: '{{InstanceId}}' outputs: - Type: StringMap Name: InstanceData Selector: $.Payload outputs: - processInstance.InstanceData ``` ### Esempio 2: pacchetto multimodulo Questo esempio dimostra l'utilizzo di un pacchetto zip contenente numerosi moduli Python per operazioni complesse con bucket S3. **Struttura del pacchetto** Crea un pacchetto zip con la seguente struttura: ``` s3-operations.zip ├── main.py ├── utils/ │ ├── __init__.py │ ├── s3_helper.py │ └── validation.py └── config/ ├── __init__.py └── settings.py ``` **main.py (punto di ingresso)** Lo script principale che orchestra le operazioni: ``` from utils.s3_helper import S3Operations from utils.validation import validate_bucket_name from config.settings import get_default_settings def cleanup_s3_bucket(events, context): """Clean up S3 bucket based on specified criteria.""" try: bucket_name = events.get('bucketName') max_age_days = events.get('maxAgeDays', 30) # Validate inputs if not validate_bucket_name(bucket_name): raise ValueError(f"Invalid bucket name: {bucket_name}") # Initialize S3 operations s3_ops = S3Operations() settings = get_default_settings() # Perform cleanup deleted_objects = s3_ops.delete_old_objects( bucket_name, max_age_days, settings['dry_run'] ) result = { 'bucketName': bucket_name, 'deletedCount': len(deleted_objects), 'deletedObjects': deleted_objects[:10], # Return first 10 for brevity 'dryRun': settings['dry_run'] } print(f"Cleanup completed for bucket {bucket_name}") return result except Exception as e: print(f"Error during S3 cleanup: {str(e)}") raise ``` ## Risoluzione dei problemi relativi agli allegati aws:executeScript Utilizza le seguenti linee guida per risolvere i problemi più comuni relativi agli allegati `aws:executeScript`: **Errori di importazione del modulo** Se ricevi errori di importazione, quando usi pacchetti multimodulo: + Assicurati di aver incluso un file `__init__.py` vuoto in ogni directory contenente i moduli Python. + Verifica che le istruzioni di importazione corrispondano all'effettiva struttura di file e directory nel pacchetto zip. + Utilizza le importazioni relative (ad esempio `from .utils import helper`) o le importazioni assolute (ad esempio `from utils import helper`) in modo coerente. **Errori per allegati non trovati** Se l'automazione non riesce a trovare l'allegato: + Verifica che il valore del `Attachment` parametro corrisponda esattamente alla chiave nella tua sezione `files`. + Controlla che il percorso del bucket S3 e il nome del file siano corretti nella sezione `files`. + Assicurati che il tuo ruolo di automazione disponga dell'autorizzazione `s3:GetObject` per la posizione dell'allegato S3. + Verifica che il checksum nel runbook corrisponda al checksum effettivo del file. **Errori della funzione del gestore** Se ricevi errori relativi al gestore: + Per Python: utilizza il formato `filename.function_name` nel parametro `Handler` (ad esempio `main.process_data`). + Assicurati che la funzione del gestore accetti esattamente due parametri: `events` e `context`. + Per PowerShell: non specificare un `Handler` parametro; lo script viene eseguito direttamente. **Errori di esecuzione dello script** Se lo script fallisce durante l'esecuzione: + Controlla la cronologia di esecuzione dell'automazione per messaggi di errore dettagliati e tracce dello stack. + Usa `print()` le istruzioni (Python) o `Write-Information` (PowerShell) per aggiungere l'output di debug. + Verifica che tutte le AWS autorizzazioni richieste siano concesse al tuo ruolo di automazione. + Testa la logica dello script localmente prima di assemblarlo come allegato. **Codici di uscita e gestione degli errori** Per gestire correttamente gli errori e restituire i codici di uscita: + In Python: usa `raise Exception("error message")` per indicare l'errore dello script. + In PowerShell: usa `throw "error message"` o `Write-Error` per indicare un errore. + Restituisci dati strutturati dalle tue funzioni per fornire success/failure informazioni dettagliate. + Usa i blocchi try-catch per gestire le eccezioni agilmente e fornire messaggi di errore significativi.