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

# Membuat aplikasi untuk melakukan pemeliharaan database terjadwal
<a name="scheduled-task-app"></a>

Anda dapat menggunakan AWS Lambda untuk mengganti proses terjadwal seperti pencadangan sistem otomatis, konversi file, dan tugas pemeliharaan. Dalam contoh ini, Anda membuat aplikasi tanpa server yang melakukan pemeliharaan terjadwal rutin pada tabel DynamoDB dengan menghapus entri lama. Aplikasi ini menggunakan EventBridge Scheduler untuk menjalankan fungsi Lambda pada jadwal cron. Saat dipanggil, fungsi menanyakan tabel untuk item yang lebih tua dari satu tahun, dan menghapusnya. Fungsi mencatat setiap item yang dihapus di CloudWatch Log.

Untuk mengimplementasikan contoh ini, pertama buat tabel DynamoDB dan isi dengan beberapa data uji untuk fungsi Anda untuk query. Kemudian, buat fungsi Lambda Python dengan pemicu EventBridge Scheduler dan peran eksekusi IAM yang memberikan izin fungsi untuk membaca, dan menghapus, item dari tabel Anda.

![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/ExampleApps/cron_app.png)


**Tip**  
Jika Anda baru mengenal Lambda, kami sarankan Anda menyelesaikan tutorial [Buat fungsi Lambda pertama Anda](getting-started.md) sebelum membuat aplikasi contoh ini.

Anda dapat menerapkan aplikasi secara manual dengan membuat dan mengonfigurasi sumber daya dengan aplikasi. Konsol Manajemen AWS Anda juga dapat menerapkan aplikasi dengan menggunakan AWS Serverless Application Model (AWS SAM). AWS SAM adalah alat infrastruktur sebagai kode (IAc). Dengan IAc, Anda tidak membuat sumber daya secara manual, tetapi mendefinisikannya dalam kode dan kemudian menerapkannya secara otomatis.

Jika Anda ingin mempelajari lebih lanjut tentang menggunakan Lambda dengan IAc sebelum menerapkan aplikasi contoh ini, lihat. [Menggunakan Lambda dengan infrastruktur sebagai kode (IAc)](foundation-iac.md)

## Prasyarat
<a name="scheduled-task-app-prereqs"></a>

Sebelum Anda dapat membuat aplikasi contoh, pastikan Anda memiliki alat dan program baris perintah yang diperlukan diinstal.
+ **Python**

  Untuk mengisi tabel DynamoDB yang Anda buat untuk menguji aplikasi, contoh ini menggunakan skrip Python dan file CSV untuk menulis data ke dalam tabel. Pastikan Anda memiliki Python versi 3.8 atau yang lebih baru diinstal pada mesin Anda.
+ **AWS SAM CLI**

  Jika Anda ingin membuat tabel DynamoDB dan menerapkan aplikasi contoh AWS SAM menggunakan, Anda perlu menginstal CLI. AWS SAM Ikuti [petunjuk penginstalan](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) di *Panduan AWS SAM Pengguna*.
+ **AWS CLI**

  Untuk menggunakan skrip Python yang disediakan untuk mengisi tabel pengujian Anda, Anda harus menginstal dan mengkonfigurasi file. AWS CLI Ini karena skrip menggunakan AWS SDK untuk Python (Boto3), yang membutuhkan akses ke kredensil AWS Identity and Access Management (IAM) Anda. Anda juga perlu AWS CLI diinstal untuk menyebarkan sumber daya menggunakan AWS SAM. Instal CLI dengan mengikuti [petunjuk penginstalan](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) di *AWS Command Line Interface Panduan Pengguna*.
+ **Docker**

  Untuk menerapkan aplikasi menggunakan AWS SAM, Docker juga harus diinstal pada mesin build Anda. Ikuti petunjuk di [Instal Docker Engine](https://docs.docker.com/engine/install/) di situs web dokumentasi Docker.

## Mengunduh contoh file aplikasi
<a name="scheduled-task-app-download"></a>

Untuk membuat database contoh dan aplikasi pemeliharaan terjadwal, Anda perlu membuat file berikut di direktori proyek Anda:

**Contoh file database**
+ `template.yaml`- AWS SAM Template yang dapat Anda gunakan untuk membuat tabel DynamoDB
+ `sample_data.csv`- file CSV yang berisi data sampel untuk dimuat ke dalam tabel Anda
+ `load_sample_data.py`- skrip Python yang menulis data dalam file CSV ke dalam tabel

**File aplikasi pemeliharaan terjadwal**
+ `lambda_function.py`- kode fungsi Python untuk fungsi Lambda yang melakukan pemeliharaan database
+ `requirements.txt`- file manifes yang mendefinisikan dependensi yang dibutuhkan kode fungsi Python Anda
+ `template.yaml`- AWS SAM Template yang dapat Anda gunakan untuk menyebarkan aplikasi

**File uji**
+ `test_app.py`- skrip Python yang memindai tabel dan mengonfirmasi keberhasilan operasi fungsi Anda dengan mengeluarkan semua catatan yang lebih tua dari satu tahun

Perluas bagian berikut untuk melihat kode dan mempelajari lebih lanjut tentang peran setiap file dalam membuat dan menguji aplikasi Anda. Untuk membuat file di mesin lokal Anda, salin dan tempel kode di bawah ini.

### AWS SAM template (contoh tabel DynamoDB)
<a name="scheduled-task-app-table-yaml"></a>

Salin dan tempel kode berikut ke dalam file bernama`template.yaml`.

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM Template for DynamoDB Table with Order_number as Partition Key and Date as Sort Key

Resources:
  MyDynamoDBTable:
    Type: AWS::DynamoDB::Table
    DeletionPolicy: Retain
    UpdateReplacePolicy: Retain
    Properties:
      TableName: MyOrderTable
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: Order_number
          AttributeType: S
        - AttributeName: Date
          AttributeType: S
      KeySchema:
        - AttributeName: Order_number
          KeyType: HASH
        - AttributeName: Date
          KeyType: RANGE
      SSESpecification:
        SSEEnabled: true
      GlobalSecondaryIndexes:
        - IndexName: Date-index
          KeySchema:
            - AttributeName: Date
              KeyType: HASH
          Projection:
            ProjectionType: ALL
      PointInTimeRecoverySpecification:
        PointInTimeRecoveryEnabled: true

Outputs:
  TableName:
    Description: DynamoDB Table Name
    Value: !Ref MyDynamoDBTable
  TableArn:
    Description: DynamoDB Table ARN
    Value: !GetAtt MyDynamoDBTable.Arn
```

**catatan**  
AWS SAM template menggunakan konvensi penamaan standar`template.yaml`. Dalam contoh ini, Anda memiliki dua file template - satu untuk membuat database contoh dan satu lagi untuk membuat aplikasi itu sendiri. Simpan di sub-direktori terpisah di folder proyek Anda.

 AWS SAM Template ini mendefinisikan resource tabel DynamoDB yang Anda buat untuk menguji aplikasi Anda. Tabel menggunakan kunci utama `Order_number` dengan semacam kunci`Date`. Agar fungsi Lambda Anda menemukan item secara langsung berdasarkan tanggal, kami juga mendefinisikan [Indeks Sekunder Global bernama](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html). `Date-index`

*Untuk mempelajari selengkapnya tentang membuat dan mengonfigurasi tabel DynamoDB menggunakan `AWS::DynamoDB::Table` sumber daya, [AWS lihat: :DynamoDB: :Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) di Panduan Pengguna.AWS CloudFormation *

### Contoh file data database
<a name="scheduled-task-app-csv-file"></a>

Salin dan tempel kode berikut ke dalam file bernama`sample_data.csv`.

```
Date,Order_number,CustomerName,ProductID,Quantity,TotalAmount
2023-09-01,ORD001,Alejandro Rosalez,PROD123,2,199.98
2023-09-01,ORD002,Akua Mansa,PROD456,1,49.99
2023-09-02,ORD003,Ana Carolina Silva,PROD789,3,149.97
2023-09-03,ORD004,Arnav Desai,PROD123,1,99.99
2023-10-01,ORD005,Carlos Salazar,PROD456,2,99.98
2023-10-02,ORD006,Diego Ramirez,PROD789,1,49.99
2023-10-03,ORD007,Efua Owusu,PROD123,4,399.96
2023-10-04,ORD008,John Stiles,PROD456,2,99.98
2023-10-05,ORD009,Jorge Souza,PROD789,3,149.97
2023-10-06,ORD010,Kwaku Mensah,PROD123,1,99.99
2023-11-01,ORD011,Li Juan,PROD456,5,249.95
2023-11-02,ORD012,Marcia Oliveria,PROD789,2,99.98
2023-11-03,ORD013,Maria Garcia,PROD123,3,299.97
2023-11-04,ORD014,Martha Rivera,PROD456,1,49.99
2023-11-05,ORD015,Mary Major,PROD789,4,199.96
2023-12-01,ORD016,Mateo Jackson,PROD123,2,199.99
2023-12-02,ORD017,Nikki Wolf,PROD456,3,149.97
2023-12-03,ORD018,Pat Candella,PROD789,1,49.99
2023-12-04,ORD019,Paulo Santos,PROD123,5,499.95
2023-12-05,ORD020,Richard Roe,PROD456,2,99.98
2024-01-01,ORD021,Saanvi Sarkar,PROD789,3,149.97
2024-01-02,ORD022,Shirley Rodriguez,PROD123,1,99.99
2024-01-03,ORD023,Sofia Martinez,PROD456,4,199.96
2024-01-04,ORD024,Terry Whitlock,PROD789,2,99.98
2024-01-05,ORD025,Wang Xiulan,PROD123,3,299.97
```

File ini berisi beberapa contoh data uji untuk mengisi tabel DynamoDB Anda dengan format nilai dipisahkan koma (CSV) standar.

### Skrip Python untuk memuat data sampel
<a name="scheduled-task-app-load-script"></a>

Salin dan tempel kode berikut ke dalam file bernama`load_sample_data.py`.

```
import boto3
import csv
from decimal import Decimal

# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyOrderTable') 
print("DDB client initialized.")

def load_data_from_csv(filename):
    with open(filename, 'r') as file:
        csv_reader = csv.DictReader(file)
        for row in csv_reader:
            item = {
                'Order_number': row['Order_number'],
                'Date': row['Date'],
                'CustomerName': row['CustomerName'],
                'ProductID': row['ProductID'],
                'Quantity': int(row['Quantity']),
                'TotalAmount': Decimal(str(row['TotalAmount']))
            }
            table.put_item(Item=item)
            print(f"Added item: {item['Order_number']} - {item['Date']}")

if __name__ == "__main__":
    load_data_from_csv('sample_data.csv')
    print("Data loading completed.")
```

Script Python ini pertama kali menggunakan AWS SDK untuk Python (Boto3) untuk membuat koneksi ke tabel DynamoDB Anda. Kemudian iterasi di setiap baris dalam file CSV contoh-data, membuat item dari baris itu, dan menulis item ke tabel DynamoDB menggunakan boto3 SDK.

### Kode fungsi Python
<a name="scheduled-task-app-function-code"></a>

Salin dan tempel kode berikut ke dalam file bernama`lambda_function.py`.

```
import boto3
from datetime import datetime, timedelta
from boto3.dynamodb.conditions import Key, Attr
import logging

logger = logging.getLogger()
logger.setLevel("INFO")

def lambda_handler(event, context):
    # Initialize the DynamoDB client
    dynamodb = boto3.resource('dynamodb')
    
    # Specify the table name
    table_name = 'MyOrderTable'
    table = dynamodb.Table(table_name)
    
    # Get today's date
    today = datetime.now()
    
    # Calculate the date one year ago
    one_year_ago = (today - timedelta(days=365)).strftime('%Y-%m-%d')
    
    # Scan the table using a global secondary index
    response = table.scan(
        IndexName='Date-index',
        FilterExpression='#date < :one_year_ago',
        ExpressionAttributeNames={
            '#date': 'Date'
        },
        ExpressionAttributeValues={
            ':one_year_ago': one_year_ago
        }
    )
    
     # Delete old items
    with table.batch_writer() as batch:
        for item in response['Items']:
            Order_number = item['Order_number']
            batch.delete_item(
                Key={
                    'Order_number': Order_number,
                    'Date': item['Date']
                }
            )
            logger.info(f'deleted order number {Order_number}')
    
    # Check if there are more items to scan
    while 'LastEvaluatedKey' in response:
        response = table.scan(
            IndexName='DateIndex',
            FilterExpression='#date < :one_year_ago',
            ExpressionAttributeNames={
                '#date': 'Date'
            },
            ExpressionAttributeValues={
                ':one_year_ago': one_year_ago
            },
            ExclusiveStartKey=response['LastEvaluatedKey']
        )
        
        # Delete old items
        with table.batch_writer() as batch:
            for item in response['Items']:
                batch.delete_item(
                    Key={
                        'Order_number': item['Order_number'],
                        'Date': item['Date']
                    }
                )
    
    return {
        'statusCode': 200,
        'body': 'Cleanup completed successfully'
    }
```

Kode fungsi Python berisi fungsi [handler () `lambda_handler` yang dijalankan Lambda saat fungsi](python-handler.md) Anda dipanggil.

Ketika fungsi dipanggil oleh EventBridge Scheduler, ia menggunakan AWS SDK untuk Python (Boto3) untuk membuat koneksi ke tabel DynamoDB di mana tugas pemeliharaan terjadwal akan dilakukan. Kemudian menggunakan `datetime` pustaka Python untuk menghitung tanggal satu tahun yang lalu, sebelum memindai tabel untuk item yang lebih tua dari ini dan menghapusnya.

Perhatikan bahwa tanggapan dari kueri DynamoDB dan operasi pemindaian dibatasi hingga ukuran maksimum 1 MB. Jika respon lebih besar dari 1 MB, DynamoDB paginates data dan mengembalikan `LastEvaluatedKey` elemen dalam respon. Untuk memastikan bahwa fungsi kami memproses semua catatan dalam tabel, kami memeriksa keberadaan kunci ini dan terus melakukan pemindaian tabel dari posisi yang dievaluasi terakhir hingga seluruh tabel dipindai.

### `requirements.txt`file manifes
<a name="scheduled-task-app-dependencies"></a>

Salin dan tempel kode berikut ke dalam file bernama`requirements.txt`.

```
boto3
```

Untuk contoh ini, kode fungsi Anda hanya memiliki satu dependensi yang bukan bagian dari pustaka Python standar - SDK for Python (Boto3) yang digunakan fungsi untuk memindai dan menghapus item dari tabel DynamoDB.

**catatan**  
Versi SDK untuk Python (Boto3) disertakan sebagai bagian dari runtime Lambda, sehingga kode Anda akan berjalan tanpa menambahkan Boto3 ke paket penerapan fungsi Anda. Namun, untuk mempertahankan kontrol penuh dependensi fungsi Anda dan menghindari kemungkinan masalah dengan misalignment versi, praktik terbaik untuk Python adalah menyertakan semua dependensi fungsi dalam paket penerapan fungsi Anda. Lihat [Dependensi runtime dengan Python](python-package.md#python-package-dependencies) untuk mempelajari selengkapnya.

### AWS SAM template (aplikasi pemeliharaan terjadwal)
<a name="scheduled-task-app-table-yaml"></a>

Salin dan tempel kode berikut ke dalam file bernama`template.yaml`.

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM Template for Lambda function and EventBridge Scheduler rule

Resources:
  MyLambdaFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: ScheduledDBMaintenance
      CodeUri: ./
      Handler: lambda_function.lambda_handler
      Runtime: python3.11
      Architectures:
        - x86_64
      Events:
        ScheduleEvent:
          Type: ScheduleV2
          Properties:
            ScheduleExpression: cron(0 3 1 * ? *)
            Description: Run on the first day of every month at 03:00 AM
      Policies:
        - CloudWatchLogsFullAccess
        - Statement:
            - Effect: Allow
              Action:
                - dynamodb:Scan
                - dynamodb:BatchWriteItem
              Resource: !Sub 'arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/MyOrderTable'

  LambdaLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub /aws/lambda/${MyLambdaFunction}
      RetentionInDays: 30

Outputs:
  LambdaFunctionName:
    Description: Lambda Function Name
    Value: !Ref MyLambdaFunction
  LambdaFunctionArn:
    Description: Lambda Function ARN
    Value: !GetAtt MyLambdaFunction.Arn
```

**catatan**  
AWS SAM template menggunakan konvensi penamaan standar`template.yaml`. Dalam contoh ini, Anda memiliki dua file template - satu untuk membuat database contoh dan satu lagi untuk membuat aplikasi itu sendiri. Simpan di sub-direktori terpisah di folder proyek Anda.

 AWS SAM Template ini mendefinisikan resource untuk aplikasi Anda. Kami mendefinisikan fungsi Lambda menggunakan sumber daya. `AWS::Serverless::Function` Jadwal EventBridge Scheduler dan pemicu untuk memanggil fungsi Lambda dibuat dengan menggunakan `Events` properti sumber daya ini menggunakan tipe. `ScheduleV2` *Untuk mempelajari selengkapnya tentang menentukan jadwal EventBridge Penjadwal dalam AWS SAM templat, lihat [ScheduleV2](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-schedulev2.html) di Panduan Pengembang.AWS Serverless Application Model *

Selain fungsi Lambda dan jadwal EventBridge Scheduler, kami juga mendefinisikan grup CloudWatch log untuk fungsi Anda untuk mengirim catatan item yang dihapus ke.

### Skrip uji
<a name="scheduled-task-app-test-script"></a>

Salin dan tempel kode berikut ke dalam file bernama`test_app.py`.

```
import boto3
from datetime import datetime, timedelta
import json

# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')

# Specify your table name
table_name = 'YourTableName'
table = dynamodb.Table(table_name)

# Get the current date
current_date = datetime.now()

# Calculate the date one year ago
one_year_ago = current_date - timedelta(days=365)

# Convert the date to string format (assuming the date in DynamoDB is stored as a string)
one_year_ago_str = one_year_ago.strftime('%Y-%m-%d')

# Scan the table
response = table.scan(
    FilterExpression='#date < :one_year_ago',
    ExpressionAttributeNames={
        '#date': 'Date'
    },
    ExpressionAttributeValues={
        ':one_year_ago': one_year_ago_str
    }
)

# Process the results
old_records = response['Items']

# Continue scanning if we have more items (pagination)
while 'LastEvaluatedKey' in response:
    response = table.scan(
        FilterExpression='#date < :one_year_ago',
        ExpressionAttributeNames={
            '#date': 'Date'
        },
        ExpressionAttributeValues={
            ':one_year_ago': one_year_ago_str
        },
        ExclusiveStartKey=response['LastEvaluatedKey']
    )
    old_records.extend(response['Items'])

for record in old_records:
    print(json.dumps(record))

# The total number of old records should be zero.
print(f"Total number of old records: {len(old_records)}")
```

Skrip pengujian ini menggunakan AWS SDK untuk Python (Boto3) untuk membuat koneksi ke tabel DynamoDB Anda dan memindai item yang lebih tua dari satu tahun. Untuk mengonfirmasi apakah fungsi Lambda telah berjalan dengan sukses, pada akhir pengujian, fungsi mencetak jumlah catatan yang lebih tua dari satu tahun masih dalam tabel. Jika fungsi Lambda berhasil, jumlah catatan lama dalam tabel harus nol. 

## Membuat dan mengisi tabel contoh DynamoDB
<a name="scheduled-task-app-create-table"></a>

Untuk menguji aplikasi pemeliharaan terjadwal, pertama-tama Anda membuat tabel DynamoDB dan mengisinya dengan beberapa data sampel. Anda dapat membuat tabel baik secara manual menggunakan Konsol Manajemen AWS atau dengan menggunakan AWS SAM. Kami menyarankan Anda menggunakan AWS SAM untuk membuat dan mengkonfigurasi tabel dengan cepat menggunakan beberapa AWS CLI perintah.

------
#### [ Console ]

**Untuk membuat tabel DynamoDB**

1. Buka [halaman Tabel](https://console.aws.amazon.com/dynamodbv2/home#tables) di konsol DynamoDB.

1. Pilih **Buat tabel**.

1. Buat tabel dengan melakukan hal berikut:

   1. Di bawah **Rincian tabel**, untuk **nama Tabel**, masukkan**MyOrderTable**.

   1. Untuk **kunci Partition**, masukkan **Order\$1number** dan biarkan tipe sebagai **String**.

   1. Untuk **tombol Sort**, masukkan **Date** dan biarkan tipe sebagai **String**.

   1. Biarkan **pengaturan Tabel** diatur ke **Pengaturan default** dan pilih **Buat tabel**.

1. Ketika tabel Anda telah selesai dibuat dan **Statusnya** ditampilkan sebagai **Aktif**, buat indeks sekunder global (GSI) dengan melakukan hal berikut. Aplikasi Anda akan menggunakan GSI ini untuk mencari item secara langsung berdasarkan tanggal untuk menentukan apa yang akan dihapus.

   1. Pilih **MyOrderTable**dari daftar tabel.

   1. Pilih tab **Indeks**.

   1. Di bawah **Indeks sekunder global**, pilih **Buat indeks**.

   1. Di bawah **Detail indeks**, masukkan **Date** untuk **kunci Partition** dan biarkan **tipe Data** diatur ke **String**.

   1. Untuk **Nama indeks**, masukkan **Date-index**.

   1. Biarkan semua parameter lain diatur ke nilai defaultnya, gulir ke bagian bawah halaman, dan pilih **Buat indeks**.

------
#### [ AWS SAM ]

**Untuk membuat tabel DynamoDB**

1. Arahkan ke folder tempat Anda menyimpan `template.yaml` file untuk tabel DynamoDB. Perhatikan bahwa contoh ini menggunakan dua `template.yaml` file. Pastikan mereka disimpan dalam sub-folder terpisah dan bahwa Anda berada di folder yang benar berisi template untuk membuat tabel DynamoDB Anda.

1. Jalankan perintah berikut.

   ```
   sam build
   ```

   Perintah ini mengumpulkan artefak build untuk sumber daya yang ingin Anda terapkan dan menempatkannya dalam format dan lokasi yang tepat untuk menerapkannya.

1. Untuk membuat sumber daya DynamoDB yang ditentukan dalam `template.yaml` file, jalankan perintah berikut.

   ```
   sam deploy --guided
   ```

   Menggunakan `--guided` tanda berarti itu AWS SAM akan menunjukkan kepada Anda petunjuk untuk memandu Anda melalui proses penerapan. Untuk penyebaran ini, masukkan a `Stack name` dari**cron-app-test-db**, dan terima default untuk semua opsi lain dengan menggunakan Enter.

   Setelah AWS SAM selesai membuat sumber daya DynamoDB, Anda akan melihat pesan berikut.

   ```
   Successfully created/updated stack - cron-app-test-db in us-west-2
   ```

1. [Anda juga dapat mengonfirmasi bahwa tabel DynamoDB telah dibuat dengan membuka halaman Tabel dari konsol DynamoDB.](https://console.aws.amazon.com/dynamodbv2/home#tables) Anda harus melihat tabel bernama`MyOrderTable`.

------

Setelah membuat tabel, Anda selanjutnya menambahkan beberapa data sampel untuk menguji aplikasi Anda. File CSV yang `sample_data.csv` Anda unduh sebelumnya berisi sejumlah contoh entri yang terdiri dari nomor pesanan, tanggal, dan informasi pelanggan dan pesanan. Gunakan skrip python yang disediakan `load_sample_data.py` untuk menambahkan data ini ke tabel Anda.

**Untuk menambahkan data sampel ke tabel**

1. Arahkan ke direktori yang berisi `load_sample_data.py` file `sample_data.csv` dan. Jika file-file ini berada di direktori terpisah, pindahkan agar file tersebut disimpan di lokasi yang sama.

1. Buat lingkungan virtual Python untuk menjalankan skrip dengan menjalankan perintah berikut. Kami menyarankan Anda menggunakan lingkungan virtual karena pada langkah berikut Anda harus menginstal AWS SDK untuk Python (Boto3).

   ```
   python -m venv venv
   ```

1. Aktifkan lingkungan virtual dengan menjalankan perintah berikut.

   ```
   source venv/bin/activate
   ```

1. Instal SDK for Python (Boto3) di lingkungan virtual Anda dengan menjalankan perintah berikut. Skrip menggunakan pustaka ini untuk terhubung ke tabel DynamoDB Anda dan menambahkan item.

   ```
   pip install boto3
   ```

1. Jalankan skrip untuk mengisi tabel dengan menjalankan perintah berikut.

   ```
   python load_sample_data.py
   ```

   Jika skrip berjalan dengan sukses, skrip harus mencetak setiap item ke konsol saat memuat dan melaporkannya`Data loading completed`.

1. Nonaktifkan lingkungan virtual dengan menjalankan perintah berikut.

   ```
   deactivate
   ```

1. Anda dapat memverifikasi bahwa data telah dimuat ke tabel DynamoDB Anda dengan melakukan hal berikut:

   1. Buka halaman [Jelajahi item](https://console.aws.amazon.com/dynamodbv2/home#item-explorer) dari konsol DynamoDB dan pilih tabel Anda (). `MyOrderTable`

   1. Di panel **Item yang dikembalikan**, Anda akan melihat 25 item dari file CSV yang ditambahkan skrip ke tabel.

## Membuat aplikasi pemeliharaan terjadwal
<a name="scheduled-task-app-create-app"></a>

Anda dapat membuat dan menerapkan sumber daya untuk aplikasi contoh ini langkah demi langkah menggunakan Konsol Manajemen AWS atau dengan menggunakan AWS SAM. Dalam lingkungan produksi, kami menyarankan Anda menggunakan alat Infrustracture-as-Code (IAc) seperti AWS SAM menyebarkan aplikasi tanpa server secara berulang tanpa menggunakan proses manual.

Untuk contoh ini, ikuti petunjuk konsol untuk mempelajari cara mengonfigurasi setiap AWS sumber daya secara terpisah, atau ikuti AWS SAM petunjuk untuk menerapkan aplikasi dengan cepat menggunakan AWS CLI perintah.

------
#### [ Console ]

**Untuk membuat fungsi menggunakan Konsol Manajemen AWS**

Pertama, buat fungsi yang berisi kode starter dasar. Anda kemudian mengganti kode ini dengan kode fungsi Anda sendiri dengan menyalin dan menempelkan kode langsung di editor kode Lambda, atau dengan mengunggah kode Anda sebagai paket. `.zip` Untuk tugas ini, kami sarankan menyalin dan menempelkan kode.

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.

1. Pilih **Buat fungsi**.

1. Pilih **Penulis dari scratch**.

1. Di bagian **Informasi dasar**, lakukan hal berikut:

   1. Untuk **Nama fungsi**, masukkan `ScheduledDBMaintenance`.

   1. Untuk **Runtime** pilih versi Python terbaru.

   1. Untuk **Arsitektur**, pilih **x86\$164**.

1. Pilih **Buat fungsi**.

1. Setelah fungsi Anda dibuat, Anda dapat mengonfigurasi fungsi Anda dengan kode fungsi yang disediakan.

   1. Di panel **sumber Kode**, ganti kode Hello world yang dibuat Lambda dengan kode fungsi Python dari file yang Anda simpan `lambda_function.py` sebelumnya.

   1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda:  
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

**Untuk mengkonfigurasi memori fungsi dan batas waktu (konsol)**

1. Pilih tab **Konfigurasi** untuk fungsi Anda.

1. Di panel **konfigurasi Umum**, pilih **Edit**.

1. Atur **Memori** ke 256 MB dan **Timeout** menjadi 15 detik. Jika Anda memproses tabel besar dengan banyak catatan, misalnya dalam kasus lingkungan produksi, Anda dapat mempertimbangkan untuk mengatur **Timeout** ke jumlah yang lebih besar. Ini memberi fungsi Anda lebih banyak waktu untuk memindai, dan membersihkan database.

1. Pilih **Simpan**.

**Untuk mengkonfigurasi format log (konsol)**

Anda dapat mengonfigurasi fungsi Lambda untuk mengeluarkan log dalam teks tidak terstruktur atau format JSON. Kami menyarankan Anda menggunakan format JSON untuk log agar lebih mudah untuk mencari dan memfilter data log. Untuk mempelajari lebih lanjut tentang opsi konfigurasi log Lambda, lihat. [Mengkonfigurasi kontrol logging lanjutan untuk fungsi Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced)

1. Pilih tab **Konfigurasi** untuk fungsi Anda.

1. Pilih **Alat pemantauan dan operasi**.

1. Di panel **konfigurasi Logging**, pilih **Edit**.

1. Untuk **konfigurasi Logging**, pilih **JSON**.

1. Pilih **Simpan**.

**Untuk mengatur izin IAM**

Untuk memberikan fungsi Anda izin yang diperlukan untuk membaca dan menghapus item DynamoDB, Anda perlu menambahkan kebijakan ke peran [eksekusi](lambda-intro-execution-role.md) fungsi Anda yang menentukan izin yang diperlukan.

1. Buka tab **Konfigurasi**, lalu pilih **Izin** dari bilah navigasi kiri.

1. Pilih nama peran di bawah **Peran eksekusi**.

1. Di konsol IAM, pilih **Tambahkan izin**, lalu **Buat kebijakan sebaris**.

1. Gunakan editor JSON dan masukkan kebijakan berikut:  
****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "dynamodb:Scan",
                   "dynamodb:DeleteItem",
                   "dynamodb:BatchWriteItem"
               ],
               "Resource": "arn:aws:dynamodb:*:*:table/MyOrderTable"
           }
       ]
   }
   ```

1. Beri nama kebijakan**DynamoDBCleanupPolicy**, lalu buat.

**Untuk mengatur EventBridge Scheduler sebagai pemicu (konsol)**

1. Buka [konsol EventBridge ](https://console.aws.amazon.com/events/home).

1. **Di panel navigasi kiri, pilih **Penjadwal di bawah bagian Penjadwal**.**

1. Pilih **Buat jadwal**.

1. Konfigurasikan jadwal dengan melakukan hal berikut:

   1. Di bawah **nama Jadwal**, masukkan nama untuk jadwal Anda (misalnya,**DynamoDBCleanupSchedule**).

   1. Di bawah **Pola jadwal**, pilih **Jadwal berulang**.

   1. Untuk **jenis Jadwal** biarkan default sebagai **jadwal berbasis Cron**, lalu masukkan detail jadwal berikut:
      + **Menit**: **0**
      + **Jam**: **3**
      + **Hari bulan**: **1**
      + **Bulan**: **\$1**
      + **Hari dalam seminggu**: **?**
      + **Tahun**: **\$1**

      Saat dievaluasi, ekspresi cron ini berjalan pada hari pertama setiap bulan pukul 03:00 pagi.

   1. Untuk **jendela waktu Fleksibel**, pilih **Mati**.

1. Pilih **Berikutnya**.

1. Konfigurasikan pemicu untuk fungsi Lambda Anda dengan melakukan hal berikut:

   1. **Di panel **Detail target**, biarkan **API Target disetel ke target** **Templated**, lalu pilih AWS Lambda Invoke.**

   1. Di bawah **Invoke**, pilih fungsi Lambda Anda `ScheduledDBMaintenance` () dari daftar dropdown.

   1. Biarkan **Payload** kosong dan pilih **Berikutnya**.

   1. Gulir ke bawah ke **Izin** dan pilih **Buat peran baru untuk jadwal ini**. Saat Anda membuat jadwal EventBridge Scheduler baru menggunakan konsol, EventBridge Scheduler membuat kebijakan baru dengan izin yang diperlukan yang dibutuhkan jadwal untuk menjalankan fungsi Anda. *Untuk informasi selengkapnya tentang mengelola izin jadwal Anda, lihat Jadwal [berbasis cron. dalam Panduan Pengguna EventBridge Penjadwal](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html#cron-based).*

   1. Pilih **Berikutnya**.

1. Tinjau pengaturan Anda dan pilih **Buat jadwal** untuk menyelesaikan pembuatan jadwal dan pemicu Lambda.

------
#### [ AWS SAM ]

**Untuk menerapkan aplikasi menggunakan AWS SAM**

1. Arahkan ke folder tempat Anda menyimpan `template.yaml` file untuk aplikasi. Perhatikan bahwa contoh ini menggunakan dua `template.yaml` file. Pastikan mereka disimpan dalam sub-folder terpisah dan bahwa Anda berada di folder yang benar berisi template untuk membuat aplikasi.

1. Salin `requirements.txt` file `lambda_function.py` dan file yang Anda unduh sebelumnya ke folder yang sama. Lokasi kode yang ditentukan dalam AWS SAM template adalah`./`, yang berarti lokasi saat ini. AWS SAM akan mencari di folder ini untuk kode fungsi Lambda ketika Anda mencoba menerapkan aplikasi.

1. Jalankan perintah berikut.

   ```
   sam build --use-container
   ```

   Perintah ini mengumpulkan artefak build untuk sumber daya yang ingin Anda terapkan dan menempatkannya dalam format dan lokasi yang tepat untuk menerapkannya. Menentukan `--use-container` opsi membangun fungsi Anda di dalam wadah Docker seperti Lambda. Kami menggunakannya di sini sehingga Anda tidak perlu menginstal Python 3.12 di mesin lokal Anda agar build berfungsi.

1. Untuk membuat sumber daya Lambda dan EventBridge Scheduler yang ditentukan dalam `template.yaml` file, jalankan perintah berikut.

   ```
   sam deploy --guided
   ```

   Menggunakan `--guided` tanda berarti itu AWS SAM akan menunjukkan kepada Anda petunjuk untuk memandu Anda melalui proses penerapan. Untuk penyebaran ini, masukkan a `Stack name` dari**cron-maintenance-app**, dan terima default untuk semua opsi lain dengan menggunakan Enter.

   Setelah AWS SAM selesai membuat sumber daya Lambda dan EventBridge Scheduler, Anda akan melihat pesan berikut.

   ```
   Successfully created/updated stack - cron-maintenance-app in us-west-2
   ```

1. Anda juga dapat mengonfirmasi bahwa fungsi Lambda telah dibuat dengan membuka halaman [Fungsi konsol](https://console.aws.amazon.com/lambda/home#/functions) Lambda. Anda akan melihat fungsi bernama`ScheduledDBMaintenance`.

------

## Menguji aplikasi
<a name="scheduled-task-app-test-app"></a>

 Untuk menguji apakah jadwal Anda memicu fungsi Anda dengan benar, dan bahwa fungsi Anda membersihkan catatan dengan benar dari database, Anda dapat mengubah jadwal sementara untuk dijalankan sekali pada waktu tertentu. Anda kemudian dapat menjalankan `sam deploy` lagi untuk mengatur ulang jadwal pengulangan Anda agar berjalan sebulan sekali. 

**Untuk menjalankan aplikasi menggunakan Konsol Manajemen AWS**

1. Arahkan kembali ke halaman konsol EventBridge Scheduler.

1. Pilih jadwal Anda, lalu pilih **Edit**.

1. Di bagian **Pola jadwal**, di bawah **Perulangan**, pilih Jadwal **satu kali**.

1.  **Atur waktu pemanggilan Anda ke beberapa menit dari sekarang, tinjau pengaturan Anda, lalu pilih Simpan.** 

 Setelah jadwal berjalan dan memanggil targetnya, Anda menjalankan `test_app.py` skrip untuk memverifikasi bahwa fungsi Anda berhasil menghapus semua catatan lama dari tabel DynamoDB. 

**Untuk memverifikasi bahwa catatan lama dihapus menggunakan skrip Python**

1.  Di baris perintah Anda, arahkan ke folder tempat Anda menyimpan`test_app.py`. 

1. Jalankan penulisan.

   ```
   python test_app.py
   ```

    Jika berhasil, Anda akan melihat output berikut. 

   ```
   Total number of old records: 0
   ```

## Langkah selanjutnya
<a name="scheduled-task-app-next-steps"></a>

 Anda sekarang dapat memodifikasi EventBridge jadwal Scheduler untuk memenuhi persyaratan aplikasi khusus Anda. EventBridge Scheduler mendukung ekspresi jadwal berikut: cron, rate, dan jadwal satu kali. 

 Untuk informasi selengkapnya tentang ekspresi EventBridge jadwal penjadwal, lihat [Jenis jadwal](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html) di *Panduan Pengguna EventBridge Penjadwal*. [Manajemen Akses](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) di *Panduan Pengguna IAM*