aws:executeScript: ejecutar un script

Ejecuta el script Python o PowerShell proporcionado mediante el uso del tiempo de ejecución y el controlador especificados. Cada acción aws:executeScript puede ejecutarse hasta un máximo de 600 segundos (10 minutos). Puede limitar el tiempo de espera mediante la especificación del parámetro timeoutSeconds para un paso aws:executeScript.

Utilice instrucciones de devolución en la función para agregar salidas a la carga útil de salida. Para ver ejemplos sobre cómo definir salidas para la acción aws:executeScript, consulte Ejemplo 2: manual de procedimientos con scripts. También puede enviar la salida de acciones aws:executeScript de los manuales de procedimientos al grupo de registros de Amazon CloudWatch Logs que especifique. Para obtener más información, consulte Registro de salida de acción de Automation con CloudWatch Logs.

Si desea enviar la salida desde acciones aws:executeScript a los Registros de CloudWatch o si los scripts que especifica para la llamada de acciones aws:executeScript las operaciones de la API de AWS, siempre se requiere un rol de servicio de AWS Identity and Access Management (IAM) (o asumir un rol) para ejecutar el manual de procedimientos.

La acción aws:executeScript contiene los siguientes módulos de PowerShell Core preinstalados:

Para utilizar módulos de PowerShell Core que no estén preinstalados, el script debe instalar el módulo con la marca -Force, como se muestra en el siguiente comando. No se admite el módulo AWSPowerShell.NetCore. Reemplace ModuleName con el módulo que desee instalar.

Install-Module ModuleName -Force

Para utilizar cmdlets de PowerShell Core en el script, se recomienda utilizar los módulos de AWS.Tools, como se muestra en los siguientes comandos. Reemplace cada example resource placeholder con su propia información.

Si el script inicializa nuevos objetos además de usar cmdlets de PowerShell Core, también debe importar el módulo como se muestra en el siguiente comando.

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

Para obtener ejemplos de instalación e importación de módulos de AWS.Tools, y de uso de cmdlets de PowerShell Core en los manuales de procedimientos, consulte Experiencia de diseño visual para manuales de procedimientos de automatización.

Input

Proporcione la información necesaria para ejecutar el script. Reemplace cada example resource placeholder con su propia información.

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

Uso de archivos adjuntos con aws:executeScript

Los archivos adjuntos proporcionan una forma eficaz de empaquetar y reutilizar scripts complejos, varios módulos y dependencias externas con sus acciones aws:executeScript. Use archivos adjuntos cuando necesite hacer lo siguiente:

Estructura y empaquetado de los archivos adjuntos

Puede adjuntar archivos individuales o paquetes zip que contengan varios archivos. La estructura depende de su caso de uso:

Archivos adjuntos de un único archivo

En el caso de scripts sencillos, puede adjuntar un único archivo .py (Python) o un archivo .zip que contenga un único script de PowerShell.

Paquetes de varios módulos

Para una automatización compleja que requiera varios módulos, cree un paquete zip con la siguiente estructura recomendada:

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

Estructura de paquetes de PowerShell

Los archivos adjuntos de PowerShell deben empaquetarse en archivos zip con la siguiente estructura:

my-powershell-package.zip
├── Main.ps1                  # Entry point script
├── Modules/
│   ├── HelperFunctions.ps1   # Utility functions
│   └── AWSOperations.ps1     # AWS-specific operations
└── Config/
    └── Settings.ps1          # Configuration settings

Crear manuales de procedimientos con archivos adjuntos

Siga estos pasos para crear manuales de procedimientos que utilicen archivos adjuntos:

Ejemplos de archivos adjuntos aws:executeScript

Los siguientes ejemplos muestran diferentes maneras de usar los archivos adjuntos con la acción aws:executeScript.

Ejemplo 1: Archivo adjunto único

En este ejemplo, se muestra cómo utilizar un único archivo Python como adjunto para procesar los datos de la instancia EC2.

Archivo adjunto: process_instance.py

Cree un archivo Python con el siguiente contenido:

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

Manual de procedimientos completo

Este es el manual de procedimientos completo que usa el archivo adjunto único:

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:
    sourceType: "S3"
    sourceInfo:
      path: "s3://my-automation-bucket/scripts/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

Ejemplo 2: Paquete de varios módulos

En este ejemplo, se muestra el uso de un paquete zip que contiene varios módulos de Python para operaciones complejas de bucket de S3.

Estructura del paquete

Cree un paquete zip con la siguiente estructura:

s3-operations.zip
├── main.py
├── utils/
│   ├── __init__.py
│   ├── s3_helper.py
│   └── validation.py
└── config/
    ├── __init__.py
    └── settings.py

main.py (punto de entrada)

El script principal que orquesta las operaciones:

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

Solución de problemas de aws:executeScript

Utilice la siguiente guía para resolver los problemas habituales relacionados con los archivos adjuntos aws:executeScript:

Errores de importación del módulo

Si recibe errores de importación al utilizar paquetes de varios módulos haga lo siguiente:

Errores de archivo adjunto no encontrado

Si la automatización no encuentra el archivo adjunto, haga lo siguiente:

Errores de función del controlador

Si recibe errores relacionados con el controlador, haga lo siguiente:

Errores de ejecución de scripts

Si el script falla durante la ejecución, haga lo siguiente:

Gestión de errores y códigos de salida

Para gestionar correctamente los errores y devolver los códigos de salida, haga lo siguiente: