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

# Membangun fungsi Lambda dengan Rust
<a name="lambda-rust"></a>

Karena Rust mengkompilasi ke kode asli, Anda tidak memerlukan runtime khusus untuk menjalankan kode Rust di Lambda. [Sebagai gantinya, gunakan [klien runtime Rust](https://github.com/aws/aws-lambda-rust-runtime) untuk membangun proyek Anda secara lokal, lalu terapkan ke Lambda menggunakan runtime khusus OS.](runtimes-provided.md) Saat Anda menggunakan runtime khusus OS, Lambda secara otomatis menjaga sistem operasi tetap up to date dengan patch terbaru.

**Alat dan pustaka untuk Rust**
+ [AWS SDK for Rust](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/getting-started.html): AWS SDK untuk Rust menyediakan Rust APIs untuk berinteraksi dengan layanan infrastruktur Amazon Web Services.
+  [Klien runtime Rust untuk Lambda](https://github.com/aws/aws-lambda-rust-runtime): Klien runtime Rust memudahkan menjalankan fungsi Lambda yang ditulis dalam Rust.
+ [Cargo Lambda](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html): Ini adalah ekstensi sumber terbuka pihak ketiga untuk alat baris perintah Cargo yang menyederhanakan pembuatan dan penerapan fungsi Rust Lambda.
+ [Lambda HTTP](https://github.com/aws/aws-lambda-rust-runtime/tree/main/lambda-http): Pustaka ini menyediakan pembungkus untuk bekerja dengan peristiwa HTTP.
+  [Ekstensi Lambda](https://github.com/aws/aws-lambda-rust-runtime/tree/main/lambda-extension): Pustaka ini menyediakan dukungan untuk menulis Ekstensi Lambda dengan Rust. 
+ [AWS Lambda Peristiwa](https://crates.io/crates/aws_lambda_events): Pustaka ini menyediakan definisi tipe untuk integrasi sumber peristiwa umum.

**Contoh aplikasi Lambda untuk Rust**
+ Fungsi [Lambda Dasar: Fungsi](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/basic-lambda) Rust yang menunjukkan cara memproses peristiwa dasar.
+ [Fungsi Lambda dengan penanganan kesalahan](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/basic-error-handling): Fungsi Rust yang menunjukkan cara menangani kesalahan Rust khusus di Lambda.
+ [Fungsi Lambda dengan sumber daya bersama](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/basic-shared-resource): Proyek Rust yang menginisialisasi sumber daya bersama sebelum membuat fungsi Lambda.
+ [Peristiwa HTTP Lambda](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-basic-lambda): Fungsi Rust yang menangani peristiwa HTTP.
+ [Peristiwa Lambda HTTP dengan header CORS](https://github.com/aws/aws-lambda-rust-runtime/blob/main//examples/http-cors): Fungsi Rust yang menggunakan Tower untuk menyuntikkan header CORS.
+ [Lambda REST API](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/http-axum-diesel): REST API yang menggunakan Axum dan Diesel untuk terhubung ke database PostgreSQL.
+ [Demo Rust Tanpa Server](https://github.com/aws-samples/serverless-rust-demo/): Proyek Rust yang menunjukkan penggunaan pustaka Lambda Rust, logging, variabel lingkungan, dan SDK. AWS 
+ Ekstensi [Lambda Dasar: Ekstensi](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/extension-basic) Rust yang menunjukkan cara memproses peristiwa ekstensi dasar.
+ [Lambda Logs Amazon Data Firehose Extension: Ekstensi](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/extension-logs-kinesis-firehose) Rust yang menunjukkan cara mengirim log Lambda ke Firehose.

**Topics**
+ [

# Tentukan penangan fungsi Lambda di Rust
](rust-handler.md)
+ [

# Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Rust
](rust-context.md)
+ [

# Memproses peristiwa HTTP dengan Rust
](rust-http-events.md)
+ [

# Menyebarkan fungsi Rust Lambda dengan arsip file.zip
](rust-package.md)
+ [

# Bekerja dengan lapisan untuk fungsi Rust Lambda
](rust-layers.md)
+ [

# Log dan pantau fungsi Rust Lambda
](rust-logging.md)

# Tentukan penangan fungsi Lambda di Rust
<a name="rust-handler"></a>

*Handler* fungsi Lambda Anda adalah metode dalam kode fungsi Anda yang memproses peristiwa. Saat fungsi Anda diaktifkan, Lambda menjalankan metode handler. Fungsi Anda berjalan sampai handler mengembalikan respons, keluar, atau waktu habis.

Halaman ini menjelaskan cara bekerja dengan penangan fungsi Lambda di Rust, termasuk inisialisasi proyek, konvensi penamaan, dan praktik terbaik. Halaman ini juga menyertakan contoh fungsi Rust Lambda yang mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon Simple Storage Service (S3). Untuk informasi selengkapnya tentang cara menerapkan fungsi Anda setelah menulisnya, lihat[Menyebarkan fungsi Rust Lambda dengan arsip file.zip](rust-package.md).

**Topics**
+ [

## Menyiapkan proyek penangan Rust Anda
](#rust-handler-setup)
+ [

## Contoh kode fungsi Lambda Rust
](#rust-example-code)
+ [

## Definisi kelas yang valid untuk penangan Rust
](#rust-handler-signatures)
+ [

## Konvensi penamaan handler
](#rust-example-naming)
+ [

## Mendefinisikan dan mengakses objek peristiwa masukan
](#rust-handler-input)
+ [

## Mengakses dan menggunakan objek konteks Lambda
](#rust-example-context)
+ [

## Menggunakan AWS SDK for Rust di handler Anda
](#rust-example-sdk-usage)
+ [

## Mengakses variabel lingkungan
](#rust-example-envvars)
+ [

## Menggunakan status bersama
](#rust-shared-state)
+ [

## Praktik terbaik kode untuk fungsi Rust Lambda
](#rust-best-practices)

## Menyiapkan proyek penangan Rust Anda
<a name="rust-handler-setup"></a>

Saat bekerja dengan fungsi Lambda di Rust, prosesnya melibatkan penulisan kode Anda, mengompilasinya, dan menyebarkan artefak yang dikompilasi ke Lambda. Cara termudah untuk menyiapkan proyek penangan Lambda di Rust adalah dengan menggunakan [AWS Lambda Runtime](https://github.com/aws/aws-lambda-rust-runtime) for Rust. Terlepas dari namanya, AWS Lambda Runtime for Rust bukanlah runtime terkelola dalam arti yang sama seperti di Lambda untuk Python, Java, atau Node.js. Sebaliknya, AWS Lambda Runtime for Rust adalah crate (`lambda_runtime`) yang mendukung penulisan fungsi Lambda di Rust dan berinteraksi dengan lingkungan eksekusi. AWS Lambda

Gunakan perintah berikut untuk menginstal [Cargo Lambda](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), ekstensi sumber terbuka pihak ketiga ke alat baris perintah Cargo yang menyederhanakan pembuatan dan penerapan fungsi Rust Lambda:

```
cargo install cargo-lambda
```

Setelah Anda berhasil menginstal`cargo-lambda`, gunakan perintah berikut untuk menginisialisasi proyek penangan fungsi Rust Lambda baru:

```
cargo lambda new example-rust
```

Saat Anda menjalankan perintah ini, antarmuka baris perintah (CLI) menanyakan beberapa pertanyaan tentang fungsi Lambda Anda:
+ **Fungsi HTTP** - Jika Anda bermaksud untuk memanggil fungsi Anda melalui [API Gateway](services-apigateway.md) atau [URL fungsi](urls-configuration.md), jawab **Ya**. Kalau tidak, jawab **No**. **Dalam kode contoh di halaman ini, kami memanggil fungsi kami dengan acara JSON khusus, jadi kami menjawab No.**
+ **Jenis peristiwa** - Jika Anda bermaksud menggunakan bentuk peristiwa yang telah ditentukan untuk menjalankan fungsi Anda, pilih jenis peristiwa yang diharapkan dengan benar. Jika tidak, biarkan opsi ini kosong. Dalam kode contoh di halaman ini, kami memanggil fungsi kami dengan acara JSON khusus, jadi kami membiarkan opsi ini kosong.

Setelah perintah berjalan dengan sukses, masukkan direktori utama proyek Anda:

```
cd example-rust
```

Perintah ini menghasilkan `generic_handler.rs` file dan `main.rs` file di `src` direktori. `generic_handler.rs`Dapat digunakan untuk menyesuaikan event handler generik. `main.rs`File berisi logika aplikasi utama Anda. `Cargo.toml`File berisi metadata tentang paket Anda dan mencantumkan dependensi eksternalnya.

## Contoh kode fungsi Lambda Rust
<a name="rust-example-code"></a>

Contoh berikut kode fungsi Rust Lambda mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon S3.

**Example `main.rs`Fungsi Lambda**  

```
use aws_sdk_s3::{Client, primitives::ByteStream};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::env;

#[derive(Deserialize, Serialize)]
struct Order {
    order_id: String,
    amount: f64,
    item: String,
}

async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error> {
    let payload = event.payload;

    // Deserialize the incoming event into Order struct
    let order: Order = serde_json::from_value(payload)?;

    let bucket_name = env::var("RECEIPT_BUCKET")
        .map_err(|_| "RECEIPT_BUCKET environment variable is not set")?;

    let receipt_content = format!(
        "OrderID: {}\nAmount: ${:.2}\nItem: {}",
        order.order_id, order.amount, order.item
    );
    let key = format!("receipts/{}.txt", order.order_id);

    let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
    let s3_client = Client::new(&config);

    upload_receipt_to_s3(&s3_client, &bucket_name, &key, &receipt_content).await?;

    Ok("Success".to_string())
}

async fn upload_receipt_to_s3(
    client: &Client,
    bucket_name: &str,
    key: &str,
    content: &str,
) -> Result<(), Error> {
    client
        .put_object()
        .bucket(bucket_name)
        .key(key)
        .body(ByteStream::from(content.as_bytes().to_vec()))  // Fixed conversion
        .content_type("text/plain")
        .send()
        .await?;

    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    run(service_fn(function_handler)).await
}
```

`main.rs`File ini berisi bagian kode berikut:
+ `use`pernyataan: Gunakan ini untuk mengimpor peti Rust dan metode yang diperlukan oleh fungsi Lambda Anda.
+ `#[derive(Deserialize, Serialize)]`: Tentukan bentuk peristiwa input yang diharapkan dalam struct Rust ini.
+ `async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error>`: Ini adalah **metode handler utama**, yang berisi logika aplikasi utama Anda.
+ `async fn upload_receipt_to_s3 (...)`: Ini adalah metode pembantu yang direferensikan oleh metode utama`function_handler`.
+ `#[tokio::main]`: Ini adalah makro yang menandai titik masuk program Rust. Ini juga menyiapkan [runtime Tokio](https://docs.rs/tokio/latest/tokio/runtime/index.html), yang memungkinkan `main()` metode Anda menggunakan`async`/`await`dan berjalan secara asinkron.
+ `async fn main() -> Result<(), Error>`: `main()` Fungsi ini adalah titik masuk kode Anda. Di dalamnya, kita tentukan `function_handler` sebagai metode handler utama.

### Contoh file Cargo.toml
<a name="rust-cargo-toml"></a>

`Cargo.toml`File berikut menyertai fungsi ini.

```
[package]
name = "example-rust"
version = "0.1.0"
edition = "2024"

[dependencies]
aws-config = "1.5.18"
aws-sdk-s3 = "1.78.0"
lambda_runtime = "0.13.0"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
```

Agar fungsi ini berfungsi dengan baik, [peran pelaksanaannya](lambda-intro-execution-role.md) harus memungkinkan `s3:PutObject` tindakan. Juga, pastikan bahwa Anda mendefinisikan variabel `RECEIPT_BUCKET` lingkungan. Setelah pemanggilan berhasil, bucket Amazon S3 harus berisi file tanda terima.

## Definisi kelas yang valid untuk penangan Rust
<a name="rust-handler-signatures"></a>

Dalam kebanyakan kasus, tanda tangan penangan Lambda yang Anda tentukan di Rust akan memiliki format berikut:

```
async fn function_handler(event: LambdaEvent<T>) -> Result<U, Error>
```

Untuk pawang ini:
+ Nama handler ini adalah`function_handler`.
+ Input tunggal ke handler adalah event, dan bertipe. `LambdaEvent<T>`
  + `LambdaEvent`adalah pembungkus yang berasal dari `lambda_runtime` peti. Menggunakan pembungkus ini memberi Anda akses ke objek konteks, yang mencakup metadata khusus Lambda seperti ID permintaan pemanggilan.
  + `T`adalah jenis acara deserialisasi. Misalnya, ini bisa jadi`serde_json::Value`, yang memungkinkan handler untuk mengambil input JSON generik apa pun. Atau, ini bisa berupa tipe seperti `ApiGatewayProxyRequest` jika fungsi Anda mengharapkan tipe input tertentu yang telah ditentukan sebelumnya.
+ Jenis pengembalian handler adalah`Result<U, Error>`.
  + `U`adalah tipe keluaran deserialisasi. `U`harus mengimplementasikan `serde::Serialize` sifat tersebut sehingga Lambda dapat mengonversi nilai yang dikembalikan ke JSON. Misalnya, `U` bisa berupa tipe sederhana seperti`String`,`serde_json::Value`, atau struct khusus selama `Serialize` mengimplementasikannya. Ketika kode Anda mencapai pernyataan Ok (U), ini menunjukkan eksekusi yang berhasil, dan fungsi Anda mengembalikan nilai tipe`U`.
  + Ketika kode Anda menemukan kesalahan (yaitu`Err(Error)`), fungsi Anda mencatat kesalahan di Amazon CloudWatch dan mengembalikan respons kesalahan tipe`Error`.

Dalam contoh kita, tanda tangan handler terlihat seperti berikut:

```
async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error>
```

Tanda tangan handler lain yang valid dapat menampilkan yang berikut:
+ Menghilangkan `LambdaEvent` pembungkus - Jika Anda menghilangkan`LambdaEvent`, Anda kehilangan akses ke objek konteks Lambda dalam fungsi Anda. Berikut ini adalah contoh dari jenis tanda tangan ini:

  ```
  async fn handler(event: serde_json::Value) -> Result<String, Error>
  ```
+ Menggunakan tipe unit sebagai input - Untuk Rust, Anda dapat menggunakan tipe unit untuk mewakili input kosong. Ini biasanya digunakan untuk fungsi dengan pemanggilan berkala dan terjadwal. Berikut ini adalah contoh dari jenis tanda tangan ini:

  ```
  async fn handler(_: ()) -> Result<Value, Error>
  ```

## Konvensi penamaan handler
<a name="rust-example-naming"></a>

Penangan Lambda di Rust tidak memiliki batasan penamaan yang ketat. Meskipun Anda dapat menggunakan nama apa pun untuk handler Anda, nama fungsi di Rust umumnya masuk`snake_case`.

Untuk aplikasi yang lebih kecil, seperti dalam contoh ini, Anda dapat menggunakan satu `main.rs` file untuk memuat semua kode Anda. Untuk proyek yang lebih besar, `main.rs` harus berisi titik masuk ke fungsi Anda, tetapi Anda dapat memiliki file tambahan untuk itu memisahkan kode Anda menjadi modul logis. Misalnya, Anda mungkin memiliki struktur file berikut:

```
/example-rust
│── src/
│   ├── main.rs        # Entry point
│   ├── handler.rs     # Contains main handler
│   ├── services.rs    # [Optional] Back-end service calls
│   ├── models.rs      # [Optional] Data models
│── Cargo.toml
```

## Mendefinisikan dan mengakses objek peristiwa masukan
<a name="rust-handler-input"></a>

JSON adalah format input yang paling umum dan standar untuk fungsi Lambda. Dalam contoh ini, fungsi mengharapkan input yang mirip dengan yang berikut:

```
{
    "order_id": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}
```

Di Rust, Anda dapat menentukan bentuk peristiwa input yang diharapkan dalam struct. Dalam contoh ini, kita mendefinisikan struct berikut untuk mewakili`Order`:

```
#[derive(Deserialize, Serialize)]
struct Order {
    order_id: String,
    amount: f64,
    item: String,
}
```

Struct ini cocok dengan bentuk input yang diharapkan. Dalam contoh ini, `#[derive(Deserialize, Serialize)]` makro secara otomatis menghasilkan kode untuk serialisasi dan deserialisasi. Ini berarti bahwa kita dapat deserialisasi tipe JSON input generik ke dalam struct kita menggunakan metode ini. `serde_json::from_value()` Ini diilustrasikan dalam beberapa baris pertama handler:

```
async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error> {
    let payload = event.payload;

    // Deserialize the incoming event into Order struct
    let order: Order = serde_json::from_value(payload)?;
    ...
}
```

Anda kemudian dapat mengakses bidang objek. Misalnya, `order.order_id` mengambil nilai dari `order_id` dari input asli.

### Jenis acara masukan yang telah ditentukan sebelumnya
<a name="rust-input-event-types"></a>

Ada banyak jenis peristiwa masukan yang telah ditentukan sebelumnya yang tersedia di `aws_lambda_events` peti. Misalnya, jika Anda ingin menjalankan fungsi Anda dengan API Gateway, termasuk impor berikut:

```
use aws_lambda_events::event::apigw::ApiGatewayProxyRequest;
```

Kemudian, pastikan handler utama Anda menggunakan tanda tangan berikut:

```
async fn handler(event: LambdaEvent<ApiGatewayProxyRequest>) -> Result<String, Error> {
    let body = event.payload.body.unwrap_or_default();
    ...
}
```

Lihat peti [aws\$1lambda\$1events untuk informasi selengkapnya tentang jenis peristiwa masukan](https://crates.io/crates/aws_lambda_events) yang telah ditentukan sebelumnya.

## Mengakses dan menggunakan objek konteks Lambda
<a name="rust-example-context"></a>

[Objek konteks](rust-context.md) Lambda berisi informasi tentang lingkungan pemanggilan, fungsi, dan eksekusi. Di Rust, `LambdaEvent` pembungkus menyertakan objek konteks. Misalnya, Anda dapat menggunakan objek konteks untuk mengambil ID permintaan dari pemanggilan saat ini dengan kode berikut:

```
async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error> {
    let request_id = event.context.request_id;
    ...
}
```

Untuk informasi lebih lanjut tentang objek konteks, lihat[Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Rust](rust-context.md).

## Menggunakan AWS SDK for Rust di handler Anda
<a name="rust-example-sdk-usage"></a>

Seringkali, Anda akan menggunakan fungsi Lambda untuk berinteraksi dengan atau membuat pembaruan ke sumber daya lain AWS . Cara termudah untuk berinteraksi dengan sumber daya ini adalah dengan menggunakan file [AWS SDK for Rust](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/welcome.html).

Untuk menambahkan dependensi SDK ke fungsi Anda, tambahkan dependensi di file Anda. `Cargo.toml` Kami sarankan hanya menambahkan pustaka yang Anda butuhkan untuk fungsi Anda. Dalam contoh kode sebelumnya, kita menggunakan`aws_sdk_s3::Client`. Dalam `Cargo.toml` file, Anda dapat menambahkan ketergantungan ini dengan menambahkan baris berikut di bawah `[dependencies]` bagian:

```
aws-sdk-s3 = "1.78.0"
```

**catatan**  
Ini mungkin bukan versi terbaru. Pilih versi yang sesuai untuk aplikasi Anda.

Itu, impor dependensi langsung di kode Anda:

```
use aws_sdk_s3::{Client, primitives::ByteStream};
```

Kode contoh kemudian menginisialisasi klien Amazon S3 sebagai berikut:

```
let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let s3_client = Client::new(&config);
```

Setelah menginisialisasi klien SDK, Anda dapat menggunakannya untuk berinteraksi dengan layanan lain AWS . Kode contoh memanggil Amazon S3 `PutObject` API dalam fungsi `upload_receipt_to_s3` helper.

## Mengakses variabel lingkungan
<a name="rust-example-envvars"></a>

Dalam kode handler Anda, Anda dapat mereferensikan [variabel lingkungan](configuration-envvars.md) apa pun dengan menggunakan `env::var` metode ini. Dalam contoh ini, kami mereferensikan variabel `RECEIPT_BUCKET` lingkungan yang ditentukan menggunakan baris kode berikut:

```
let bucket_name = env::var("RECEIPT_BUCKET")
    .map_err(|_| "RECEIPT_BUCKET environment variable is not set")?;
```

## Menggunakan status bersama
<a name="rust-shared-state"></a>

Anda dapat mendeklarasikan variabel bersama yang independen dari kode handler fungsi Lambda Anda. Variabel ini dapat membantu Anda memuat informasi status selama[Fase inisialisasi](lambda-runtime-environment.md#runtimes-lifecycle-ib), sebelum fungsi Anda menerima peristiwa apa pun. Misalnya, Anda dapat mengubah kode di halaman ini untuk menggunakan status bersama saat menginisialisasi klien Amazon S3 dengan memperbarui fungsi dan tanda tangan `main` handler:

```
async fn function_handler(client: &Client, event: LambdaEvent<Value>) -> Result<String, Error> {
    ...
    upload_receipt_to_s3(client, &bucket_name, &key, &receipt_content).await?;
    ...
}

...
      
#[tokio::main]
async fn main() -> Result<(), Error> {
    let shared_config = aws_config::from_env().load().await;
    let client = Client::new(&shared_config);
    let shared_client = &client;
    lambda_runtime::run(service_fn(move |event: LambdaEvent<Request>| async move {
        handler(&shared_client, event).await
    }))
    .await
```

## Praktik terbaik kode untuk fungsi Rust Lambda
<a name="rust-best-practices"></a>

Patuhi pedoman dalam daftar berikut untuk menggunakan praktik pengkodean terbaik saat membangun fungsi Lambda Anda:
+ **Pisahkan handler Lambda dari logika inti Anda.** Ini memungkinkan Anda untuk membuat fungsi yang lebih dapat teruji.
+ **Minimalkan kompleksitas dependensi Anda.** Utamakan memilih kerangka kerja lebih sederhana yang cepat dimuat dalam memulai [lingkungan eksekusi](lambda-runtime-environment.md).
+ **Minimalkan ukuran paket penerapan Anda sesuai kebutuhan runtime-nya.** Ini akan mengurangi jumlah waktu yang dibutuhkan untuk mengunduh dan membongkar paket deployment Anda sebelum invokasi.

**Manfaatkan penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda.** Inisialisasi klien SDK dan koneksi basis data di luar fungsi handler, dan lakukan caching aset statis secara lokal di direktori `/tmp`. Invokasi selanjutnya yang diproses oleh instans yang sama dari fungsi Anda dapat menggunakan kembali sumber daya ini. Ini menghemat biaya dengan mengurangi waktu pengoperasian fungsi.

Untuk menghindari potensi kebocoran data di seluruh invokasi, jangan menggunakan lingkungan eksekusi untuk menyimpan data pengguna, peristiwa, atau informasi lainnya implikasi keamanan. Jika fungsi Anda bergantung pada status yang dapat disenyapkan yang tidak dapat disimpan dalam memori di dalam handler, pertimbangkan untuk membuat fungsi terpisah atau versi terpisah dari fungsi untuk setiap pengguna.

**Gunakan arahan keep-alive untuk mempertahankan koneksi yang persisten.** Lambda membersihkan koneksi idle dari waktu ke waktu. Mencoba menggunakan ulang koneksi idle saat mengidentifikasi suatu fungsi akan menyebabkan kesalahan koneksi. Untuk mempertahankan koneksi yang persisten, gunakan arahan tetap aktif yang berkaitan dengan runtime Anda. Sebagai contoh, lihat [Menggunakan Kembali Koneksi dengan Keep-Alive di Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).

**Gunakan [variabel lingkungan](configuration-envvars.md) untuk meneruskan parameter operasional ke fungsi Anda.** Misalnya, jika Anda ingin menulis ke bucket Amazon S3 alih-alih melakukan hard-coding nama bucket yang Anda tulis, konfigurasikan nama bucket sebagai variabel lingkungan.

**Hindari menggunakan pemanggilan rekursif** dalam fungsi Lambda Anda, di mana fungsi memanggil dirinya sendiri atau memulai proses yang dapat memanggil fungsi lagi. Hal ini dapat menyebabkan volume invokasi fungsi yang tidak diinginkan dan peningkatan biaya. Jika Anda melihat volume pemanggilan yang tidak diinginkan, setel konkurensi fungsi cadangan untuk `0` segera membatasi semua pemanggilan ke fungsi, saat Anda memperbarui kode.

**Jangan gunakan non-dokumen, non-publik APIs** dalam kode fungsi Lambda Anda. Untuk runtime AWS Lambda terkelola, Lambda secara berkala menerapkan pembaruan keamanan dan fungsional ke internal Lambda. APIs Pembaruan API internal ini mungkin tidak kompatibel ke belakang, yang menyebabkan konsekuensi yang tidak diinginkan seperti kegagalan pemanggilan jika fungsi Anda memiliki ketergantungan pada non-publik ini. APIs Lihat [referensi API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) untuk daftar yang tersedia APIs untuk umum.

**Tulis kode idempoten.** Menulis kode idempoten untuk fungsi Anda memastikan bahwa peristiwa duplikat ditangani dengan cara yang sama. Kode Anda harus memvalidasi peristiwa dengan benar dan menangani peristiwa duplikat dengan anggun. Untuk informasi selengkapnya, lihat [Bagaimana cara membuat fungsi Lambda saya idempoten?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/) .

# Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Rust
<a name="rust-context"></a>

Ketika Lambda menjalankan fungsi Anda, ia menambahkan objek konteks ke LambdaEvent yang diterima [handler](rust-handler.md). Objek ini menyediakan properti dengan informasi tentang lingkungan invokasi, fungsi, dan eksekusi.

**Properti konteks**
+  `request_id`: ID AWS permintaan yang dihasilkan oleh layanan Lambda. 
+  `deadline`: Batas waktu eksekusi untuk pemanggilan saat ini dalam milidetik.
+  `invoked_function_arn`: Nama Sumber Daya Amazon (ARN) dari fungsi Lambda yang dipanggil.
+  `xray_trace_id`: ID AWS X-Ray jejak untuk pemanggilan saat ini. 
+  `client_content`: Objek konteks klien yang dikirim oleh SDK AWS seluler. Bidang ini kosong kecuali fungsi dipanggil menggunakan SDK AWS seluler. 
+  `identity`: Identitas Amazon Cognito yang memanggil fungsi. Bidang ini kosong kecuali permintaan pemanggilan ke Lambda APIs dibuat menggunakan AWS kredensil yang dikeluarkan oleh kumpulan identitas Amazon Cognito.
+  `env_config`: Konfigurasi fungsi Lambda dari variabel lingkungan lokal. Properti ini mencakup informasi seperti nama fungsi, alokasi memori, versi, dan aliran log.

## Mengakses informasi konteks aktif
<a name="rust-context-invoke"></a>

Fungsi Lambda memiliki akses ke metadata tentang lingkungan mereka dan permintaan invokasi. `LambaEvent`Objek yang diterima oleh penangan fungsi Anda mencakup `context` metadata:

```
use lambda_runtime::{service_fn, LambdaEvent, Error};
use serde_json::{json, Value};

async fn handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
    let invoked_function_arn = event.context.invoked_function_arn;
    Ok(json!({ "message": format!("Hello, this is function {invoked_function_arn}!") }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_runtime::run(service_fn(handler)).await
}
```

# Memproses peristiwa HTTP dengan Rust
<a name="rust-http-events"></a>

Amazon API Gateway APIs, Application Load Balancers, dan [fungsi Lambda URLs](urls-configuration.md) dapat mengirim peristiwa HTTP ke Lambda. Anda dapat menggunakan peti [aws\$1lambda\$1events dari crates.io untuk memproses peristiwa](https://crates.io/crates/aws_lambda_events) dari sumber-sumber ini.

**Example — Menangani permintaan proxy API Gateway**  
Perhatikan hal-hal berikut:  
+ `use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse}`: Peti [aws\$1lambda\$1events mencakup banyak acara](https://crates.io/crates/aws-lambda-events) Lambda. Untuk mengurangi waktu kompilasi, gunakan flag fitur untuk mengaktifkan acara yang Anda butuhkan. Contoh:`aws_lambda_events = { version = "0.8.3", default-features = false, features = ["apigw"] }`.
+ `use http::HeaderMap`: Impor ini mengharuskan Anda untuk menambahkan peti [http](https://crates.io/crates/http) ke dependensi Anda.

```
use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse};
use http::HeaderMap;
use lambda_runtime::{service_fn, Error, LambdaEvent};

async fn handler(
    _event: LambdaEvent<ApiGatewayProxyRequest>,
) -> Result<ApiGatewayProxyResponse, Error> {
    let mut headers = HeaderMap::new();
    headers.insert("content-type", "text/html".parse().unwrap());
    let resp = ApiGatewayProxyResponse {
        status_code: 200,
        multi_value_headers: headers.clone(),
        is_base64_encoded: false,
        body: Some("Hello AWS Lambda HTTP request".into()),
        headers,
    };
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_runtime::run(service_fn(handler)).await
}
```

[Klien runtime Rust untuk Lambda](https://github.com/aws/aws-lambda-rust-runtime) juga menyediakan abstraksi atas jenis acara ini yang memungkinkan Anda bekerja dengan tipe HTTP asli, terlepas dari layanan mana yang mengirimkan peristiwa. Kode berikut ini setara dengan contoh sebelumnya, dan berfungsi di luar kotak dengan fungsi Lambda URLs, Application Load Balancers, dan API Gateway.

**catatan**  
[Peti [lambda\$1http](https://crates.io/crates/lambda_http) menggunakan peti lambda\$1runtime di bawahnya.](https://crates.io/crates/lambda_runtime) Anda tidak perlu mengimpor `lambda_runtime` secara terpisah.

**Example — Menangani permintaan HTTP**  

```
use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt, Response};

async fn handler(event: Request) -> Result<impl IntoResponse, Error> {
    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body("Hello AWS Lambda HTTP request")
        .map_err(Box::new)?;
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_http::run(service_fn(handler)).await
}
```

Untuk contoh lain tentang cara menggunakan`lambda_http`, lihat [contoh kode http-axum](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-axum/src/main.rs) pada repositori Labs. AWS GitHub 

**Contoh acara HTTP Lambda untuk Rust**
+ [Peristiwa HTTP Lambda](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/http-basic-lambda): Fungsi Rust yang menangani peristiwa HTTP.
+ [Peristiwa Lambda HTTP dengan header CORS](https://github.com/aws/aws-lambda-rust-runtime/blob/main/examples/http-cors): Fungsi Rust yang menggunakan Tower untuk menyuntikkan header CORS.
+ [Peristiwa HTTP Lambda dengan sumber daya bersama](https://github.com/aws/aws-lambda-rust-runtime/tree/main/examples/basic-shared-resource): Fungsi Rust yang menggunakan sumber daya bersama yang diinisialisasi sebelum penangan fungsi dibuat.

# Menyebarkan fungsi Rust Lambda dengan arsip file.zip
<a name="rust-package"></a>

Halaman ini menjelaskan cara mengkompilasi fungsi Rust Anda, dan kemudian menerapkan biner yang dikompilasi untuk AWS Lambda menggunakan Cargo [Lambda](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html). Ini juga menunjukkan bagaimana menerapkan biner yang dikompilasi dengan AWS Command Line Interface dan AWS Serverless Application Model CLI.

**Topics**
+ [

## Prasyarat
](#rust-package-prerequisites)
+ [

## Membangun fungsi Rust di macOS, Windows, atau Linux
](#rust-package-build)
+ [

## Menerapkan biner fungsi Rust dengan Cargo Lambda
](#rust-deploy-cargo)
+ [

## Memanggil fungsi Rust Anda dengan Cargo Lambda
](#rust-invoke-function)

## Prasyarat
<a name="rust-package-prerequisites"></a>
+ [Karat](https://www.rust-lang.org/tools/install)
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

## Membangun fungsi Rust di macOS, Windows, atau Linux
<a name="rust-package-build"></a>

Langkah-langkah berikut menunjukkan cara membuat proyek untuk fungsi Lambda pertama Anda dengan Rust dan mengompilasinya dengan Cargo [Lambda](https://www.cargo-lambda.info/), ekstensi sumber terbuka pihak ketiga ke alat baris perintah Cargo yang menyederhanakan pembuatan dan penerapan fungsi Rust Lambda.

1. Instal [Cargo Lambda](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), ekstensi sumber terbuka pihak ketiga ke alat baris perintah Cargo yang menyederhanakan pembuatan dan penerapan fungsi Rust Lambda:

   ```
   cargo install cargo-lambda
   ```

   Untuk opsi penginstalan lainnya, lihat [Instalasi](https://www.cargo-lambda.info/guide/installation.html) di dokumentasi Cargo Lambda.

1. Buat struktur paket. Perintah ini membuat beberapa kode fungsi dasar di`src/main.rs`. Anda dapat menggunakan kode ini untuk menguji atau menggantinya dengan kode Anda sendiri.

   ```
   cargo lambda new my-function
   ```

1. Di dalam direktori root paket, jalankan subperintah [build](https://www.cargo-lambda.info/commands/build.html) untuk mengkompilasi kode dalam fungsi Anda.

   ```
   cargo lambda build --release
   ```

   (Opsional) Jika Anda ingin menggunakan AWS Graviton2 di Lambda, tambahkan `--arm64` bendera untuk mengkompilasi kode Anda untuk ARM. CPUs

   ```
   cargo lambda build --release --arm64
   ```

1. Sebelum menerapkan fungsi Rust Anda, konfigurasikan AWS kredensil pada mesin Anda.

   ```
   aws configure
   ```

## Menerapkan biner fungsi Rust dengan Cargo Lambda
<a name="rust-deploy-cargo"></a>

Gunakan subperintah [deploy](https://www.cargo-lambda.info/commands/deploy.html) untuk menyebarkan biner yang dikompilasi ke Lambda. Perintah ini menciptakan [peran eksekusi](lambda-intro-execution-role.md) dan kemudian membuat fungsi Lambda. Untuk menentukan peran eksekusi yang ada, gunakan [flag --iam-role](https://www.cargo-lambda.info/commands/deploy.html#iam-roles).

```
cargo lambda deploy my-function
```

### Menerapkan biner fungsi Rust Anda dengan AWS CLI
<a name="rust-deploy-aws-cli"></a>

Anda juga dapat menerapkan biner Anda dengan file. AWS CLI

1. Gunakan subperintah [build](https://www.cargo-lambda.info/commands/build.html) untuk membangun paket deployment .zip.

   ```
   cargo lambda build --release --output-format zip
   ```

1. [Untuk menyebarkan paket.zip ke Lambda, jalankan perintah create-function.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html)
   + Untuk `--runtime`, tentukan `provided.al2023`. Ini adalah runtime [khusus OS](runtimes-provided.md). Runtime khusus OS digunakan untuk menyebarkan binari yang dikompilasi dan runtime khusus ke Lambda.
   + Untuk`--role`, tentukan ARN dari peran [eksekusi](lambda-intro-execution-role.md).

   ```
   aws lambda create-function \
        --function-name my-function \
        --runtime provided.al2023 \
        --role arn:aws:iam::111122223333:role/lambda-role \
        --handler rust.handler \
        --zip-file fileb://target/lambda/my-function/bootstrap.zip
   ```

### Menerapkan biner fungsi Rust Anda dengan CLI AWS SAM
<a name="rust-deploy-sam-cli"></a>

Anda juga dapat menerapkan biner Anda dengan AWS SAM CLI.

1. Buat AWS SAM template dengan definisi sumber daya dan properti. Untuk `Runtime`, tentukan `provided.al2023`. Ini adalah runtime [khusus OS](runtimes-provided.md). Runtime khusus OS digunakan untuk menyebarkan binari yang dikompilasi dan runtime khusus ke Lambda.

   Untuk informasi selengkapnya tentang penerapan fungsi Lambda AWS SAM menggunakan, [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)lihat di Panduan *AWS Serverless Application Model Pengembang.*  
**Example Sumber daya SAM dan definisi properti untuk biner Rust**  

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: SAM template for Rust binaries
   Resources:
     RustFunction:
       Type: AWS::Serverless::Function 
       Properties:
         CodeUri: target/lambda/my-function/
         Handler: rust.handler
         Runtime: provided.al2023
   Outputs:
     RustFunction:
       Description: "Lambda Function ARN"
       Value: !GetAtt RustFunction.Arn
   ```

1. Gunakan subperintah [build](https://www.cargo-lambda.info/commands/build.html) untuk mengkompilasi fungsi.

   ```
   cargo lambda build --release
   ```

1. Gunakan perintah [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) untuk menyebarkan fungsi ke Lambda.

   ```
   sam deploy --guided
   ```

*Untuk informasi selengkapnya tentang membangun fungsi Rust dengan AWS SAM CLI, lihat [Membangun fungsi Lambda Karat dengan Cargo Lambda di Panduan Pengembang](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/building-rust.html).AWS Serverless Application Model *

## Memanggil fungsi Rust Anda dengan Cargo Lambda
<a name="rust-invoke-function"></a>

Gunakan subperintah [pemanggilan](https://www.cargo-lambda.info/commands/invoke.html) untuk menguji fungsi Anda dengan payload.

```
cargo lambda invoke --remote --data-ascii '{"command": "Hello world"}' my-function
```

### Memanggil fungsi Rust Anda dengan AWS CLI
<a name="rust-invoke-cli"></a>

Anda juga dapat menggunakan AWS CLI untuk menjalankan fungsi.

```
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"command": "Hello world"}' /tmp/out.txt
```

**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*.

# Bekerja dengan lapisan untuk fungsi Rust Lambda
<a name="rust-layers"></a>

Kami tidak menyarankan menggunakan [lapisan](chapter-layers.md) untuk mengelola dependensi untuk fungsi Lambda yang ditulis dalam Rust. Ini karena fungsi Lambda di Rust dikompilasi menjadi satu executable, yang Anda berikan ke Lambda saat Anda menerapkan fungsi Anda. Executable ini berisi kode fungsi dikompilasi Anda, bersama dengan semua dependensinya. Menggunakan lapisan tidak hanya mempersulit proses ini, tetapi juga menyebabkan peningkatan waktu mulai dingin karena fungsi Anda perlu memuat rakitan ekstra secara manual ke dalam memori selama fase init.

Untuk menggunakan dependensi eksternal dengan penangan Rust Anda, sertakan langsung ke dalam paket penerapan Anda. Dengan demikian, Anda menyederhanakan proses penerapan dan juga memanfaatkan pengoptimalan kompiler Rust bawaan. Untuk contoh cara mengimpor dan menggunakan dependensi seperti AWS SDK for Rust dalam fungsi Anda, lihat. [Tentukan penangan fungsi Lambda di Rust](rust-handler.md)

# Log dan pantau fungsi Rust Lambda
<a name="rust-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). Untuk informasi tentang mengonfigurasi format log, lihat[Mengkonfigurasi JSON dan format log teks biasa](monitoring-cloudwatchlogs-logformat.md). Halaman ini menjelaskan cara menghasilkan output log dari kode fungsi Lambda Anda.

## Membuat fungsi yang menulis log
<a name="rust-logging-function"></a>

Untuk mengeluarkan log dari kode fungsi Anda, Anda dapat menggunakan fungsi logging apa pun yang menulis ke `stdout` atau`stderr`, seperti `println!` makro. Contoh berikut digunakan `println!` untuk mencetak pesan ketika fungsi handler dimulai dan sebelum selesai.

```
use lambda_runtime::{service_fn, LambdaEvent, Error};
use serde_json::{json, Value};
async fn handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
    println!("Rust function invoked");
    let payload = event.payload;
    let first_name = payload["firstName"].as_str().unwrap_or("world");
    println!("Rust function responds to {}", &first_name);
    Ok(json!({ "message": format!("Hello, {first_name}!") }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_runtime::run(service_fn(handler)).await
}
```

## Menerapkan logging lanjutan dengan peti Tracing
<a name="rust-logging-tracing"></a>

[Tracing](https://crates.io/crates/tracing) adalah kerangka kerja untuk menginstrumentasi program Rust untuk mengumpulkan informasi diagnostik berbasis peristiwa yang terstruktur. Kerangka kerja ini menyediakan utilitas untuk menyesuaikan tingkat dan format keluaran logging, seperti membuat pesan log JSON terstruktur. Untuk menggunakan framework ini, Anda harus menginisialisasi `subscriber` sebelum mengimplementasikan fungsi handler. Kemudian, Anda dapat menggunakan melacak makro seperti`debug`,`info`, dan`error`, untuk menentukan tingkat logging yang Anda inginkan untuk setiap skenario.

**Example — Menggunakan peti Tracing**  
Perhatikan hal-hal berikut:  
+ `tracing_subscriber::fmt().json()`: Ketika opsi ini disertakan, log diformat dalam JSON. Untuk menggunakan opsi ini, Anda harus menyertakan `json` fitur dalam `tracing-subscriber` ketergantungan (misalnya,`tracing-subscriber = { version = "0.3.11", features = ["json"] }`).
+ `#[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))]`: Anotasi ini menghasilkan rentang setiap kali handler dipanggil. Rentang menambahkan ID permintaan ke setiap baris log.
+ `{ %first_name }`: Konstruksi ini menambahkan `first_name` bidang ke baris log tempat ia digunakan. Nilai untuk bidang ini sesuai dengan variabel dengan nama yang sama.

```
use lambda_runtime::{service_fn, Error, LambdaEvent};
use serde_json::{json, Value};
#[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))]
async fn handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
    tracing::info!("Rust function invoked");
    let payload = event.payload;
    let first_name = payload["firstName"].as_str().unwrap_or("world");
    tracing::info!({ %first_name }, "Rust function responds to event");
    Ok(json!({ "message": format!("Hello, {first_name}!") }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt().json()
        .with_max_level(tracing::Level::INFO)
        // this needs to be set to remove duplicated information in the log.
        .with_current_span(false)
        // this needs to be set to false, otherwise ANSI color codes will
        // show up in a confusing manner in CloudWatch logs.
        .with_ansi(false)
        // disabling time is handy because CloudWatch will add the ingestion time.
        .without_time()
        // remove the name of the function from every log entry
        .with_target(false)
        .init();
    lambda_runtime::run(service_fn(handler)).await
}
```

Ketika fungsi Rust ini dipanggil, ia mencetak dua baris log yang mirip dengan yang berikut ini:

```
{"level":"INFO","fields":{"message":"Rust function invoked"},"spans":[{"req_id":"45daaaa7-1a72-470c-9a62-e79860044bb5","name":"handler"}]}
{"level":"INFO","fields":{"message":"Rust function responds to event","first_name":"David"},"spans":[{"req_id":"45daaaa7-1a72-470c-9a62-e79860044bb5","name":"handler"}]}
```