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. 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 Output dell'operazione automazione del logging con CloudWatch Logs.

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.

L'aws:executeScriptazione contiene i seguenti moduli Core PowerShell preinstallati:

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.

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

Input

Fornisci le informazioni necessarie per eseguire lo script. Sostituisci ogni example resource placeholder con le tue informazioni.

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"
    }
}

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:

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

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:

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 dell' EC2 istanza.

File allegato: process_instance.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:

Errori per allegati non trovati

Se l'automazione non riesce a trovare l'allegato:

Errori della funzione del gestore

Se ricevi errori relativi al gestore:

Errori di esecuzione dello script

Se lo script fallisce durante l'esecuzione:

Codici di uscita e gestione degli errori

Per gestire correttamente gli errori e restituire i codici di uscita: