• El panel de AWS Systems Manager CloudWatch dejará de estar disponible después del 30 de abril de 2026. Los clientes pueden seguir utilizando la consola de Amazon CloudWatch para ver, crear y administrar sus paneles de Amazon CloudWatch, tal y como lo hacen actualmente. Para obtener más información, consulte la [documentación del panel de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). # `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](automation-authoring-runbooks-scripted-example.md). 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](automation-action-logging.md). 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. **nota** La acción `aws:executeScript` no admite el reintento automático de limitación. Si el script realiza llamadas a la API de AWS que podrían estar limitadas, debe implementar su propia lógica de reintento en el código del script. La acción `aws:executeScript` contiene los siguientes módulos de PowerShell Core preinstalados: + Microsoft.PowerShell.Host + Microsoft.PowerShell.Management + Microsoft.PowerShell.Security + Microsoft.PowerShell.Utility + PackageManagement + PowerShellGet 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. + Cmdlets de Amazon S3 ``` Install-Module AWS.Tools.S3 -Force Get-S3Bucket -BucketName amzn-s3-demo-bucket ``` + Cmdlets de Amazon EC2 ``` Install-Module AWS.Tools.EC2 -Force Get-EC2InstanceStatus -InstanceId instance-id ``` + Cmdlets de AWS Tools for Windows PowerShell comunes o independientes del servicio ``` Install-Module AWS.Tools.Common -Force Get-AWSRegion ``` 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](automation-visual-designer.md). **Input** Proporcione la información necesaria para ejecutar el script. Reemplace cada *example resource placeholder* con su propia información. **nota** El archivo adjunto de un script de Python puede ser un archivo .py o uno .zip que contenga el script. Los scripts de PowerShell deben almacenarse en archivos .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" } } ``` ------ Tiempo de ejecución El tiempo de ejecución es el lenguaje que se debe usar para ejecutar el script proporcionado. `aws:executeScript` admite los tiempos de ejecución de la siguiente tabla. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/systems-manager/latest/userguide/automation-action-executeScript.html) Tipo: cadena Obligatorio: sí Para los tiempos de ejecución de Python, el entorno proporciona 512 MB de memoria y 512 MB de espacio en disco. Para los tiempos de ejecución de PowerShell, el entorno proporciona 1024 MB de memoria y 512 MB de espacio en disco. Controlador Nombre de la función. Debe asegurarse de que la función definida en el controlador tenga dos parámetros, `events` y `context`. El tiempo de ejecución de PowerShell no admite este parámetro. Tipo: cadena Requerido: Sí (Python) \$1 No admitido (PowerShell) InputPayload Un objeto JSON o YAML que se pasará al primer parámetro del controlador. Se puede usar para pasar los datos de entrada al script. Tipo: cadena Requerido: 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 Un script insertado que desea ejecutar durante la automatización. Tipo: cadena Requerido: No (Python) \$1 Sí (PowerShell) Archivo adjunto Nombre de un archivo de script independiente o archivo .zip que puede invocarse mediante la acción. Especifique el mismo valor que el `Name` del archivo adjunto de documento que especifique en el parámetro de solicitud `Attachments`. Para obtener más información, consulte [Archivos adjuntos](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateDocument.html#systemsmanager-CreateDocument-request-Attachments) en la *referencia de la API de AWS Systems Manager*. Si proporciona un script mediante un archivo adjunto, también debe definir una sección `files` en los elementos de nivel superior del manual de procedimientos. Para obtener más información, consulte [Versión de esquema 0.3](documents-schemas-features.md#automation-doc-syntax-examples). Si desea invocar un archivo para Python, use el formato `filename.method_name` en `Handler`. El archivo adjunto de un script de Python puede ser un archivo .py o uno .zip que contenga el script. Los scripts de PowerShell deben almacenarse en archivos .zip. Al incluir bibliotecas de Python en su archivo adjunto, recomendamos que agregue un archivo `__init__.py` vacío en cada directorio del módulo. Esto le permite importar los módulos desde la biblioteca del archivo adjunto dentro del contenido de su script. Por ejemplo: `from library import module` Tipo: cadena Requerido: noOutput Carga La representación JSON del objeto devuelta por su función. Se devuelven hasta 100 KB. Si genera una lista, incluirá un máximo de 100 elementos. ## 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: + Empaquetar varios módulos de Python o scripts de PowerShell juntos. + Reutilizar la misma lógica de script en varios manuales de procedimientos. + Incluir bibliotecas o dependencias externas en sus scripts. + Mantener limpia la definición del manual de procedimientos separando la lógica de los scripts complejos. + Compartir paquetes de scripts entre equipos o flujos de trabajo de automatización. ### 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 ``` **importante** Para los paquetes de Python, debe incluir un archivo `__init__.py` vacío en cada directorio que contenga los módulos de Python. Esto le permite importar módulos utilizando la sintaxis de importación estándar de Python, como `from utils import helper_functions`. **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: 1. **Cargar el archivo adjunto a Amazon S3** Cargue el archivo de script o el paquete zip en un bucket de S3 al que pueda acceder su rol de automatización. Observe el URI de S3 que se usará en el siguiente paso. ``` aws s3 cp my-automation-package.zip s3://my-automation-bucket/scripts/ ``` 1. **Calcular la suma de verificación del archivo adjunto** Calcule la suma de verificación SHA-256 de su archivo adjunto para la verificación de seguridad: ``` # Linux/macOS shasum -a 256 my-automation-package.zip # Windows PowerShell Get-FileHash -Algorithm SHA256 my-automation-package.zip ``` 1. **Definir la sección de archivos en su manual de procedimientos** Agregue una sección `files` en el nivel superior de su manual de procedimientos para hacer referencia a su archivo adjunto: ``` files: my-automation-package.zip: checksums: sha256: "your-calculated-checksum-here" ``` 1. **Hacer referencia al archivo adjunto en su paso de executeScript** Utilice el parámetro `Attachment` para hacer referencia al archivo cargado: ``` - name: runMyScript action: aws:executeScript inputs: Runtime: python3.11 Handler: main.process_data Attachment: my-automation-package.zip InputPayload: inputData: "{{InputParameter}}" ``` ## 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\$1instance.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: 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: + Asegúrese de haber incluido un archivo vacío `__init__.py` en cada directorio que contenga los módulos de Python. + Compruebe que las instrucciones de importación coincidan con la estructura real de archivos y directorios del paquete zip. + Utilice las importaciones relativas (por ejemplo, `from .utils import helper`) o las importaciones absolutas (por ejemplo, `from utils import helper`) de forma coherente. **Errores de archivo adjunto no encontrado** Si la automatización no encuentra el archivo adjunto, haga lo siguiente: + Compruebe que el valor del parámetro `Attachment` coincida exactamente con la clave de su sección `files`. + Compruebe que la ruta del bucket de S3 y el nombre del archivo sean correctos en la sección `files`. + Asegúrese de que su función de automatización tenga el permiso `s3:GetObject` para la ubicación de S3 del archivo adjunto. + Compruebe que la suma de verificación en su manual de procedimientos coincida con la suma de verificación real del archivo. **Errores de función del controlador** Si recibe errores relacionados con el controlador, haga lo siguiente: + Para Python: utilice el formato `filename.function_name` en el parámetro `Handler` (por ejemplo, `main.process_data`). + Asegúrese de que su función controladora acepte exactamente dos parámetros: `events` y `context`. + Para PowerShell: no especifique ningún parámetro `Handler`; el script se ejecuta directamente. **Errores de ejecución de scripts** Si el script falla durante la ejecución, haga lo siguiente: + Consulte el historial de ejecución de la automatización para ver los mensajes de error detallados y los seguimientos de la pila. + Use instrucciones `print()` (Python) o `Write-Information` (PowerShell) para agregar resultados de depuración. + Compruebe que se concedan todos los permisos de AWS necesarios a su función de automatización. + Pruebe la lógica del script localmente antes de empaquetarlo como un archivo adjunto. **Gestión de errores y códigos de salida** Para gestionar correctamente los errores y devolver los códigos de salida, haga lo siguiente: + En Python: use `raise Exception("error message")` para indicar un error en el script. + En PowerShell: utilice `throw "error message"` o `Write-Error` para indicar un error. + Devuelva datos estructurados de sus funciones para proporcionar información detallada sobre el éxito o el error. + Utilice bloques try-catch para gestionar las excepciones de manera elegante y proporcionar mensajes de error significativos.