Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

aws:executeScript - Exécuter un script

Exécute le Python ou le PowerShell script fourni à l'aide du runtime 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 également envoyer le résultat des aws:executeScript actions de vos runbooks vers le groupe de CloudWatch journaux Amazon Logs que vous spécifiez. Pour de plus amples informations, veuillez consulter Résultat de l'action d'automatisation de la CloudWatch journalisation avec journaux.

Si vous souhaitez envoyer le résultat des aws:executeScript actions vers CloudWatch Logs, ou si les scripts que vous spécifiez pour les aws:executeScript actions appellent des opérations d' AWS API, un rôle de service AWS Identity and Access Management (IAM) (ou un rôle assumé) est toujours requis pour exécuter le runbook.

L'aws:executeScriptaction 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'-Forceindicateur, comme indiqué dans la commande suivante. Le module AWSPowerShell.NetCore n'est pas pris en charge. ModuleNameRemplacez-le 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 AWS.Tools modules, comme indiqué dans les commandes suivantes. Remplacez chaque example resource placeholder par vos propres informations.

Si votre script initialise de nouveaux objets en plus d'utiliser les 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 des exemples d'installation et d'importation de AWS.Tools modules, ainsi que d'utilisation d'applets de commande PowerShell Core dans des runbooks, consultez. 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 par 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"
    }
}

Utilisation de pièces jointes avec AWS:ExecuteScript

Les pièces jointes 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 aws:executeScript actions. Utilisez des pièces jointes lorsque vous devez :

Structure de fixation et emballage

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

Pièces jointes à un seul fichier

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

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

PowerShell structure du package

PowerShell les pièces jointes doivent être regroupées 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éation de runbooks avec pièces jointes

Pour créer des runbooks utilisant des pièces jointes, procédez comme suit :

AWS:Exemples de pièces jointes ExecuteScript

Les exemples suivants illustrent les différentes manières d'utiliser les pièces jointes avec l'aws:executeScriptaction.

Exemple 1 : pièce jointe à un seul fichier

Cet exemple montre comment utiliser un seul fichier Python comme pièce jointe pour traiter les données d'une EC2 instance.

Fichier joint : 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

Runbook complet

Voici le runbook complet qui utilise la pièce jointe 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 problèmes liés à AWS : ExecuteScript

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

Erreurs d'importation du module

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

Erreurs relatives à la pièce jointe non trouvée

Si votre système automatique ne trouve pas la pièce jointe :

Erreurs de fonction du gestionnaire

Si vous recevez des erreurs liées au gestionnaire :

Échec de l'exécution du 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 :