aws:executeScript – Executa um script

Executa o script do Python ou PowerShell fornecido, usando o runtime e o handler especificados. Cada ação aws:executeScript pode ser executada por uma duração máxima de dez minutos (600 segundos). Você pode limitar o tempo limite especificando o parâmetro timeoutSeconds para uma etapa aws:executeScript.

Use instruções de retorno em sua função para adicionar saídas à carga útil da saída. Para obter exemplos de definição de saídas para sua ação aws:executeScript, consulte Exemplo 2: Runbook com script. Também é possível enviar o resultado das ações do aws:executeScript nos runbooks para o grupo de logs do Amazon CloudWatch Logs especificado. Para obter mais informações, consulte Registro de saída de ações do Automation em log com o CloudWatch Logs.

Se quiser enviar a saída de ações aws:executeScript ao CloudWatch Logs ou se os scripts que você especificar para ações aws:executeScript chamarem opções de API da AWS, um perfil de serviço do AWS Identity and Access Management (IAM) (ou uma função de recepção) sempre será necessário para executar o runbook.

A ação aws:executeScript contém os módulos pré-instalados do PowerShell Core a seguir.

Para usar módulos do PowerShell Core que não estão pré-instalados, o script deve instalar o módulo com o sinalizador -Force, conforme mostrado no comando a seguir. Não há suporte ao módulo AWSPowerShell.NetCore. Substitua ModuleName pelo nome do módulo que deseja instalar.

Install-Module ModuleName -Force

Para usar cmdlets do PowerShell Core em seu script, recomendamos o uso dos módulos AWS.Tools, conforme mostrado nos comandos a seguir. Substitua cada espaço reservado para recurso de exemplo por suas próprias informações.

Se o script inicializar novos objetos além de usar cmdlets do PowerShell Core, você também deverá importar o módulo conforme mostrado no comando a seguir.

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 obter exemplos de instalação e importação dos módulos AWS.Tools e do uso de cmdlets do PowerShell Core em runbooks, consulte Experiência de design visual para runbooks de automação.

Entrada

Forneça as informações necessárias para executar o script. Substitua cada espaço reservado para recurso de exemplo por suas próprias informações.

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

Usar anexos com aws:executeScript

Os anexos fornecem uma maneira poderosa de empacotar e reutilizar scripts complexos, vários módulos e dependências externas com suas ações aws:executeScript. Use anexos quando precisar:

Estrutura e empacotamento de anexos

Você pode anexar arquivos únicos ou pacotes zip contendo vários arquivos. A estrutura depende do seu caso de uso:

Anexos de arquivo único

Para scripts simples, você pode anexar um único arquivo .py (Python) ou um arquivo .zip contendo um único script PowerShell.

Pacotes de vários módulos

Para automação complexa que requer vários módulos, crie um pacote zip com a seguinte estrutura 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

Estrutura do pacote PowerShell

Os anexos PowerShell devem ser empacotados em arquivos zip com a seguinte estrutura:

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

Criar runbooks com anexos

Siga estas etapas para criar runbooks que usam anexos:

Exemplos de anexos aws:executeScript

Os exemplos a seguir demonstram maneiras diferentes de usar anexos com a ação aws:executeScript.

Exemplo 1: anexo de arquivo único

Este exemplo mostra como usar um único arquivo Python como anexo para processar dados da instância do EC2.

Arquivo do anexo: process_instance.py

Crie um arquivo Python com o seguinte conteúdo:

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

Aqui está o runbook completo que usa o anexo de arquivo ú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

Exemplo 2: pacote de vários módulos

Este exemplo demonstra o uso de um pacote zip contendo vários módulos Python para operações complexas de bucket do S3.

Estrutura do pacote

Crie um pacote zip com a seguinte estrutura:

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

main.py (ponto de entrada)

O script principal que orquestra as operações:

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

Solução de problemas de anexos aws:executeScript

Use as diretrizes a seguir para resolver problemas comuns com anexos aws:executeScript:

Erros de importação de módulos

Se você receber erros de importação ao usar pacotes com vários módulos:

Erros de anexo não encontrado

Se sua automação não conseguir encontrar o anexo:

Erros de função do manipulador

Se você receber erros relacionados ao manipulador:

Falhas de execução de script

Se o script falhar durante a execução:

Tratamento de erros e códigos de saída

Para lidar adequadamente com erros e códigos de saída de retorno: