

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

# Log dan pantau fungsi Node.js Lambda
<a name="nodejs-logging"></a>

AWS Lambda secara otomatis memonitor fungsi Lambda atas nama Anda dan mengirim log ke Amazon. CloudWatch Fungsi Lambda Anda dilengkapi dengan grup CloudWatch log Log dan aliran log untuk setiap instance fungsi Anda. Lingkungan runtime Lambda mengirimkan detail tentang setiap invokasi ke pengaliran log, dan menyampaikan log serta output lain dari kode fungsi Anda. Untuk informasi selengkapnya, lihat [Mengirim log fungsi Lambda ke Log CloudWatch](monitoring-cloudwatchlogs.md).

Halaman ini menjelaskan cara menghasilkan keluaran log dari kode fungsi Lambda Anda, dan mengakses log menggunakan AWS Command Line Interface, konsol Lambda, atau konsol. CloudWatch 

**Topics**
+ [Membuat fungsi yang mengembalikan log](#node-logging-output)
+ [Menggunakan kontrol logging lanjutan Lambda dengan Node.js](#node-js-logging-advanced)
+ [Melihat log di konsol Lambda](#nodejs-logging-console)
+ [Melihat log di CloudWatch konsol](#nodejs-logging-cwconsole)
+ [Melihat log menggunakan AWS Command Line Interface (AWS CLI)](#nodejs-logging-cli)
+ [Menghapus log](#nodejs-logging-delete)

## Membuat fungsi yang mengembalikan log
<a name="node-logging-output"></a>

Untuk menghasilkan log dari kode fungsi, Anda dapat menggunakan metode di [objek konsol](https://developer.mozilla.org/en-US/docs/Web/API/Console), atau pustaka pencatatan yang menulis ke `stdout` atau `stderr`. Contoh berikut mencatat nilai variabel lingkungan dan objek peristiwa.

**catatan**  
Kami menyarankan Anda menggunakan teknik seperti validasi input dan pengkodean output saat mencatat input. Jika Anda mencatat data input secara langsung, penyerang mungkin dapat menggunakan kode Anda untuk membuat gangguan sulit dideteksi, memalsukan entri log, atau melewati monitor log. Untuk informasi selengkapnya, lihat [Netralisasi Output yang Tidak Tepat untuk Log](https://cwe.mitre.org/data/definitions/117.html) dalam *Pencacahan Kelemahan Umum*. 

**Example index.js file – Pencatatan**  

```
exports.handler = async function(event, context) {
  console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
  console.info("EVENT\n" + JSON.stringify(event, null, 2))
  console.warn("Event not processed.")
  return context.logStreamName
}
```

**Example format log**  

```
START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST
2019-06-07T19:11:20.562Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	ENVIRONMENT VARIABLES
{
  "AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
  "AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
  "AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
  "AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
  "AWS_LAMBDA_FUNCTION_NAME": "my-function",
  "PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
  "NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/node_modules",
  ...
}
2019-06-07T19:11:20.563Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	EVENT
{
  "key": "value"
}
2019-06-07T19:11:20.564Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	WARN	Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac	Duration: 128.83 ms	Billed Duration: 296 ms	Memory Size: 128 MB	Max Memory Used: 74 MB	Init Duration: 166.62 ms	XRAY TraceId: 1-5d9d007f-0a8c7fd02xmpl480aed55ef0	SegmentId: 3d752xmpl1bbe37e	Sampled: true
```

Runtime Node.js mencatat baris `START`, `END`, dan `REPORT` untuk setiap invokasi. Ini menambahkan stempel waktu, ID permintaan, dan tingkat log ke setiap entri yang dicatat oleh fungsi. Baris laporan memberikan perincian berikut.

**Laporkan bidang data baris**
+ **RequestId** – ID permintaan unik untuk invokasi.
+ **Durasi** – Jumlah waktu yang digunakan oleh metode handler fungsi Anda gunakan untuk memproses peristiwa.
+ **Durasi yang Ditagih** – Jumlah waktu yang ditagihkan untuk invokasi.
+ **Ukuran Memori** – Jumlah memori yang dialokasikan untuk fungsi.
+ **Memori Maks yang Digunakan** – Jumlah memori yang digunakan oleh fungsi. Saat pemanggilan berbagi lingkungan eksekusi, Lambda melaporkan memori maksimum yang digunakan di semua pemanggilan. Perilaku ini dapat menghasilkan nilai yang dilaporkan lebih tinggi dari yang diharapkan.
+ **Durasi Init** – Untuk permintaan pertama yang dilayani, lama waktu yang diperlukan runtime untuk memuat fungsi dan menjalankan kode di luar metode handler.
+ **XRAY TraceId** — Untuk permintaan yang dilacak, ID [AWS X-Ray jejak](services-xray.md).
+ **SegmentId** – Untuk permintaan yang dilacak, ID segmen X-Ray.
+ **Diambil Sampel** – Untuk permintaan yang dilacak, hasil pengambilan sampel.

Anda dapat melihat log di konsol Lambda, di konsol CloudWatch Log, atau dari baris perintah.

## Menggunakan kontrol logging lanjutan Lambda dengan Node.js
<a name="node-js-logging-advanced"></a>

Untuk memberi Anda kontrol lebih besar atas bagaimana log fungsi Anda ditangkap, diproses, dan digunakan, Anda dapat mengonfigurasi opsi logging berikut untuk runtime Node.js yang didukung:
+ **Format log** - pilih antara teks biasa dan format JSON terstruktur untuk log fungsi Anda
+ **Tingkat log** - untuk log dalam format JSON, pilih tingkat detail log yang dikirim Lambda ke CloudWatch Amazon, seperti ERROR, DEBUG, atau INFO
+ **Grup log** - pilih grup CloudWatch log fungsi Anda mengirim log ke

Untuk informasi selengkapnya tentang opsi pencatatan ini, dan petunjuk tentang cara mengonfigurasi fungsi Anda untuk menggunakannya, lihat[Mengkonfigurasi kontrol logging lanjutan untuk fungsi Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).

Untuk menggunakan format log dan opsi tingkat log dengan fungsi Lambda Node.js Anda, lihat panduan di bagian berikut.

### Menggunakan log JSON terstruktur dengan Node.js
<a name="nodejs-logging-advanced-JSON"></a>

Jika Anda memilih JSON untuk format log fungsi Anda, Lambda akan mengirim output log menggunakan metode `console.trace` konsol`console.debug`,,,, `console.log` `console.info``console.error`, `console.warn` dan CloudWatch ke sebagai JSON terstruktur. Setiap objek log JSON berisi setidaknya empat pasangan nilai kunci dengan kunci berikut:
+ `"timestamp"`- waktu pesan log dihasilkan
+ `"level"`- tingkat log yang ditetapkan untuk pesan
+ `"message"`- isi pesan log
+ `"requestId"`- ID permintaan unik untuk pemanggilan fungsi

Bergantung pada metode logging yang digunakan fungsi Anda, objek JSON ini mungkin juga berisi pasangan kunci tambahan. Misalnya, jika fungsi Anda menggunakan `console` metode untuk mencatat objek kesalahan menggunakan beberapa argumen, objek JSON akan berisi pasangan nilai kunci tambahan dengan kunci`errorMessage`,`errorType`, dan`stackTrace`.

Jika kode Anda sudah menggunakan pustaka logging lain, seperti Powertools for AWS Lambda, untuk menghasilkan log terstruktur JSON, Anda tidak perlu membuat perubahan apa pun. Lambda tidak menyandikan dua kali log apa pun yang sudah dikodekan JSON, sehingga log aplikasi fungsi Anda akan terus ditangkap seperti sebelumnya.

Untuk informasi selengkapnya tentang penggunaan paket Powertools for AWS Lambda logging guna membuat log terstruktur JSON di runtime Node.js, lihat. [Log dan pantau fungsi TypeScript Lambda](typescript-logging.md)

#### Contoh keluaran log yang diformat JSON
<a name="nodejs-logging-examples"></a>

Contoh berikut menunjukkan bagaimana berbagai keluaran log yang dihasilkan menggunakan `console` metode dengan argumen tunggal dan ganda ditangkap di CloudWatch Log saat Anda menyetel format log fungsi Anda ke JSON.

Contoh pertama menggunakan `console.error` metode untuk menampilkan string sederhana.

**Example Kode pencatatan Node.js**  

```
export const handler = async (event) => {
  console.error("This is a warning message");
  ...
}
```

**Example Catatan log JSON**  

```
{
    "timestamp":"2025-11-01T00:21:51.358Z",
    "level":"ERROR",
    "message":"This is a warning message",
    "requestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}
```

Anda juga dapat menampilkan pesan log terstruktur yang lebih kompleks menggunakan argumen tunggal atau ganda dengan `console` metode. Dalam contoh berikutnya, Anda gunakan `console.log` untuk menampilkan dua pasangan nilai kunci menggunakan argumen tunggal. Perhatikan bahwa `"message"` bidang dalam objek JSON yang dikirim Lambda CloudWatch ke Log tidak dirangkai.

**Example Kode pencatatan Node.js**  

```
export const handler = async (event) => {
  console.log({data: 12.3, flag: false});
  ...
}
```

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "data": 12.3,
        "flag": false
    }
}
```

Dalam contoh berikutnya, Anda kembali menggunakan `console.log` metode untuk membuat output log. Kali ini, metode ini mengambil dua argumen, peta yang berisi dua pasangan nilai kunci dan string pengidentifikasi. Perhatikan bahwa dalam kasus ini, karena Anda telah memberikan dua argumen, Lambda membuat stringifikasi bidang. `"message"`

**Example Kode pencatatan Node.js**  

```
export const handler = async (event) => {
  console.log('Some object - ', {data: 12.3, flag: false});
  ...
}
```

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "Some object -  { data: 12.3, flag: false }"
}
```

Lambda menetapkan output yang dihasilkan menggunakan INFO tingkat log`console.log`.

Contoh terakhir menunjukkan bagaimana objek kesalahan dapat output ke CloudWatch Log menggunakan `console` metode. Perhatikan bahwa ketika Anda mencatat objek kesalahan menggunakan beberapa argumen, Lambda menambahkan bidang`errorMessage`,`errorType`, dan `stackTrace` ke output log.

**Example Kode pencatatan Node.js**  

```
export const handler = async (event) => {
  let e1 = new ReferenceError("some reference error");
  let e2 = new SyntaxError("some syntax error");
  console.log(e1);
  console.log("errors logged - ", e1, e2);
};
```

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-12-08T23:21:04.632Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "errorType": "ReferenceError",
        "errorMessage": "some reference error",
        "stackTrace": [
            "ReferenceError: some reference error",
            "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
            "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
        ]
    }
}

{
    "timestamp": "2025-12-08T23:21:04.646Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "errors logged -  ReferenceError: some reference error\n    at Runtime.handler (file:///var/task/index.mjs:3:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29) SyntaxError: some syntax error\n    at Runtime.handler (file:///var/task/index.mjs:4:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29)",
    "errorType": "ReferenceError",
    "errorMessage": "some reference error",
    "stackTrace": [
        "ReferenceError: some reference error",
        "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
        "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
    ]
}
```

Saat mencatat beberapa jenis kesalahan, bidang tambahan`errorMessage`,`errorType`, dan `stackTrace` diekstraksi dari jenis kesalahan pertama yang diberikan ke `console` metode.

### Menggunakan pustaka klien format metrik tertanam (EMF) dengan log JSON terstruktur
<a name="nodejs-logging-advanced-emf"></a>

AWS menyediakan pustaka klien sumber terbuka untuk Node.js yang dapat Anda gunakan untuk membuat log [format metrik tertanam](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Libraries.html) (EMF). Jika Anda memiliki fungsi yang ada yang menggunakan pustaka ini dan Anda mengubah format log fungsi Anda ke JSON, CloudWatch mungkin tidak lagi mengenali metrik yang dipancarkan oleh kode Anda.

Jika kode Anda saat ini memancarkan log EMF secara langsung menggunakan `console.log` atau dengan menggunakan Powertools for AWS Lambda (TypeScript), juga tidak CloudWatch akan dapat mengurai ini jika Anda mengubah format log fungsi Anda menjadi JSON.

**penting**  
Untuk memastikan bahwa log EMF fungsi Anda terus diurai dengan benar CloudWatch, perbarui [EMF](https://www.npmjs.com/package/aws-embedded-metrics) dan [Powertools Anda untuk AWS Lambda](https://github.com/aws-powertools/powertools-lambda-typescript) pustaka ke versi terbaru. Jika beralih ke format log JSON, kami juga menyarankan Anda melakukan pengujian untuk memastikan kompatibilitas dengan metrik tertanam fungsi Anda. Jika kode Anda memancarkan log EMF secara langsung menggunakan`console.log`, ubah kode Anda untuk menampilkan metrik tersebut secara langsung `stdout` seperti yang ditunjukkan pada contoh kode berikut.

**Example kode yang memancarkan metrik tertanam ke `stdout`**  

```
process.stdout.write(JSON.stringify(
    {
        "_aws": {
            "Timestamp": Date.now(),
            "CloudWatchMetrics": [{
                "Namespace": "lambda-function-metrics",
                "Dimensions": [["functionVersion"]],
                "Metrics": [{
                    "Name": "time",
                    "Unit": "Milliseconds",
                    "StorageResolution": 60
                }]
            }]
        },
        "functionVersion": "$LATEST",
        "time": 100,
        "requestId": context.awsRequestId
    }
) + "\n")
```

### Menggunakan penyaringan tingkat log dengan Node.js
<a name="nodejs-logging-advanced-level"></a>

 AWS Lambda Untuk memfilter log aplikasi Anda sesuai dengan tingkat lognya, fungsi Anda harus menggunakan log berformat JSON. Anda dapat mencapai ini dengan dua cara:
+ Buat output log menggunakan metode konsol standar dan konfigurasikan fungsi Anda untuk menggunakan pemformatan log JSON. AWS Lambda kemudian memfilter output log Anda menggunakan pasangan nilai kunci “level” di objek JSON yang dijelaskan dalam. [Menggunakan log JSON terstruktur dengan Node.js](#nodejs-logging-advanced-JSON) Untuk mempelajari cara mengonfigurasi format log fungsi Anda, lihat[Mengkonfigurasi kontrol logging lanjutan untuk fungsi Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
+ Gunakan pustaka atau metode logging lain untuk membuat log terstruktur JSON dalam kode Anda yang menyertakan pasangan nilai kunci “level” yang menentukan tingkat keluaran log. Misalnya, Anda dapat menggunakan Powertools AWS Lambda untuk menghasilkan output log terstruktur JSON dari kode Anda. Lihat [Log dan pantau fungsi TypeScript Lambda](typescript-logging.md) untuk mempelajari lebih lanjut tentang menggunakan Powertools dengan runtime Node.js.

  Agar Lambda dapat memfilter log fungsi Anda, Anda juga harus menyertakan pasangan nilai `"timestamp"` kunci dalam keluaran log JSON Anda. Waktu harus ditentukan dalam format stempel waktu [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) yang valid. Jika Anda tidak menyediakan stempel waktu yang valid, Lambda akan menetapkan log INFO level dan menambahkan stempel waktu untuk Anda.

Ketika Anda mengonfigurasi fungsi Anda untuk menggunakan pemfilteran tingkat log, Anda memilih tingkat log yang ingin Anda kirim AWS Lambda ke CloudWatch Log dari opsi berikut:


| Tingkat log | Penggunaan standar | 
| --- | --- | 
| TRACE (paling detail) | Informasi paling halus yang digunakan untuk melacak jalur eksekusi kode Anda | 
| AWAKUTU | Informasi terperinci untuk debugging sistem | 
| INFO | Pesan yang merekam operasi normal fungsi Anda | 
| PERINGATAN | Pesan tentang potensi kesalahan yang dapat menyebabkan perilaku tak terduga jika tidak ditangani | 
| ERROR | Pesan tentang masalah yang mencegah kode berfungsi seperti yang diharapkan | 
| FATAL (paling detail) | Pesan tentang kesalahan serius yang menyebabkan aplikasi berhenti berfungsi | 

Lambda mengirimkan log dari level yang dipilih dan lebih rendah ke. CloudWatch Misalnya, jika Anda mengonfigurasi level log WARN, Lambda akan mengirim log yang sesuai dengan level WARN, ERROR, dan FATAL.

## Melihat log di konsol Lambda
<a name="nodejs-logging-console"></a>

Anda dapat menggunakan konsol Lambda untuk melihat output log setelah Anda memanggil fungsi Lambda.

Jika kode Anda dapat diuji dari editor **Kode** tertanam, Anda akan menemukan log dalam **hasil eksekusi**. Saat Anda menggunakan fitur pengujian konsol untuk menjalankan fungsi, Anda akan menemukan **Keluaran Log** di bagian **Detail**.

## Melihat log di CloudWatch konsol
<a name="nodejs-logging-cwconsole"></a>

Anda dapat menggunakan CloudWatch konsol Amazon untuk melihat log untuk semua pemanggilan fungsi Lambda.

**Untuk melihat log di CloudWatch konsol**

1. Buka [halaman Grup log](https://console.aws.amazon.com/cloudwatch/home?#logs:) di CloudWatch konsol.

1. Pilih grup log untuk fungsi Anda (**/aws/lambda/ *your-function-name***).

1. Pilih pengaliran log.

Setiap aliran log sesuai dengan [instans fungsi Anda](lambda-runtime-environment.md). Aliran log muncul saat Anda memperbarui fungsi Lambda, dan saat instance tambahan dibuat untuk menangani pemanggilan bersamaan. Untuk menemukan log untuk pemanggilan tertentu, kami sarankan untuk menginstrumentasi fungsi Anda dengan. AWS X-Ray X-Ray mencatat detail tentang permintaan dan pengaliran log di jejak.

## Melihat log menggunakan AWS Command Line Interface (AWS CLI)
<a name="nodejs-logging-cli"></a>

 AWS CLI Ini adalah alat sumber terbuka yang memungkinkan Anda berinteraksi dengan AWS layanan menggunakan perintah di shell baris perintah Anda. Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) untuk mengambil log untuk invokasi menggunakan opsi perintah `--log-type`. Respons berisi bidang `LogResult` yang memuat hingga 4 KB log berkode base64 dari invokasi.

**Example mengambil ID log**  
Contoh berikut menunjukkan cara mengambil *ID log* dari `LogResult` untuk fungsi bernama `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail
```
Anda akan melihat output berikut:  

```
{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}
```

**Example mendekode log**  
Pada prompt perintah yang sama, gunakan utilitas `base64` untuk mendekodekan log. Contoh berikut menunjukkan cara mengambil log berkode base64 untuk `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.  
Anda akan melihat output berikut:  

```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB
```
Utilitas `base64` tersedia di Linux, macOS, dan [Ubuntu pada Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Pengguna macOS mungkin harus menggunakan `base64 -D`.

**Example Skrip get-logs.sh**  
Pada prompt perintah yang sama, gunakan script berikut untuk mengunduh lima peristiwa log terakhir. Skrip menggunakan `sed` untuk menghapus kutipan dari file output, dan akan tidur selama 15 detik untuk memberikan waktu agar log tersedia. Output mencakup respons dari Lambda dan output dari perintah `get-log-events`.   
Salin konten dari contoh kode berikut dan simpan dalam direktori proyek Lambda Anda sebagai `get-logs.sh`.  
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.  

```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```

**Example macOS dan Linux (khusus)**  
Pada prompt perintah yang sama, pengguna macOS dan Linux mungkin perlu menjalankan perintah berikut untuk memastikan skrip dapat dijalankan.  

```
chmod -R 755 get-logs.sh
```

**Example mengambil lima log acara terakhir**  
Pada prompt perintah yang sama, gunakan skrip berikut untuk mendapatkan lima log acara terakhir.  

```
./get-logs.sh
```
Anda akan melihat output berikut:  

```
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```

## Menghapus log
<a name="nodejs-logging-delete"></a>

Grup log tidak terhapus secara otomatis ketika Anda menghapus suatu fungsi. Untuk menghindari penyimpanan log secara tidak terbatas, hapus kelompok log, atau [lakukan konfigurasi periode penyimpanan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention), yang setelahnya log akan dihapus secara otomatis.