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 Protokollierung der Automation-Aktionsausgabe mit CloudWatch Logs.

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 PowerShell vorinstallierten 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

Anhänge bieten eine leistungsstarke Möglichkeit, komplexe Skripts, mehrere Module und externe Abhängigkeiten zu verpacken und für aws:executeScript-Aktionen wiederzuverwenden. Sie können Anhänge in folgenden Fällen verwenden:

Struktur und Verpackung von Anhängen

Sie können 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

Erstellen von Runbooks mit Anhängen

Gehen Sie wie folgt vor, um Runbooks zu erstellen, die Anhänge verwenden:

Beispiele für aws:executeScript-Anhänge

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

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 folgendem 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 vollständige 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:
    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

In diesem Beispiel wird ein ZIP-Paket, das mehrere Python-Module enthält, für komplexe S3-Bucket-Vorgänge verwendet.

Paketstruktur

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 (Eintrittspunkt)

Das Hauptskript, das die Vorgänge 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

Fehlerbehebung bei aws:executeScript-Anhängen

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

Modulimportfehler

Wenn Sie bei Paketen mit mehreren Modulen Importfehler erhalten:

Anhang kann nicht gefunden werden

Wenn Ihre Automatisierung den Anhang nicht finden kann:

Handler-Funktionsfehler

Wenn Fehler im Zusammenhang mit dem Handler auftreten:

Fehler bei der Skriptausführung

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

Beendigungscodes und Fehlerbehandlung

Gehen Sie wie folgt vor, um Fehler zu bearbeiten und Beendigungscodes zurückzugeben: