

• AWS Systems Manager CloudWatch Dasbor tidak akan lagi tersedia setelah 30 April 2026. Pelanggan dapat terus menggunakan CloudWatch konsol Amazon untuk melihat, membuat, dan mengelola CloudWatch dasbor Amazon mereka, seperti yang mereka lakukan hari ini. Untuk informasi selengkapnya, lihat [dokumentasi CloudWatch Dasbor Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). 

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# `aws:executeScript` – Jalankan skrip
<a name="automation-action-executeScript"></a>

Menjalankan Python atau PowerShell skrip yang disediakan menggunakan runtime dan handler yang ditentukan. Setiap `aws:executeScript` tindakan dapat menjalankan hingga durasi maksimum 600 detik (10 menit). Anda dapat membatasi batas waktu dengan menentukan `timeoutSeconds` parameter untuk `aws:executeScript` langkah.

Gunakan pernyataan pengembalian dalam fungsi Anda untuk menambahkan output ke payload keluaran Anda. Untuk contoh mendefinisikan output untuk `aws:executeScript` tindakan Anda, lihat. [Contoh 2: Runbook berskrip](automation-authoring-runbooks-scripted-example.md) Anda juga dapat mengirim output dari `aws:executeScript` tindakan di runbook ke grup CloudWatch log Amazon Logs yang Anda tentukan. Untuk informasi selengkapnya, lihat [Keluaran tindakan Otomasi Pencatatan dengan CloudWatch Log](automation-action-logging.md).

Jika Anda ingin mengirim output dari `aws:executeScript` tindakan ke CloudWatch Log, atau jika skrip yang Anda tentukan untuk `aws:executeScript` tindakan memanggil operasi AWS API, peran layanan AWS Identity and Access Management (IAM) (atau mengambil peran) selalu diperlukan untuk menjalankan runbook.

**catatan**  
`aws:executeScript`Tindakan ini tidak mendukung percobaan ulang pelambatan otomatis. Jika skrip Anda membuat panggilan AWS API yang mungkin dibatasi, Anda harus menerapkan logika coba ulang Anda sendiri dalam kode skrip Anda.

`aws:executeScript`Tindakan ini berisi modul PowerShell Core prainstal berikut:
+ Microsoft. PowerShell.Tuan rumah
+ Microsoft. PowerShell.Manajemen
+ Microsoft. PowerShell.Keamanan
+ Microsoft. PowerShell.Utilitas
+ PackageManagement
+ PowerShellGet

Untuk menggunakan modul PowerShell Core yang tidak diinstal sebelumnya, skrip Anda harus menginstal modul dengan `-Force` bendera, seperti yang ditunjukkan pada perintah berikut. `AWSPowerShell.NetCore`Modul tidak didukung. Ganti *ModuleName* dengan modul yang ingin Anda instal.

```
Install-Module ModuleName -Force
```

Untuk menggunakan cmdlet PowerShell Core dalam skrip Anda, sebaiknya gunakan `AWS.Tools` modul, seperti yang ditunjukkan pada perintah berikut. Ganti masing-masing *example resource placeholder* dengan informasi Anda sendiri.
+ cmdlet Amazon S3.

  ```
  Install-Module AWS.Tools.S3 -Force
  Get-S3Bucket -BucketName amzn-s3-demo-bucket
  ```
+ cmdlet Amazon EC2.

  ```
  Install-Module AWS.Tools.EC2 -Force
  Get-EC2InstanceStatus -InstanceId instance-id
  ```
+ Umum, atau layanan AWS Tools for Windows PowerShell cmdlet independen.

  ```
  Install-Module AWS.Tools.Common -Force
  Get-AWSRegion
  ```

Jika skrip Anda menginisialisasi objek baru selain menggunakan cmdlet PowerShell Core, Anda juga harus mengimpor modul seperti yang ditunjukkan pada perintah berikut.

```
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
```

Untuk contoh menginstal dan mengimpor `AWS.Tools` modul, dan menggunakan cmdlet PowerShell Core di runbook, lihat. [Pengalaman desain visual untuk runbook Otomasi](automation-visual-designer.md)

**Input**  
Berikan informasi yang diperlukan untuk menjalankan skrip Anda. Ganti masing-masing *example resource placeholder* dengan informasi Anda sendiri.

**catatan**  
Lampiran untuk skrip Python dapat berupa file.py atau file.zip yang berisi skrip. PowerShell skrip harus disimpan dalam file.zip.

------
#### [ 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"
    }
}
```

------

Waktu Aktif  
Bahasa runtime yang akan digunakan untuk menjalankan skrip yang disediakan. `aws:executeScript`mendukung runtime dalam tabel berikut.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/systems-manager/latest/userguide/automation-action-executeScript.html)
Tipe: String  
Diperlukan: Ya  
Untuk runtime python, lingkungan menyediakan memori 512MB dan ruang disk 512MB. Untuk PowerShell runtime, lingkungan menyediakan memori 1024MB dan ruang disk 512MB.

Handler  
Nama fungsi Anda. Anda harus memastikan fungsi yang didefinisikan dalam handler memiliki dua parameter, `events` dan `context`. PowerShell Runtime tidak mendukung parameter ini.  
Tipe: String  
Diperlukan: Ya (Python) \$1 Tidak didukung () PowerShell

InputPayload  
Objek JSON atau YAML yang akan diteruskan ke parameter handler pertama. Ini dapat digunakan untuk melewatkan data input ke script.  
Jenis: String  
Wajib: Tidak  

```
description: Tag an instance
schemaVersion: '0.3'
assumeRole: '{{AutomationAssumeRole}}'
parameters:
    AutomationAssumeRole:
        type: String
        description: '(Required) The Amazon Resource Name (ARN) of the IAM role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to operate this runbook.'
    InstanceId:
        type: String
        description: (Required) The ID of the EC2 instance you want to tag.
mainSteps:
  - name: tagInstance
    action: 'aws:executeScript'
    inputs:
        Runtime: "python3.11"
        Handler: tagInstance
        InputPayload:
            instanceId: '{{InstanceId}}'
        Script: |-
          def tagInstance(events,context):
            import boto3

            #Initialize client
            ec2 = boto3.client('ec2')
            instanceId = events['instanceId']
            tag = {
                "Key": "Env",
                "Value": "ExamplePython"
            }
            print(f"Adding tag {tag} to instance id {instanceId}")
            ec2.create_tags(
                Resources=[instanceId],
                Tags=[tag]
            )
            return tag
    outputs:
      - Type: String
        Name: TagKey
        Selector: $.Payload.Key
outputs:
  - tagInstance.TagKey
```

```
description: Tag an instance
schemaVersion: '0.3'
assumeRole: '{{AutomationAssumeRole}}'
parameters:
  AutomationAssumeRole:
    type: String
    description: (Required) The Amazon Resource Name (ARN) of the IAM role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to operate this runbook.
  InstanceId:
    type: String
    description: (Required) The ID of the EC2 instance you want to tag.
mainSteps:
  - name: tagInstance
    action: aws:executeScript
    isEnd: true
    inputs:
      Runtime: PowerShell 7.4
      InputPayload:
        instanceId: '{{InstanceId}}'
      Script: |-
        Install-Module AWS.Tools.EC2 -Force
        Import-Module AWS.Tools.EC2

        $input = $env:InputPayload | ConvertFrom-Json

        $tag = New-Object Amazon.EC2.Model.Tag
        $tag.Key = "Env"
        $tag.Value = "ExamplePowerShell"

        Write-Information "Adding tag key: $($tag.Key) and value: $($tag.Value) to instance id $($input.instanceId)"
        New-EC2Tag -Resource $input.instanceId -Tag $tag

        return $tag
    outputs:
      - Type: String
        Name: TagKey
        Selector: $.Payload.Key
outputs:
  - tagInstance.TagKey
```

Skrip  
Skrip tertanam yang ingin Anda jalankan selama otomatisasi.  
Tipe: String  
Wajib: Tidak (Python) \$1 Ya () PowerShell

Lampiran  
Nama file skrip mandiri atau file .zip yang dapat dijalankan oleh tindakan. Tentukan nilai yang sama dengan `Name` file lampiran dokumen yang Anda tentukan dalam parameter `Attachments` permintaan. Untuk informasi selengkapnya, lihat [Lampiran](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateDocument.html#systemsmanager-CreateDocument-request-Attachments) di *Referensi AWS Systems Manager API*. Jika Anda menyediakan skrip menggunakan lampiran, Anda juga harus menentukan `files` bagian di elemen tingkat atas runbook Anda. Untuk informasi selengkapnya, lihat [Skema versi 0.3](documents-schemas-features.md#automation-doc-syntax-examples).  
Guna menjalankan file untuk Python, gunakan `filename.method_name` format dalam `Handler`.   
Lampiran untuk skrip Python dapat berupa file.py atau file.zip yang berisi skrip. PowerShell skrip harus disimpan dalam file.zip.
Ketika menyertakan pustaka Python di lampiran anda, kami sarankan menambahkan sebuah `__init__.py` file kosong dalam setiap direktori modul. Hal ini mengizinkan Anda untuk mengimpor modul dari pustaka di lampiran dalam konten skrip Anda. Misalnya: `from library import module`  
Jenis: String  
Wajib: TidakOutput

Payload  
Representasi objek JSON dikembalikan oleh fungsi Anda. Hingga 100KB yang dikembalikan. Jika Anda menampilkan daftar, maksimal 100 item dikembalikan.

## Menggunakan lampiran dengan AWS: ExecuteScript
<a name="automation-action-executeScript-attachments"></a>

Lampiran menyediakan cara ampuh untuk mengemas dan menggunakan kembali skrip kompleks, beberapa modul, dan dependensi eksternal dengan tindakan Anda. `aws:executeScript` Gunakan lampiran saat Anda perlu:
+ Package beberapa modul Python atau PowerShell script bersama-sama.
+ Gunakan kembali logika skrip yang sama di beberapa runbook.
+ Sertakan pustaka atau dependensi eksternal dengan skrip Anda.
+ Jaga agar definisi runbook Anda tetap bersih dengan memisahkan logika skrip yang kompleks.
+ Bagikan paket skrip di seluruh tim atau alur kerja otomatisasi.

### Struktur lampiran dan kemasan
<a name="automation-action-executeScript-attachment-structure"></a>

Anda dapat melampirkan file tunggal atau paket zip yang berisi banyak file. Strukturnya tergantung pada kasus penggunaan Anda:

**Lampiran file tunggal**  
Untuk skrip sederhana, Anda dapat melampirkan satu `.py` file (Python) atau file `.zip` yang berisi skrip tunggal PowerShell.

**Paket multi-modul**  
Untuk otomatisasi kompleks yang memerlukan banyak modul, buat paket zip dengan struktur yang direkomendasikan berikut:

```
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
```

**penting**  
Untuk paket Python, Anda harus menyertakan `__init__.py` file kosong di setiap direktori yang berisi modul Python. Ini memungkinkan Anda untuk mengimpor modul menggunakan sintaks impor Python standar seperti. `from utils import helper_functions`

**PowerShell struktur paket**  
PowerShell lampiran harus dikemas dalam file zip dengan struktur berikut:

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

### Membuat runbook dengan lampiran
<a name="automation-action-executeScript-attachment-workflow"></a>

Ikuti langkah-langkah berikut untuk membuat runbook yang menggunakan lampiran:

1. **Unggah lampiran Anda ke Amazon S3**

   Unggah file skrip atau paket zip Anda ke bucket S3 yang dapat diakses oleh peran otomatisasi Anda. Perhatikan URI S3 untuk digunakan pada langkah berikutnya.

   ```
   aws s3 cp my-automation-package.zip s3://my-automation-bucket/scripts/
   ```

1. **Hitung checksum lampiran**

   Hitung checksum SHA-256 dari file lampiran Anda untuk verifikasi keamanan:

   ```
   # Linux/macOS
   shasum -a 256 my-automation-package.zip
   
   # Windows PowerShell
   Get-FileHash -Algorithm SHA256 my-automation-package.zip
   ```

1. **Tentukan bagian file di runbook Anda**

   Tambahkan `files` bagian di tingkat atas runbook Anda untuk mereferensikan lampiran Anda:

   ```
   files:
     my-automation-package.zip:
       checksums:
         sha256: "your-calculated-checksum-here"
   ```

1. **Referensikan lampiran di langkah ExecuteScript Anda**

   Gunakan `Attachment` parameter untuk mereferensikan file yang Anda unggah:

   ```
   - name: runMyScript
     action: aws:executeScript
     inputs:
       Runtime: python3.11
       Handler: main.process_data
       Attachment: my-automation-package.zip
       InputPayload:
         inputData: "{{InputParameter}}"
   ```

## AWS: Contoh lampiran executeScript
<a name="automation-action-executeScript-examples"></a>

Contoh berikut menunjukkan berbagai cara untuk menggunakan lampiran dengan `aws:executeScript` tindakan.

### Contoh 1: Lampiran file tunggal
<a name="automation-action-executeScript-single-file-example"></a>

Contoh ini menunjukkan bagaimana menggunakan file Python tunggal sebagai lampiran untuk memproses data instans EC2.

**File lampiran: process\$1instance.py**  
Buat file Python dengan konten berikut:

```
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 lengkap**  
Berikut adalah runbook lengkap yang menggunakan lampiran file tunggal:

```
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
```

### Contoh 2: Paket multi-modul
<a name="automation-action-executeScript-multi-module-example"></a>

Contoh ini menunjukkan penggunaan paket zip yang berisi beberapa modul Python untuk operasi bucket S3 yang kompleks.

**Struktur Package**  
Buat paket zip dengan struktur berikut:

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

**main.py (titik masuk)**  
Skrip utama yang mengatur operasi:

```
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
```

## Pemecahan masalah AWS: Lampiran ExecuteScript
<a name="automation-action-executeScript-troubleshooting"></a>

Gunakan panduan berikut untuk menyelesaikan masalah umum dengan `aws:executeScript` lampiran:

**Kesalahan impor modul**  
Jika Anda menerima kesalahan impor saat menggunakan paket multi-modul:
+ Pastikan Anda telah menyertakan `__init__.py` file kosong di setiap direktori yang berisi modul Python.
+ Verifikasi bahwa pernyataan impor Anda cocok dengan struktur file dan direktori yang sebenarnya dalam paket zip Anda.
+ Gunakan impor relatif (misalnya,`from .utils import helper`) atau impor absolut (misalnya,`from utils import helper`) secara konsisten.

**Lampiran tidak ditemukan kesalahan**  
Jika otomatisasi Anda gagal menemukan lampiran:
+ Verifikasi bahwa nilai `Attachment` parameter sama persis dengan kunci di `files` bagian Anda.
+ Periksa apakah jalur bucket S3 dan nama file Anda sudah benar di `files` bagian tersebut.
+ Pastikan peran otomatisasi Anda memiliki `s3:GetObject` izin untuk lokasi lampiran S3.
+ Verifikasi bahwa checksum di runbook Anda cocok dengan checksum file yang sebenarnya.

**Kesalahan fungsi handler**  
Jika Anda menerima kesalahan terkait penangan:
+ Untuk Python: Gunakan format `filename.function_name` dalam `Handler` parameter (misalnya,`main.process_data`).
+ Pastikan fungsi handler Anda menerima tepat dua parameter: `events` dan. `context`
+ Untuk PowerShell: Jangan tentukan `Handler` parameter; skrip berjalan secara langsung.

**Kegagalan eksekusi skrip**  
Jika skrip Anda gagal selama eksekusi:
+ Periksa riwayat eksekusi otomatisasi untuk pesan kesalahan terperinci dan jejak tumpukan.
+ Gunakan `print()` pernyataan (Python) atau `Write-Information` (PowerShell) untuk menambahkan output debugging.
+ Verifikasi bahwa semua AWS izin yang diperlukan diberikan ke peran otomatisasi Anda.
+ Uji logika skrip Anda secara lokal sebelum mengemasnya sebagai lampiran.

**Kode keluar dan penanganan kesalahan**  
Untuk menangani kesalahan dengan benar dan mengembalikan kode keluar:
+ Dalam Python: Gunakan `raise Exception("error message")` untuk menunjukkan kegagalan skrip.
+ Dalam PowerShell: Gunakan `throw "error message"` atau `Write-Error` untuk menunjukkan kegagalan.
+ Kembalikan data terstruktur dari fungsi Anda untuk memberikan success/failure informasi terperinci.
+ Gunakan blok try-catch untuk menangani pengecualian dengan anggun dan memberikan pesan kesalahan yang berarti.