Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

aws:executeScript - Führen Sie ein Skript aus

Führt das bereitgestellte Python- oder PowerShell Skript mit der angegebenen Laufzeit und dem angegebenen Handler aus. Jede aws:executeScript-Aktion kann bis zu einer maximalen Dauer von 600 Sekunden (10 Minuten) laufen. Sie können die Zeitüberschreitung über den Parameter timeoutSeconds für einen aws:executeScript-Schritt limitieren.

Verwenden Sie Rückgabe-Anweisungen in Ihrer Funktion, um Ihrer Ausgabenutzlast Ausgaben hinzuzufügen. Für Beispiele zum Definieren von Ausgaben für Ihre aws:executeScript-Aktion, siehe Beispiel 2: Skriptbasiertes Runbook. Sie können auch die Ausgabe von aws:executeScript Aktionen in Ihren Runbooks an die von Ihnen angegebene Amazon CloudWatch Logs-Protokollgruppe senden. Weitere Informationen finden Sie unter Ausgabe von Automatisierungsaktionen mit CloudWatch Protokollen protokollieren.

Wenn Sie die Ausgabe von aws:executeScript Aktionen an CloudWatch Logs senden möchten oder wenn die Skripts, die Sie für aws:executeScript Aktionen angeben, AWS API-Operationen aufrufen, ist für die Ausführung des Runbooks immer eine AWS Identity and Access Management (IAM-) Service-Rolle (oder Übernahme einer Rolle) erforderlich.

Die aws:executeScript Aktion enthält die folgenden vorinstallierten PowerShell Core-Module:

Um PowerShell Core-Module zu verwenden, die nicht vorinstalliert sind, muss Ihr Skript das Modul mit der -Force Markierung installieren, wie im folgenden Befehl gezeigt. Das AWSPowerShell.NetCore-Modul wird nicht unterstützt. ModuleNameErsetzen Sie es durch das Modul, das Sie installieren möchten.

Install-Module ModuleName -Force

Um PowerShell Core-Cmdlets in Ihrem Skript zu verwenden, empfehlen wir die Verwendung der AWS.Tools Module, wie in den folgenden Befehlen gezeigt. Ersetzen Sie jeden example resource placeholder durch Ihre Informationen.

Wenn Ihr Skript zusätzlich zur Verwendung von PowerShell Core-Cmdlets neue Objekte initialisiert, müssen Sie das Modul auch importieren, wie im folgenden Befehl gezeigt.

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

Beispiele für die Installation und den Import von AWS.Tools Modulen und die Verwendung von PowerShell Core-Cmdlets in Runbooks finden Sie unter. Visuelle Designerfahrung für Automation-Runbooks

Eingabe

Geben Sie die zum Ausführen Ihres Skripts erforderlichen Informationen an. Ersetzen Sie jeden example resource placeholder durch Ihre Informationen.

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

Verwenden von Anhängen mit aws:ExecuteScript

Anlagen bieten eine leistungsstarke Möglichkeit, komplexe Skripts, mehrere Module und externe Abhängigkeiten zu verpacken und für Ihre Aktionen wiederzuverwenden. aws:executeScript Verwenden Sie Anlagen, wenn Sie:

Aufbau und Verpackung von Anhängen

Sie können entweder einzelne Dateien oder Zip-Pakete mit mehreren Dateien anhängen. Die Struktur hängt von Ihrem Anwendungsfall ab:

Einzelne Dateianhänge

Bei einfachen Skripten können Sie eine einzelne .py Datei (Python) oder eine .zip Datei, die ein einzelnes PowerShell Skript enthält, anhängen.

Pakete mit mehreren Modulen

Für komplexe Automatisierungen, die mehrere Module erfordern, erstellen Sie ein ZIP-Paket mit der folgenden empfohlenen Struktur:

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 Struktur des Pakets

PowerShell Anlagen müssen in ZIP-Dateien mit der folgenden Struktur gepackt werden:

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

Runbooks mit Anhängen erstellen

Gehen Sie wie folgt vor, um Runbooks zu erstellen, die Anlagen verwenden:

aws:ExecuteScript-Anhangsbeispiele

Die folgenden Beispiele zeigen verschiedene Möglichkeiten, Anlagen mit der Aktion zu verwenden. aws:executeScript

Beispiel 1: Einzelner Dateianhang

Dieses Beispiel zeigt, wie eine einzelne Python-Datei als Anlage zur Verarbeitung von EC2 Instanzdaten verwendet wird.

Anhangsdatei: process_instance.py

Erstellen Sie eine Python-Datei mit dem folgenden Inhalt:

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

Vollständiges Runbook

Hier ist das komplette Runbook, das den einzelnen Dateianhang verwendet:

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

Beispiel 2: Paket mit mehreren Modulen

Dieses Beispiel zeigt die Verwendung eines Zip-Pakets mit mehreren Python-Modulen für komplexe S3-Bucket-Operationen.

Aufbau Package

Erstellen Sie ein Zip-Paket mit der folgenden Struktur:

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

main.py (Einstiegspunkt)

Das Hauptskript, das die Operationen orchestriert:

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

Problembehandlung bei AWS:ExecuteScript-Anhängen

Verwenden Sie die folgenden Anleitungen, um häufig auftretende Probleme mit Anhängen zu lösen: aws:executeScript

Fehler beim Import von Modulen

Wenn Sie Importfehler erhalten, wenn Sie Pakete mit mehreren Modulen verwenden:

Fehler „Anlage nicht gefunden“

Wenn Ihre Automatisierung den Anhang nicht finden kann:

Fehler in der Handler-Funktion

Wenn Sie Fehler im Zusammenhang mit dem Handler erhalten:

Fehler bei der Ausführung des Skripts

Wenn Ihr Skript während der Ausführung fehlschlägt:

Exit-Codes und Fehlerbehandlung

Um Fehler richtig zu behandeln und Exit-Codes zurückzugeben: