aws:executeScript - Exécuter un script

Exécute le script python ou PowerShell fourni à l'aide du moteur d'exécution et du gestionnaire spécifiés. Chaque action aws:executeScript peut être exécutée jusqu'à une durée maximale de 600 secondes (10 minutes). Vous pouvez limiter le délai d'attente en spécifiant le paramètre timeoutSeconds pour une étape aws:executeScript.

Utilisez les instructions de retour dans votre fonction pour ajouter des sorties à votre charge utile de sortie. Pour des exemples de définition de sorties pour votre action aws:executeScript, consultez Exemple 2 : runbook scripté. Vous pouvez envoyer la sortie depuis des actions aws:executeScript dans vos runbooks vers le groupe de journaux Amazon CloudWatch Logs que vous spécifiez. Pour de plus amples informations, consultez Journalisation de la sortie d'actions Automation avec CloudWatch Logs.

Si vous voulez envoyer la sortie d'action aws:executeScript vers CloudWatch Logs, ou si les scripts que vous spécifiez pour l'action aws:executeScript appellent des opérations d'API AWS, une fonction du service AWS Identity and Access Management (IAM) (ou un rôle de responsable) est toujours nécessaire pour exécuter le runbook.

L'action aws:executeScript contient les modules PowerShell Core préinstallés suivants :

Pour utiliser des modules PowerShell Core qui ne sont pas préinstallés, votre script doit installer le module avec l'indicateur -Force, comme spécifié dans la commande suivante. Le module AWSPowerShell.NetCore n'est pas pris en charge. Remplacez ModuleName (Nom du module) par le module que vous souhaitez installer.

Install-Module ModuleName -Force

Pour utiliser les applets de commande PowerShell Core dans votre script, nous vous recommandons d'utiliser les modules AWS.Tools, comme indiqué dans les commandes suivantes. Remplacez chaque example resource placeholder (espace réservé pour les ressources) avec vos propres informations.

Si votre script initialise de nouveaux objets en plus de l'utilisation des applets de commande PowerShell Core, vous devez également importer le module comme indiqué dans la commande suivante.

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

Pour obtenir des exemples d'installation et d'importation de modules AWS.Tools et d'utilisation des applets de commande PowerShell Core dans les runbooks, veuillez consulter Expérience de conception visuelle pour les runbooks d’Automatisation.

Entrée

Fournissez les informations requises pour exécuter votre script. Remplacez chaque example resource placeholder (espace réservé pour les ressources) avec vos propres informations.

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

Utiliser des attachements avec aws:executeScript

Les attachements constituent un moyen puissant d’empaqueter et de réutiliser des scripts complexes, des modules multiples et des dépendances externes dans le cadre de vos actions aws:executeScript. Utilisez des attachements lorsque vous devez :

Structure d’empaquetage des attachements

Vous pouvez attacher des fichiers uniques ou des packages zip contenant plusieurs fichiers. La structure dépend de votre cas d’utilisation :

Attachement d’un seul fichier

Pour les scripts simples, vous pouvez attacher un seul fichier .py (Python) ou un fichier .zip contenant un seul script PowerShell.

Packages multimodules

Pour une automatisation complexe nécessitant plusieurs modules, créez un package zip avec la structure recommandée suivante :

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

Structure de package PowerShell

Les attachements PowerShell doivent être regroupés dans des fichiers zip dont la structure est la suivante :

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

Créer des dossiers d’exploitation avec des attachements

Pour créer des dossiers d’exploitation utilisant des attachements, procédez comme suit :

Exemples d’attachement aws:executeScript

Les exemples suivants illustrent les différentes manières d’utiliser les attachements avec l’action aws:executeScript.

Exemple 1 : attachement d’un seul fichier

Cet exemple montre comment utiliser un seul fichier Python en tant qu’attachement pour traiter les données d’une instance EC2.

Fichier d’attachement : process_instance.py

Créez un fichier Python avec le contenu suivant :

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

Dossier d’exploitation complet

Voici le dossier d’exploitation complet qui utilise l’attachement unique :

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

Exemple 2 : package multimodule

Cet exemple illustre l’utilisation d’un package zip contenant plusieurs modules Python pour des opérations de compartiment S3 complexes.

Structure du package

Créez un package zip avec la structure suivante :

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

main.py (point d’entrée)

Le script principal qui orchestre les opérations :

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

Résolution des attachements aws:executeScript

Suivez ces instructions pour résoudre les problèmes courants liés aux attachements aws:executeScript :

Erreurs d’importation de module

Si vous recevez des erreurs d’importation lors de l’utilisation de packages multimodules :

Erreurs d’attachement introuvable

Si votre automatisation ne trouve pas l’attachement :

Erreurs de fonction de gestionnaire

Si vous recevez des erreurs liées au gestionnaire :

Erreurs d’exécution de script

Si votre script échoue lors de son exécution :

Codes de sortie et gestion des erreurs

Pour gérer correctement les erreurs et renvoyer les codes de sortie :