Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun fungsi Lambda dengan Go
Go diimplementasikan secara berbeda dari runtime terkelola lainnya. Karena Go mengkompilasi secara native ke biner yang dapat dieksekusi, itu tidak memerlukan runtime bahasa khusus. Gunakan [runtime khusus OS (keluarga runtime](runtimes-provided.md)) untuk menerapkan `provided` fungsi Go ke Lambda.
**Topics**
+ [
## Dukungan runtime Go
](#golang-al1)
+ [
## Alat dan pustaka
](#golang-libraries)
+ [
# Tentukan penangan fungsi Lambda di Go
](golang-handler.md)
+ [
# Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Go
](golang-context.md)
+ [
# Deploy fungsi Go Lambda dengan arsip file .zip
](golang-package.md)
+ [
# Deploy fungsi Lambda Go dengan gambar kontainer
](go-image.md)
+ [
# Bekerja dengan lapisan untuk fungsi Go Lambda
](golang-layers.md)
+ [
# Log dan pantau fungsi Go Lambda
](golang-logging.md)
+ [
# Menginstrumentasi kode Go di AWS Lambda
](golang-tracing.md)
## Dukungan runtime Go
[Runtime terkelola Go 1.x untuk Lambda tidak digunakan lagi.](lambda-runtimes.md#runtime-support-policy) Jika Anda memiliki fungsi yang menggunakan runtime Go 1.x, Anda harus memigrasikan fungsi Anda ke atau. `provided.al2023` `provided.al2` `provided.al2`Runtime `provided.al2023` dan menawarkan beberapa keunggulan dibandingkan`go1.x`, termasuk dukungan untuk arsitektur arm64 (prosesor AWS Graviton2), binari yang lebih kecil, dan waktu pemanggilan yang sedikit lebih cepat.
Tidak diperlukan perubahan kode untuk migrasi ini. Satu-satunya perubahan yang diperlukan terkait dengan cara Anda membangun paket penerapan dan runtime mana yang Anda gunakan untuk membuat fungsi Anda. *Untuk informasi selengkapnya, lihat [Memigrasi AWS Lambda fungsi dari runtime Go1.x ke runtime khusus di Amazon Linux 2 di Blog Komputasi](https://aws.amazon.com/blogs/compute/migrating-aws-lambda-functions-from-the-go1-x-runtime-to-the-custom-runtime-on-amazon-linux-2/).AWS *
| Nama | Pengidentifikasi | Sistem operasi | Tanggal pengusangan | Buat fungsi blok | Pembaruan fungsi blok |
| --- | --- | --- | --- | --- | --- |
| Runtime Khusus OS | `provided.al2023` | Amazon Linux 2023 | 30 Jun 2029 | 31 Jul 2029 | Agustus 31, 2029 |
| Runtime Khusus OS | `provided.al2` | Amazon Linux 2 | Juli 31, 2026 | Agustus 31, 2026 | Sep 30, 2026 |
## Alat dan pustaka
Lambda menyediakan alat dan pustaka berikut untuk runtime Go:
+ [AWS SDK untuk Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2): AWS SDK resmi untuk bahasa pemrograman Go.
+ [github. com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda): Implementasi model pemrograman Lambda untuk Go. Paket ini digunakan oleh AWS Lambda untuk memanggil [handler](golang-handler.md) Anda.
+ [github. com/aws/aws-lambda-go/lambdacontext](https://github.com/aws/aws-lambda-go/tree/master/lambdacontext): Pembantu untuk mengakses informasi konteks dari objek [konteks](golang-context.md).
+ [github. com/aws/aws-lambda-go/events](https://github.com/aws/aws-lambda-go/tree/master/events): Pustaka ini menyediakan definisi tipe untuk integrasi sumber peristiwa umum.
+ [github. com/aws/aws-lambda-go/cmd/build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/master/cmd/build-lambda-zip): Alat ini dapat digunakan untuk membuat arsip file.zip di Windows.
Untuk informasi lebih lanjut, lihat [aws-lambda-go](https://github.com/aws/aws-lambda-go)di GitHub.
Lambda menyediakan aplikasi contoh berikut untuk runtime Go:
**Sampel aplikasi Lambda di Go**
+ [go-al2](https://github.com/aws-samples/sessions-with-aws-sam/tree/master/go-al2) - Fungsi hello world yang mengembalikan alamat IP publik. Aplikasi ini menggunakan runtime `provided.al2` khusus.
+ [blank-go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go) — Fungsi Go yang menunjukkan penggunaan library Go Lambda, logging, variabel lingkungan, dan SDK. AWS Aplikasi ini menggunakan `go1.x` runtime.
# Tentukan penangan fungsi Lambda di Go
*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 Go, termasuk penyiapan proyek, konvensi penamaan, dan praktik terbaik. Halaman ini juga menyertakan contoh fungsi Go Lambda yang mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon Simple Storage Service (Amazon S3). Untuk informasi tentang cara menerapkan fungsi Anda setelah menulisnya, lihat [Deploy fungsi Go Lambda dengan arsip file .zip](golang-package.md) atau[Deploy fungsi Lambda Go dengan gambar kontainer](go-image.md).
**Topics**
+ [
## Menyiapkan proyek Go handler Anda
](#golang-handler-setup)
+ [
## Contoh kode fungsi Go Lambda
](#golang-example-code)
+ [
## Konvensi penamaan handler
](#golang-handler-naming)
+ [
## Mendefinisikan dan mengakses objek peristiwa masukan
](#golang-example-input)
+ [
## Mengakses dan menggunakan objek konteks Lambda
](#golang-example-context)
+ [
## Tanda tangan handler yang valid untuk penangan Go
](#golang-handler-signatures)
+ [
## Menggunakan AWS SDK untuk Go v2 di handler Anda
](#golang-example-sdk-usage)
+ [
## Mengakses variabel lingkungan
](#golang-example-envvars)
+ [
## Menggunakan status global
](#golang-handler-state)
+ [
## Praktik terbaik kode untuk fungsi Go Lambda
](#go-best-practices)
## Menyiapkan proyek Go handler Anda
Fungsi Lambda yang ditulis di [Go](https://golang.org/) diprogram sebagai Go executable. Anda dapat menginisialisasi proyek fungsi Go Lambda dengan cara yang sama Anda menginisialisasi proyek Go lainnya menggunakan perintah berikut: `go mod init`
```
go mod init example-go
```
Di sini, `example-go` adalah nama modul. Anda dapat menggantinya dengan apa saja. Perintah ini menginisialisasi proyek Anda dan menghasilkan `go.mod` file yang mencantumkan dependensi proyek Anda.
Gunakan `go get` perintah untuk menambahkan dependensi eksternal ke proyek Anda. [Misalnya, untuk semua fungsi Lambda di Go, Anda harus menyertakan github. com/aws/aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda)paket, yang mengimplementasikan model pemrograman Lambda untuk Go. Sertakan paket ini dengan `go get` perintah berikut:
```
go get github.com/aws/aws-lambda-go
```
Kode fungsi Anda harus hidup dalam file Go. Dalam contoh berikut, kami memberi nama file ini`main.go`. Dalam file ini, Anda menerapkan logika fungsi inti Anda dalam metode handler, serta `main()` fungsi yang memanggil handler ini.
## Contoh kode fungsi Go Lambda
Contoh kode fungsi Go Lambda berikut mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon S3.
**Example `main.go`Fungsi Lambda**
```
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"strings"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
type Order struct {
OrderID string `json:"order_id"`
Amount float64 `json:"amount"`
Item string `json:"item"`
}
var (
s3Client *s3.Client
)
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}
s3Client = s3.NewFromConfig(cfg)
}
func uploadReceiptToS3(ctx context.Context, bucketName, key, receiptContent string) error {
_, err := s3Client.PutObject(ctx, &s3.PutObjectInput{
Bucket: &bucketName,
Key: &key,
Body: strings.NewReader(receiptContent),
})
if err != nil {
log.Printf("Failed to upload receipt to S3: %v", err)
return err
}
return nil
}
func handleRequest(ctx context.Context, event json.RawMessage) error {
// Parse the input event
var order Order
if err := json.Unmarshal(event, &order); err != nil {
log.Printf("Failed to unmarshal event: %v", err)
return err
}
// Access environment variables
bucketName := os.Getenv("RECEIPT_BUCKET")
if bucketName == "" {
log.Printf("RECEIPT_BUCKET environment variable is not set")
return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
}
// Create the receipt content and key destination
receiptContent := fmt.Sprintf("OrderID: %s\nAmount: $%.2f\nItem: %s",
order.OrderID, order.Amount, order.Item)
key := "receipts/" + order.OrderID + ".txt"
// Upload the receipt to S3 using the helper method
if err := uploadReceiptToS3(ctx, bucketName, key, receiptContent); err != nil {
return err
}
log.Printf("Successfully processed order %s and stored receipt in S3 bucket %s", order.OrderID, bucketName)
return nil
}
func main() {
lambda.Start(handleRequest)
}
```
`main.go`File ini berisi bagian kode berikut:
+ `package main`: Di Go, paket yang berisi `func main()` fungsi Anda harus selalu diberi nama`main`.
+ `import`block: Gunakan blok ini untuk menyertakan pustaka yang dibutuhkan fungsi Lambda Anda.
+ `type Order struct {}`block: Tentukan bentuk peristiwa input yang diharapkan dalam struct Go ini.
+ `var ()`block: Gunakan blok ini untuk menentukan variabel global apa pun yang akan Anda gunakan dalam fungsi Lambda Anda.
+ `func init() {}`: Sertakan kode apa pun yang Anda ingin Lambda jalankan selama [fase inisialisasi](lambda-runtime-environment.md#runtimes-lifecycle-ib) dalam metode ini. `init()`
+ `func uploadReceiptToS3(...) {}`: Ini adalah metode helper yang direferensikan oleh metode `handleRequest` handler utama.
+ `func handleRequest(ctx context.Context, event json.RawMessage) error {}`: Ini adalah **metode handler utama**, yang berisi logika aplikasi utama Anda.
+ `func main() {}`: Ini adalah titik masuk yang diperlukan untuk penangan Lambda Anda. Argumen untuk `lambda.Start()` metode ini adalah metode handler utama Anda.
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.
## Konvensi penamaan handler
Untuk fungsi Lambda di Go, Anda dapat menggunakan nama apa pun untuk handler. Dalam contoh ini, nama metode handler adalah`handleRequest`. Untuk mereferensikan nilai handler dalam kode Anda, Anda dapat menggunakan variabel `_HANDLER` lingkungan.
Untuk fungsi Go yang digunakan menggunakan [paket.zip deployment](golang-package.md), file yang dapat dieksekusi yang berisi kode fungsi Anda harus diberi nama. `bootstrap` Selain itu, `bootstrap` file harus berada di root file.zip. Untuk fungsi Go yang digunakan menggunakan [gambar kontainer](go-image.md#go-image-provided), Anda dapat menggunakan nama apa pun untuk file yang dapat dieksekusi.
## Mendefinisikan dan mengakses objek peristiwa masukan
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"
}
```
Saat bekerja dengan fungsi Lambda di Go, Anda dapat menentukan bentuk peristiwa input yang diharapkan sebagai struct Go. Dalam contoh ini, kita mendefinisikan struct untuk mewakili`Order`:
```
type Order struct {
OrderID string `json:"order_id"`
Amount float64 `json:"amount"`
Item string `json:"item"`
}
```
Struct ini cocok dengan bentuk input yang diharapkan. [Setelah Anda menentukan struct Anda, Anda dapat menulis tanda tangan handler yang menggunakan tipe JSON generik yang kompatibel dengan pustaka standar encoding/json.](https://pkg.go.dev/encoding/json) Anda kemudian dapat deserialisasinya ke dalam struct Anda menggunakan [fungsi func](https://golang.org/pkg/encoding/json/#Unmarshal) Unmarshal. Ini diilustrasikan dalam beberapa baris pertama handler:
```
func handleRequest(ctx context.Context, event json.RawMessage) error {
// Parse the input event
var order Order
if err := json.Unmarshal(event, &order); err != nil {
log.Printf("Failed to unmarshal event: %v", err)
return err
...
}
```
Setelah deserialisasi ini, Anda dapat mengakses bidang variabel. `order` Misalnya, `order.OrderID` mengambil nilai dari `"order_id"` dari input asli.
**catatan**
`encoding/json`Paket hanya dapat mengakses bidang yang diekspor. Untuk diekspor, nama bidang dalam struktur peristiwa harus dalam huruf kapital.
## Mengakses dan menggunakan objek konteks Lambda
[Objek konteks](golang-context.md) Lambda berisi informasi tentang lingkungan pemanggilan, fungsi, dan eksekusi. Dalam contoh ini, kami mendeklarasikan variabel ini seperti `ctx` pada tanda tangan handler:
```
func handleRequest(ctx context.Context, event json.RawMessage) error {
...
}
```
`ctx context.Context`Input adalah argumen opsional dalam handler fungsi Anda. Untuk informasi selengkapnya tentang tanda tangan handler yang diterima, lihat. [Tanda tangan handler yang valid untuk penangan Go](#golang-handler-signatures)
Jika Anda melakukan panggilan ke layanan lain menggunakan AWS SDK, objek konteks diperlukan di beberapa area utama. Misalnya, untuk menginisialisasi klien SDK dengan benar, Anda dapat memuat konfigurasi AWS SDK yang benar menggunakan objek konteks sebagai berikut:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
```
Panggilan SDK sendiri mungkin memerlukan objek konteks sebagai input. Misalnya, `s3Client.PutObject` panggilan menerima objek konteks sebagai argumen pertamanya:
```
// Upload the receipt to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Di luar permintaan AWS SDK, Anda juga dapat menggunakan objek konteks untuk pemantauan fungsi. Untuk informasi lebih lanjut tentang objek konteks, lihat[Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Go](golang-context.md).
## Tanda tangan handler yang valid untuk penangan Go
Anda memiliki beberapa pilihan ketika membangun handler fungsi Lambda di Go, tetapi Anda harus mematuhi aturan berikut:
+ Handler harus berupa fungsi.
+ Handler dapat mengambil antara 0 dan 2 argumen. Jika ada dua argumen, argumen pertama harus menerapkan `context.Context`.
+ Handler dapat mengembalikan antara 0 dan 2 argumen. Jika ada nilai kembali tunggal, nilai harus menerapkan `error`. Jika ada dua nilai kembali, nilai kedua harus menerapkan `error`.
Daftar berikut ini mencantumkan tanda tangan handler yang valid. `TIn` dan `TOut` mewakili tipe yang kompatibel dengan pustaka standar *encoding/json*. Untuk informasi selengkapnya, lihat [func Unmarshal](https://golang.org/pkg/encoding/json/#Unmarshal) untuk mempelajari cara tipe-tipe ini dideserialisasikan.
+
```
func ()
```
+
```
func () error
```
+
```
func () (TOut, error)
```
+
```
func (TIn) error
```
+
```
func (TIn) (TOut, error)
```
+
```
func (context.Context) error
```
+
```
func (context.Context) (TOut, error)
```
+
```
func (context.Context, TIn) error
```
+
```
func (context.Context, TIn) (TOut, error)
```
## Menggunakan AWS SDK untuk Go v2 di handler Anda
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 [AWS SDK untuk Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2).
**catatan**
AWS SDK untuk Go (v1) dalam mode pemeliharaan, dan akan mencapai end-of-support pada 31 Juli 2025. Kami menyarankan Anda hanya menggunakan AWS SDK untuk Go v2 ke depan.
Untuk menambahkan dependensi SDK ke fungsi Anda, gunakan `go get` perintah untuk klien SDK tertentu yang Anda butuhkan. Dalam contoh kode sebelumnya, kita menggunakan `config` perpustakaan dan `s3` perpustakaan. Tambahkan dependensi ini dengan menjalankan perintah berikut di direktori yang berisi file Anda `go.mod` dan`main.go `:
```
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3
```
Kemudian, impor dependensi yang sesuai di blok impor fungsi Anda:
```
import (
...
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
```
Saat menggunakan SDK di handler Anda, konfigurasikan klien Anda dengan pengaturan yang tepat. Cara termudah untuk melakukannya adalah dengan menggunakan [rantai penyedia kredensyal default](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain). Contoh ini menggambarkan salah satu cara untuk memuat konfigurasi ini:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
if err != nil {
log.Printf("Failed to load AWS SDK config: %v", err)
return err
}
```
Setelah memuat konfigurasi ini ke dalam `cfg` variabel, Anda dapat meneruskan variabel ini ke instantiasi klien. Kode contoh membuat instance klien Amazon S3 sebagai berikut:
```
// Create an S3 client
s3Client := s3.NewFromConfig(cfg)
```
Dalam contoh ini, kami menginisialisasi klien Amazon S3 kami dalam fungsi untuk menghindari `init()` keharusan menginisialisasi setiap kali kami menjalankan fungsi kami. Masalahnya adalah bahwa dalam `init()` fungsi, Lambda tidak memiliki akses ke objek konteks. Sebagai solusinya, Anda dapat meneruskan placeholder seperti `context.TODO()` selama fase inisialisasi. Kemudian, saat Anda melakukan panggilan menggunakan klien, teruskan objek konteks lengkap. Solusi ini juga dijelaskan dalam. [Menggunakan konteks dalam inisialisasi dan AWS panggilan klien SDK](golang-context.md#golang-context-sdk)
Setelah Anda mengkonfigurasi dan menginisialisasi klien SDK Anda, Anda kemudian dapat menggunakannya untuk berinteraksi dengan layanan lain AWS . Kode contoh memanggil Amazon S3 `PutObject` API sebagai berikut:
```
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
Bucket: &bucketName,
Key: &key,
Body: strings.NewReader(receiptContent),
})
```
## Mengakses variabel lingkungan
Dalam kode handler Anda, Anda dapat mereferensikan [variabel lingkungan](configuration-envvars.md) apa pun dengan menggunakan `os.Getenv()` metode ini. Dalam contoh ini, kami mereferensikan variabel `RECEIPT_BUCKET` lingkungan yang ditentukan menggunakan baris kode berikut:
```
// Access environment variables
bucketName := os.Getenv("RECEIPT_BUCKET")
if bucketName == "" {
log.Printf("RECEIPT_BUCKET environment variable is not set")
return fmt.Errorf("missing required environment variable RECEIPT_BUCKET")
}
```
## Menggunakan status global
Untuk menghindari pembuatan sumber daya baru setiap kali Anda menjalankan fungsi, Anda dapat mendeklarasikan dan memodifikasi variabel global di luar kode penangan fungsi Lambda Anda. Anda mendefinisikan variabel global ini dalam `var` blok atau pernyataan. [Selain itu, handler Anda dapat mendeklarasikan `init()` fungsi yang dijalankan selama fase inisialisasi.](lambda-runtime-environment.md#runtimes-lifecycle-ib) `init`Metode ini berperilaku sama AWS Lambda seperti pada program Go standar.
## Praktik terbaik kode untuk fungsi Go Lambda
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 Go
Di Lambda, objek konteks menyediakan metode dan properti dengan informasi tentang lingkungan pemanggilan, fungsi, dan eksekusi. Saat Lambda menjalankan fungsi Anda, ia meneruskan objek konteks ke [handler](golang-handler.md). Untuk menggunakan objek konteks di handler Anda, Anda dapat secara opsional mendeklarasikannya sebagai parameter input ke handler Anda. Objek konteks diperlukan jika Anda ingin melakukan hal berikut di handler Anda:
+ Anda memerlukan akses ke salah satu [variabel global, metode, atau properti](#golang-context-library) yang ditawarkan oleh objek konteks. Metode dan properti ini berguna untuk tugas-tugas seperti menentukan entitas yang memanggil fungsi Anda atau mengukur waktu pemanggilan fungsi Anda, seperti yang diilustrasikan dalam. [Mengakses informasi konteks aktif](#golang-context-access)
+ Anda perlu menggunakan AWS SDK untuk Go untuk melakukan panggilan ke layanan lain. Objek konteks adalah parameter input penting untuk sebagian besar panggilan ini. Untuk informasi selengkapnya, lihat [Menggunakan konteks dalam inisialisasi dan AWS panggilan klien SDK](#golang-context-sdk).
**Topics**
+ [
## Variabel, metode, dan properti yang didukung dalam objek konteks
](#golang-context-library)
+ [
## Mengakses informasi konteks aktif
](#golang-context-access)
+ [
## Menggunakan konteks dalam inisialisasi dan AWS panggilan klien SDK
](#golang-context-sdk)
## Variabel, metode, dan properti yang didukung dalam objek konteks
Pustaka konteks Lambda menyediakan variabel, metode, dan sifat global berikut.
**Variabel global**
+ `FunctionName` – Nama fungsi Lambda.
+ `FunctionVersion` – [Versi](configuration-versions.md) fungsi.
+ `MemoryLimitInMB` – Jumlah memori yang dialokasikan untuk fungsi tersebut.
+ `LogGroupName` – Grup log untuk fungsi.
+ `LogStreamName` – Aliran log untuk instans fungsi.
**Metode konteks**
+ `Deadline` – Mengembalikan tanggal saat waktu pelaksanaan habis, dalam waktu Unix milidetik.
**Properti konteks**
+ `InvokedFunctionArn` – Amazon Resource Name (ARN) yang digunakan untuk memicu fungsi. Menunjukkan jika pemicu menyebutkan nomor versi atau alias.
+ `AwsRequestID` – Pengidentifikasi permintaan invokasi.
+ `Identity` – (aplikasi seluler) Informasi tentang identitas Amazon Cognito yang mengesahkan permintaan.
+ `ClientContext` – (aplikasi seluler) Konteks klien yang disediakan untuk Lambda oleh aplikasi klien.
## Mengakses informasi konteks aktif
Fungsi Lambda memiliki akses ke metadata tentang lingkungan mereka dan permintaan invokasi. Ini dapat diakses di [Konteks paket](https://golang.org/pkg/context/). Jika handler Anda mencakup `context.Context` sebagai parameter, Lambda akan memasukkan informasi tentang fungsi Anda ke dalam `Value` properti konteks. Perhatikan bahwa Anda perlu mengimpor pustaka `lambdacontext` untuk mengakses konten dari `context.Context` objek.
```
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-lambda-go/lambdacontext"
)
func CognitoHandler(ctx context.Context) {
lc, _ := lambdacontext.FromContext(ctx)
log.Print(lc.Identity.CognitoIdentityPoolID)
}
func main() {
lambda.Start(CognitoHandler)
}
```
Dalam contoh di atas, `lc` adalah variabel yang digunakan untuk mengkonsumsi informasi bahwa objek konteks ditangkap dan `log.Print(lc.Identity.CognitoIdentityPoolID)` mencetak informasi itu, dalam hal ini, CognitoIdentityPool ID.
Contoh berikut memperkenalkan cara menggunakan objek konteks untuk memantau berapa lama waktu yang dibutuhkan fungsi Lambda untuk menyelesaikannya. Ini memungkinkan Anda untuk menganalisis ekspektasi kinerja dan menyesuaikan kode fungsi Anda, jika diperlukan.
```
package main
import (
"context"
"log"
"time"
"github.com/aws/aws-lambda-go/lambda"
)
func LongRunningHandler(ctx context.Context) (string, error) {
deadline, _ := ctx.Deadline()
deadline = deadline.Add(-100 * time.Millisecond)
timeoutChannel := time.After(time.Until(deadline))
for {
select {
case <- timeoutChannel:
return "Finished before timing out.", nil
default:
log.Print("hello!")
time.Sleep(50 * time.Millisecond)
}
}
}
func main() {
lambda.Start(LongRunningHandler)
}
```
## Menggunakan konteks dalam inisialisasi dan AWS panggilan klien SDK
Jika handler Anda perlu menggunakan untuk melakukan panggilan AWS SDK untuk Go ke layanan lain, sertakan objek konteks sebagai input ke handler Anda. Di AWS, ini adalah praktik terbaik untuk meneruskan objek konteks di sebagian besar panggilan AWS SDK. Misalnya, `PutObject` panggilan Amazon S3 menerima objek konteks (`ctx`) sebagai argumen pertamanya:
```
// Upload an object to S3
_, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
...
})
```
Untuk menginisialisasi klien SDK Anda dengan benar, Anda juga dapat menggunakan objek konteks untuk memuat konfigurasi yang benar sebelum meneruskan objek konfigurasi tersebut ke klien:
```
// Load AWS SDK configuration using the default credential provider chain
cfg, err := config.LoadDefaultConfig(ctx)
...
s3Client = s3.NewFromConfig(cfg)
```
Jika Anda ingin menginisialisasi klien SDK di luar handler utama Anda (yaitu selama fase inisialisasi), Anda dapat meneruskan objek konteks placeholder:
```
func init() {
// Initialize the S3 client outside of the handler, during the init phase
cfg, err := config.LoadDefaultConfig(context.TODO())
...
s3Client = s3.NewFromConfig(cfg)
}
```
Jika Anda menginisialisasi klien dengan cara ini, pastikan Anda meneruskan objek konteks yang benar dalam panggilan SDK dari pengendali utama Anda.
# Deploy fungsi Go Lambda dengan arsip file .zip
Kode AWS Lambda fungsi Anda terdiri dari skrip atau program yang dikompilasi dan dependensinya. Gunakan *paket deployment* untuk men-deploy fungsi kode Anda ke Lambda. Lambda mendukung dua tipe paket deployment: gambar kontainer dan arsip file .zip.
Halaman ini menjelaskan cara membuat file.zip sebagai paket penerapan Anda untuk runtime Go, dan kemudian menggunakan file.zip untuk menyebarkan kode fungsi Anda AWS Lambda menggunakan, () Konsol Manajemen AWS, dan AWS Command Line Interface (AWS CLI). AWS Serverless Application Model AWS SAM
Perhatikan bahwa Lambda menggunakan izin file POSIX, jadi Anda mungkin perlu [mengatur izin untuk folder paket penyebaran](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) sebelum membuat arsip file.zip.
**Topics**
+ [
## Membuat file .zip pada macOS dan Linux
](#golang-package-mac-linux)
+ [
## Membuat file .zip pada Windows
](#golang-package-windows)
+ [
## Membuat dan memperbarui fungsi Go Lambda menggunakan file.zip
](#golang-package-create-function)
## Membuat file .zip pada macOS dan Linux
Langkah-langkah berikut menunjukkan cara mengkompilasi executable Anda menggunakan `go build` perintah dan membuat paket penyebaran file.zip untuk Lambda. Sebelum mengkompilasi kode Anda, pastikan Anda telah menginstal paket [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) dari. GitHub Modul ini menyediakan implementasi antarmuka runtime, yang mengelola interaksi antara Lambda dan kode fungsi Anda. Untuk mengunduh pustaka ini, jalankan perintah berikut.
```
go get github.com/aws/aws-lambda-go/lambda
```
Jika fungsi Anda menggunakan AWS SDK untuk Go, unduh set standar modul SDK, bersama dengan klien API AWS layanan apa pun yang diperlukan oleh aplikasi Anda. Untuk mempelajari cara menginstal SDK for Go, [lihat Memulai dengan V2 AWS SDK untuk Go .](https://github.com/aws/aws-sdk-go-v2?tab=readme-ov-file#getting-started)
### Menggunakan keluarga runtime yang disediakan
Go diimplementasikan secara berbeda dari runtime terkelola lainnya. Karena Go mengkompilasi secara native ke biner yang dapat dieksekusi, itu tidak memerlukan runtime bahasa khusus. Gunakan [runtime khusus OS (keluarga runtime](runtimes-provided.md)) untuk menerapkan `provided` fungsi Go ke Lambda.
**Untuk membuat paket penyebaran.zip (macOS/Linux)**
1. Dalam direktori proyek yang berisi `main.go` file aplikasi Anda, kompilasi executable Anda. Perhatikan hal-hal berikut:
+ Executable harus diberi nama. `bootstrap` Untuk informasi selengkapnya, lihat [Konvensi penamaan handler](golang-handler.md#golang-handler-naming).
+ Tetapkan [arsitektur set instruksi](foundation-arch.md) target Anda. Runtime khusus OS mendukung arm64 dan x86\$164.
+ Anda dapat menggunakan `lambda.norpc` tag opsional untuk mengecualikan komponen Remote Procedure Call (RPC) dari pustaka [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Komponen RPC hanya diperlukan jika Anda menggunakan runtime Go 1.x yang tidak digunakan lagi. Mengecualikan RPC mengurangi ukuran paket penyebaran.
Untuk arsitektur arm64:
```
GOOS=linux GOARCH=arm64 go build -tags lambda.norpc -o bootstrap main.go
```
Untuk arsitektur x86\$164:
```
GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o bootstrap main.go
```
1. (Opsional) Anda mungkin perlu mengompilasi paket dengan `CGO_ENABLED=0` yang diatur di Linux:
```
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bootstrap -tags lambda.norpc main.go
```
Perintah ini membuat paket biner stabil untuk versi pustaka C standar (`libc`), yang mungkin berbeda di Lambda dan perangkat lainnya.
1. Buat paket deployment dengan mengemas executable dalam file .zip.
```
zip myFunction.zip bootstrap
```
**catatan**
`bootstrap`File harus berada di root file.zip.
1. Buat fungsi . Perhatikan hal-hal berikut:
+ Biner harus diberi nama`bootstrap`, tetapi nama handler bisa apa saja. Untuk informasi selengkapnya, lihat [Konvensi penamaan handler](golang-handler.md#golang-handler-naming).
+ `--architectures`Opsi ini hanya diperlukan jika Anda menggunakan arm64. Nilai default adalah x86\$164.
+ Untuk`--role`, tentukan Nama Sumber Daya Amazon (ARN) dari peran [eksekusi](lambda-intro-execution-role.md).
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--architectures arm64 \
--role arn:aws:iam::111122223333:role/lambda-ex \
--zip-file fileb://myFunction.zip
```
## Membuat file .zip pada Windows
Langkah-langkah berikut menunjukkan cara mengunduh [build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/main/cmd/build-lambda-zip)alat untuk Windows dari GitHub, mengkompilasi executable Anda, dan membuat paket deployment .zip.
**catatan**
Jika Anda belum melakukannya, Anda harus menginstal [git](https://git-scm.com/), lalu tambahkan executable `git` ke variabel lingkungan Windows `%PATH%` Anda.
Sebelum mengkompilasi kode Anda, pastikan Anda telah menginstal pustaka [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda) dari. GitHub Untuk mengunduh pustaka ini, jalankan perintah berikut.
```
go get github.com/aws/aws-lambda-go/lambda
```
Jika fungsi Anda menggunakan AWS SDK untuk Go, unduh set standar modul SDK, bersama dengan klien API AWS layanan apa pun yang diperlukan oleh aplikasi Anda. Untuk mempelajari cara menginstal SDK for Go, [lihat Memulai dengan V2 AWS SDK untuk Go .](https://aws.github.io/aws-sdk-go-v2/docs/getting-started/)
### Menggunakan keluarga runtime yang disediakan
Go diimplementasikan secara berbeda dari runtime terkelola lainnya. Karena Go mengkompilasi secara native ke biner yang dapat dieksekusi, itu tidak memerlukan runtime bahasa khusus. Gunakan [runtime khusus OS (keluarga runtime](runtimes-provided.md)) untuk menerapkan `provided` fungsi Go ke Lambda.
**Untuk membuat paket penyebaran.zip (Windows)**
1. Unduh **build-lambda-zip**alat dari GitHub.
```
go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
```
1. Gunakan alat dari `GOPATH` Anda untuk membuat file .zip. Jika Anda memiliki penginstalan default Go, alat ini biasanya di `%USERPROFILE%\Go\bin`. Jika tidak, arahkan ke tempat Anda menginstal runtime Go dan lakukan salah satu hal berikut:
------
#### [ cmd.exe ]
Di cmd.exe, jalankan salah satu dari berikut ini, tergantung pada [arsitektur set instruksi](foundation-arch.md) target Anda. Runtime khusus OS mendukung arm64 dan x86\$164.
Anda dapat menggunakan `lambda.norpc` tag opsional untuk mengecualikan komponen Remote Procedure Call (RPC) dari pustaka [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Komponen RPC hanya diperlukan jika Anda menggunakan runtime Go 1.x yang tidak digunakan lagi. Mengecualikan RPC mengurangi ukuran paket penyebaran.
**Example — Untuk arsitektur x86\$164**
```
set GOOS=linux
set GOARCH=amd64
set CGO_ENABLED=0
go build -tags lambda.norpc -o bootstrap main.go
%USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
**Example — Untuk arsitektur arm64**
```
set GOOS=linux
set GOARCH=arm64
set CGO_ENABLED=0
go build -tags lambda.norpc -o bootstrap main.go
%USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
------
#### [ PowerShell ]
Dalam PowerShell, jalankan salah satu dari berikut ini, tergantung pada [arsitektur set instruksi](foundation-arch.md) target Anda. Runtime khusus OS mendukung arm64 dan x86\$164.
Anda dapat menggunakan `lambda.norpc` tag opsional untuk mengecualikan komponen Remote Procedure Call (RPC) dari pustaka [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Komponen RPC hanya diperlukan jika Anda menggunakan runtime Go 1.x yang tidak digunakan lagi. Mengecualikan RPC mengurangi ukuran paket penyebaran.
Untuk arsitektur x86\$164:
```
$env:GOOS = "linux"
$env:GOARCH = "amd64"
$env:CGO_ENABLED = "0"
go build -tags lambda.norpc -o bootstrap main.go
~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
Untuk arsitektur arm64:
```
$env:GOOS = "linux"
$env:GOARCH = "arm64"
$env:CGO_ENABLED = "0"
go build -tags lambda.norpc -o bootstrap main.go
~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
```
------
1. Buat fungsi . Perhatikan hal-hal berikut:
+ Biner harus diberi nama`bootstrap`, tetapi nama handler bisa apa saja. Untuk informasi selengkapnya, lihat [Konvensi penamaan handler](golang-handler.md#golang-handler-naming).
+ `--architectures`Opsi ini hanya diperlukan jika Anda menggunakan arm64. Nilai default adalah x86\$164.
+ Untuk`--role`, tentukan Nama Sumber Daya Amazon (ARN) dari peran [eksekusi](lambda-intro-execution-role.md).
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--architectures arm64 \
--role arn:aws:iam::111122223333:role/lambda-ex \
--zip-file fileb://myFunction.zip
```
## Membuat dan memperbarui fungsi Go Lambda menggunakan file.zip
Setelah Anda membuat paket.zip deployment, Anda dapat menggunakannya untuk membuat fungsi Lambda baru atau memperbarui yang sudah ada. Anda dapat menerapkan paket.zip Anda menggunakan konsol Lambda, API, AWS Command Line Interface dan Lambda. Anda juga dapat membuat dan memperbarui fungsi Lambda menggunakan AWS Serverless Application Model (AWS SAM) dan. CloudFormation
Ukuran maksimum untuk paket.zip deployment untuk Lambda adalah 250 MB (unzip). Perhatikan bahwa batas ini berlaku untuk ukuran gabungan semua file yang Anda unggah, termasuk lapisan Lambda apa pun.
Runtime Lambda membutuhkan izin untuk membaca file dalam paket deployment Anda. Dalam notasi oktal izin Linux, Lambda membutuhkan 644 izin untuk file yang tidak dapat dieksekusi (rw-r - r--) dan 755 izin () untuk direktori dan file yang dapat dieksekusi. rwxr-xr-x
Di Linux dan macOS, gunakan `chmod` perintah untuk mengubah izin file pada file dan direktori dalam paket penyebaran Anda. Misalnya, untuk memberikan file yang tidak dapat dieksekusi izin yang benar, jalankan perintah berikut.
```
chmod 644
```
Untuk mengubah izin file di Windows, lihat [Mengatur, Melihat, Mengubah, atau Menghapus Izin pada Objek](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) dalam dokumentasi Microsoft Windows.
**catatan**
Jika Anda tidak memberikan Lambda izin yang diperlukan untuk mengakses direktori dalam paket penerapan Anda, Lambda menetapkan izin untuk direktori tersebut ke 755 (). rwxr-xr-x
### Membuat dan memperbarui fungsi dengan file.zip menggunakan konsol
Untuk membuat fungsi baru, Anda harus terlebih dahulu membuat fungsi di konsol, lalu mengunggah arsip.zip Anda. Untuk memperbarui fungsi yang ada, buka halaman untuk fungsi Anda, lalu ikuti prosedur yang sama untuk menambahkan file.zip Anda yang diperbarui.
Jika file.zip Anda kurang dari 50MB, Anda dapat membuat atau memperbarui fungsi dengan mengunggah file langsung dari mesin lokal Anda. Untuk file.zip yang lebih besar dari 50MB, Anda harus mengunggah paket Anda ke bucket Amazon S3 terlebih dahulu. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan Konsol Manajemen AWS, lihat [Memulai Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Untuk mengunggah file menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *Panduan AWS CLI Pengguna*.
**catatan**
Anda tidak dapat mengonversi fungsi gambar kontainer yang ada untuk menggunakan arsip.zip. Anda harus membuat fungsi baru.
**Untuk membuat fungsi baru (konsol)**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda dan pilih **Buat** Fungsi.
1. Pilih **Tulis dari awal**.
1. Di bagian **Informasi dasar**, lakukan hal berikut:
1. Untuk **nama Fungsi**, masukkan nama untuk fungsi Anda.
1. Untuk **Runtime**, pilih`provided.al2023`.
1. (Opsional) Di bagian **Izin**, luaskan **Ubah peran eksekusi default**. Anda dapat membuat **peran Eksekusi** baru atau menggunakan yang sudah ada.
1. Pilih **Buat fungsi**. Lambda menciptakan fungsi dasar 'Hello world' menggunakan runtime yang Anda pilih.
**Untuk mengunggah arsip.zip dari mesin lokal Anda (konsol)**
1. Di [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda, pilih fungsi yang ingin Anda unggah file.zip.
1. Pilih tab **Kode**.
1. Di panel **Sumber kode**, pilih **Unggah dari**.
1. Pilih **file.zip**.
1. Untuk mengunggah file.zip, lakukan hal berikut:
1. Pilih **Unggah**, lalu pilih file.zip Anda di pemilih file.
1. Pilih **Buka**.
1. Pilih **Simpan**.
**Untuk mengunggah arsip.zip dari bucket Amazon S3 (konsol)**
1. Di [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda, pilih fungsi yang ingin Anda unggah file.zip baru.
1. Pilih tab **Kode**.
1. Di panel **Sumber kode**, pilih **Unggah dari**.
1. Pilih **lokasi Amazon S3**.
1. **Rekatkan URL tautan Amazon S3 dari file.zip Anda dan pilih Simpan.**
### Membuat dan memperbarui fungsi dengan file.zip menggunakan AWS CLI
Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)untuk membuat fungsi baru atau memperbarui yang sudah ada menggunakan file.zip. Gunakan [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) dan [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)perintah untuk menyebarkan paket.zip Anda. Jika file.zip Anda lebih kecil dari 50MB, Anda dapat mengunggah paket.zip dari lokasi file di mesin build lokal Anda. Untuk file yang lebih besar, Anda harus mengunggah paket.zip Anda dari bucket Amazon S3. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *AWS CLI Panduan Pengguna*.
**catatan**
Jika Anda mengunggah file.zip dari bucket Amazon S3 menggunakan AWS CLI, bucket harus berada di lokasi yang Wilayah AWS sama dengan fungsi Anda.
Untuk membuat fungsi baru menggunakan file.zip dengan AWS CLI, Anda harus menentukan yang berikut:
+ Nama fungsi Anda (`--function-name`)
+ Runtime () `--runtime` fungsi Anda
+ Nama Sumber Daya Amazon (ARN) dari [peran eksekusi](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) fungsi Anda () `--role`
+ Nama metode handler dalam kode fungsi Anda () `--handler`
Anda juga harus menentukan lokasi file.zip Anda. Jika file.zip Anda terletak di folder di mesin build lokal Anda, gunakan `--zip-file` opsi untuk menentukan jalur file, seperti yang ditunjukkan pada perintah contoh berikut.
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Untuk menentukan lokasi file.zip di bucket Amazon S3, gunakan opsi seperti `--code` yang ditunjukkan pada perintah contoh berikut. Anda hanya perlu menggunakan `S3ObjectVersion` parameter untuk objek berversi.
```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Untuk memperbarui fungsi yang ada menggunakan CLI, Anda menentukan nama fungsi Anda menggunakan parameter. `--function-name` Anda juga harus menentukan lokasi file.zip yang ingin Anda gunakan untuk memperbarui kode fungsi Anda. Jika file.zip Anda terletak di folder di mesin build lokal Anda, gunakan `--zip-file` opsi untuk menentukan jalur file, seperti yang ditunjukkan pada perintah contoh berikut.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Untuk menentukan lokasi file.zip di bucket Amazon S3, gunakan opsi `--s3-key` dan seperti `--s3-bucket` yang ditunjukkan pada perintah contoh berikut. Anda hanya perlu menggunakan `--s3-object-version` parameter untuk objek berversi.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Membuat dan memperbarui fungsi dengan file.zip menggunakan API Lambda
Untuk membuat dan memperbarui fungsi menggunakan arsip file.zip, gunakan operasi API berikut:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Membuat dan memperbarui fungsi dengan file.zip menggunakan AWS SAM
The AWS Serverless Application Model (AWS SAM) adalah toolkit yang membantu merampingkan proses membangun dan menjalankan aplikasi tanpa server. AWS Anda menentukan sumber daya untuk aplikasi Anda dalam template YAMB atau JSON dan menggunakan antarmuka baris AWS SAM perintah (AWS SAM CLI) untuk membangun, mengemas, dan menyebarkan aplikasi Anda. Saat Anda membuat fungsi Lambda dari AWS SAM template, AWS SAM secara otomatis membuat paket penerapan .zip atau gambar kontainer dengan kode fungsi Anda dan dependensi apa pun yang Anda tentukan. Untuk mempelajari lebih lanjut cara menggunakan AWS SAM untuk membangun dan menerapkan fungsi Lambda, [lihat Memulai](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) di Panduan AWS SAM*AWS Serverless Application Model Pengembang*.
Anda juga dapat menggunakan AWS SAM untuk membuat fungsi Lambda menggunakan arsip file.zip yang ada. Untuk membuat fungsi Lambda menggunakan AWS SAM, Anda dapat menyimpan file.zip di bucket Amazon S3 atau di folder lokal di mesin build Anda. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *AWS CLI Panduan Pengguna*.
Dalam AWS SAM template Anda, `AWS::Serverless::Function` sumber daya menentukan fungsi Lambda Anda. Dalam sumber daya ini, atur properti berikut untuk membuat fungsi menggunakan arsip file.zip:
+ `PackageType`- diatur ke `Zip`
+ `CodeUri`- diatur ke kode fungsi Amazon S3 URI, jalur ke folder lokal, atau objek [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`- Setel ke runtime yang Anda pilih
Dengan AWS SAM, jika file.zip Anda lebih besar dari 50MB, Anda tidak perlu mengunggahnya ke bucket Amazon S3 terlebih dahulu. AWS SAM dapat mengunggah paket.zip hingga ukuran maksimum yang diizinkan 250MB (unzip) dari lokasi di mesin build lokal Anda.
Untuk mempelajari selengkapnya tentang penerapan fungsi menggunakan file.zip AWS SAM, lihat [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)di Panduan *AWS SAM Pengembang*.
**Contoh: Menggunakan AWS SAM untuk membangun fungsi Go dengan provided.al2023**
1. Buat AWS SAM template dengan properti berikut:
+ **BuildMethod**: Menentukan compiler untuk aplikasi Anda. Gunakan `go1.x`.
+ **Runtime**: Gunakan`provided.al2023`.
+ **CodeUri**: Masukkan jalur ke kode Anda.
+ **Arsitektur**: Gunakan `[arm64]` untuk arsitektur arm64. Untuk arsitektur set instruksi x86\$164, gunakan `[amd64]` atau hapus properti. `Architectures`
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: go1.x
Properties:
CodeUri: hello-world/ # folder where your main program resides
Handler: bootstrap
Runtime: provided.al2023
Architectures: [arm64]
```
1. Gunakan perintah [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) untuk mengkompilasi executable.
```
sam build
```
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
```
### Membuat dan memperbarui fungsi dengan file.zip menggunakan CloudFormation
Anda dapat menggunakan CloudFormation untuk membuat fungsi Lambda menggunakan arsip file.zip. Untuk membuat fungsi Lambda dari file.zip, Anda harus terlebih dahulu mengunggah file Anda ke bucket Amazon S3. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *AWS CLI Panduan Pengguna*.
Dalam CloudFormation template Anda, `AWS::Lambda::Function` sumber daya menentukan fungsi Lambda Anda. Dalam sumber daya ini, atur properti berikut untuk membuat fungsi menggunakan arsip file.zip:
+ `PackageType`- Setel ke `Zip`
+ `Code`- Masukkan nama bucket Amazon S3 dan nama file.zip di dan bidang `S3Bucket` `S3Key`
+ `Runtime`- Setel ke runtime yang Anda pilih
File.zip yang CloudFormation menghasilkan tidak boleh melebihi 4MB. Untuk mempelajari selengkapnya tentang penerapan fungsi menggunakan file.zip CloudFormation, lihat [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)di *CloudFormation Panduan Pengguna*.
# Deploy fungsi Lambda Go dengan gambar kontainer
Ada dua cara untuk membangun image kontainer untuk fungsi Go Lambda:
+ [Menggunakan gambar AWS dasar khusus OS](#go-image-provided)
Go diimplementasikan secara berbeda dari runtime terkelola lainnya. Karena Go mengkompilasi secara native ke biner yang dapat dieksekusi, itu tidak memerlukan runtime bahasa khusus. Gunakan gambar [dasar khusus OS untuk membuat gambar](images-create.md#runtimes-images-provided) Go untuk Lambda. Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan `aws-lambda-go/lambda` paket dalam gambar.
+ [Menggunakan gambar AWS non-dasar](#go-image-other)
Anda dapat menggunakan gambar dasar alternatif dari registri kontainer lain, seperti Alpine Linux atau Debian. Anda juga dapat menggunakan gambar kustom yang dibuat oleh organisasi Anda. Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan `aws-lambda-go/lambda` paket dalam gambar.
**Tip**
Untuk mengurangi waktu yang dibutuhkan agar fungsi kontainer Lambda menjadi aktif, lihat [Menggunakan build multi-tahap](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds) dalam dokumentasi Docker. Untuk membuat gambar kontainer yang efisien, ikuti [Praktik terbaik untuk menulis Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Halaman ini menjelaskan cara membuat, menguji, dan menyebarkan gambar kontainer untuk Lambda.
## AWS gambar dasar untuk menerapkan fungsi Go
Go diimplementasikan secara berbeda dari runtime terkelola lainnya. Karena Go mengkompilasi secara native ke biner yang dapat dieksekusi, itu tidak memerlukan runtime bahasa khusus. Gunakan [gambar dasar khusus OS](images-create.md#runtimes-images-provided) untuk menerapkan fungsi Go ke Lambda.
| Nama | Pengidentifikasi | Sistem operasi | Tanggal pengusangan | Buat fungsi blok | Pembaruan fungsi blok |
| --- | --- | --- | --- | --- | --- |
| Runtime Khusus OS | `provided.al2023` | Amazon Linux 2023 | 30 Jun 2029 | Jul 31, 2029 | Agustus 31, 2029 |
| Runtime Khusus OS | `provided.al2` | Amazon Linux 2 | Juli 31, 2026 | Agustus 31, 2026 | Sep 30, 2026 |
Galeri Publik Registri Kontainer Elastis Amazon: [gallery.ecr. aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## Klien antarmuka Go runtime
Paket `aws-lambda-go/lambda` termasuk implementasi dari antarmuka runtime. Untuk contoh cara menggunakan `aws-lambda-go/lambda` dalam gambar Anda, lihat [Menggunakan gambar AWS dasar khusus OS](#go-image-provided) atau[Menggunakan gambar AWS non-dasar](#go-image-other).
## Menggunakan gambar AWS dasar khusus OS
Go diimplementasikan secara berbeda dari runtime terkelola lainnya. Karena Go mengkompilasi secara native ke biner yang dapat dieksekusi, itu tidak memerlukan runtime bahasa khusus. Gunakan image [dasar khusus OS untuk membuat gambar](images-create.md#runtimes-images-provided) kontainer untuk fungsi Go.
| Tag | Waktu berjalan | Sistem operasi | Dockerfile | penghentian |
| --- | --- | --- | --- | --- |
| al2023 | Runtime Khusus OS | Amazon Linux 2023 | [Dockerfile untuk Runtime khusus OS aktif GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 30 Jun 2029 |
| al2 | Runtime Khusus OS | Amazon Linux 2 | [Dockerfile untuk Runtime khusus OS aktif GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | Juli 31, 2026 |
Untuk informasi selengkapnya tentang gambar dasar ini, lihat [disediakan](https://gallery.ecr.aws/lambda/provided) di galeri publik Amazon ECR.
Anda harus menyertakan paket [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) dengan handler Go Anda. Paket ini mengimplementasikan model pemrograman untuk Go, termasuk antarmuka runtime.
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
+ Go
### Membuat gambar dari gambar dasar.al2023 yang disediakan
**Untuk membangun dan menerapkan fungsi Go dengan image `provided.al2023` dasar**
1. Buat direktori untuk proyek, dan kemudian beralih ke direktori itu.
```
mkdir hello
cd hello
```
1. Inisialisasi modul Go baru.
```
go mod init example.com/hello-world
```
1. Tambahkan pustaka **lambda** sebagai dependensi modul baru Anda.
```
go get github.com/aws/aws-lambda-go/lambda
```
1. Buat file bernama `main.go` dan kemudian buka di editor teks. Ini adalah kode untuk fungsi Lambda. Anda dapat menggunakan kode contoh berikut untuk pengujian, atau menggantinya dengan kode Anda sendiri.
```
package main
import (
"context"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
response := events.APIGatewayProxyResponse{
StatusCode: 200,
Body: "\"Hello from Lambda!\"",
}
return response, nil
}
func main() {
lambda.Start(handler)
}
```
1. Gunakan editor teks untuk membuat Dockerfile di direktori proyek Anda.
+ Contoh berikut Dockerfile menggunakan build [multi-tahap](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Ini memungkinkan Anda untuk menggunakan gambar dasar yang berbeda di setiap langkah. Anda dapat menggunakan satu gambar, seperti [image dasar Go](https://hub.docker.com/_/golang), untuk mengkompilasi kode Anda dan membangun biner yang dapat dieksekusi. Anda kemudian dapat menggunakan gambar yang berbeda, seperti`provided.al2023`, dalam `FROM` pernyataan akhir untuk menentukan gambar yang Anda terapkan ke Lambda. Proses build dipisahkan dari image penerapan akhir, sehingga gambar akhir hanya berisi file yang diperlukan untuk menjalankan aplikasi.
+ Anda dapat menggunakan `lambda.norpc` tag opsional untuk mengecualikan komponen Remote Procedure Call (RPC) dari pustaka [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Komponen RPC hanya diperlukan jika Anda menggunakan runtime Go 1.x yang tidak digunakan lagi. Mengecualikan RPC mengurangi ukuran paket penyebaran.
+ Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example — Multi-tahap membangun Dockerfile**
**catatan**
Pastikan bahwa versi Go yang Anda tentukan di Dockerfile Anda (misalnya,`golang:1.20`) adalah versi Go yang sama dengan yang Anda gunakan untuk membuat aplikasi Anda.
```
FROM golang:1.20 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build with optional lambda.norpc tag
COPY main.go .
RUN go build -tags lambda.norpc -o main main.go
# Copy artifacts to a clean image
FROM public.ecr.aws/lambda/provided:al2023
COPY --from=build /helloworld/main ./main
ENTRYPOINT [ "./main" ]
```
1. Buat image Docker dengan perintah [docker](https://docs.docker.com/engine/reference/commandline/build/) build. Contoh berikut menamai gambar `docker-image` dan memberinya `test` [tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Untuk membuat gambar Anda kompatibel dengan Lambda, Anda harus menggunakan opsi. `--provenance=false`
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**catatan**
Perintah menentukan `--platform linux/amd64` opsi untuk memastikan bahwa container Anda kompatibel dengan lingkungan eksekusi Lambda terlepas dari arsitektur mesin build Anda. Jika Anda berniat untuk membuat fungsi Lambda menggunakan arsitektur set ARM64 instruksi, pastikan untuk mengubah perintah untuk menggunakan `--platform linux/arm64` opsi sebagai gantinya.
### (Opsional) Uji gambar secara lokal
Gunakan [emulator antarmuka runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) untuk menguji gambar Anda secara lokal. Emulator antarmuka runtime disertakan dalam gambar `provided.al2023` dasar.
**Untuk menjalankan emulator antarmuka runtime di mesin lokal Anda**
1. Mulai gambar Docker dengan perintah **docker run**. Perhatikan hal-hal berikut:
+ `docker-image`adalah nama gambar dan `test` tag.
+ `./main`adalah `ENTRYPOINT` dari Dockerfile Anda.
```
docker run -d -p 9000:8080 \
--entrypoint /usr/local/bin/aws-lambda-rie \
docker-image:test ./main
```
Perintah ini menjalankan gambar sebagai wadah dan membuat titik akhir lokal di`localhost:9000/2015-03-31/functions/function/invocations`.
1. Dari jendela terminal baru, posting peristiwa ke titik akhir berikut menggunakan perintah **curl**:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Beberapa fungsi mungkin memerlukan payload JSON. Contoh:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
1. Dapatkan ID kontainer.
```
docker ps
```
1. Gunakan perintah [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) untuk menghentikan wadah. Dalam perintah ini, ganti `3766c4ab331c` dengan ID kontainer dari langkah sebelumnya.
```
docker kill 3766c4ab331c
```
### Menyebarkan gambar
**Untuk mengunggah gambar ke Amazon ECR dan membuat fungsi Lambda**
1. Jalankan [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)perintah untuk mengautentikasi CLI Docker ke registri Amazon ECR Anda.
+ Tetapkan `--region` nilai ke Wilayah AWS tempat Anda ingin membuat repositori Amazon ECR.
+ Ganti `111122223333` dengan Akun AWS ID Anda.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. [Buat repositori di Amazon ECR menggunakan perintah create-repository.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**catatan**
Repositori Amazon ECR harus sama Wilayah AWS dengan fungsi Lambda.
Jika berhasil, Anda melihat respons seperti ini:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Salin `repositoryUri` dari output pada langkah sebelumnya.
1. Jalankan perintah [tag docker](https://docs.docker.com/engine/reference/commandline/tag/) untuk menandai gambar lokal Anda ke repositori Amazon ECR Anda sebagai versi terbaru. Dalam perintah ini:
+ `docker-image:test`adalah nama dan [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) gambar Docker Anda. Ini adalah nama gambar dan tag yang Anda tentukan dalam `docker build` perintah.
+ Ganti `` dengan `repositoryUri` yang Anda salin. Pastikan untuk menyertakan `:latest` di akhir URI.
```
docker tag docker-image:test :latest
```
Contoh:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Jalankan perintah [docker push](https://docs.docker.com/engine/reference/commandline/push/) untuk menyebarkan gambar lokal Anda ke repositori Amazon ECR. Pastikan untuk menyertakan `:latest` di akhir URI repositori.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Buat peran eksekusi](lambda-intro-execution-role.md#permissions-executionrole-api) untuk fungsi tersebut, jika Anda belum memilikinya. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran tersebut di langkah berikutnya.
1. Buat fungsi Lambda. Untuk`ImageUri`, tentukan URI repositori dari sebelumnya. Pastikan untuk menyertakan `:latest` di akhir URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**catatan**
Anda dapat membuat fungsi menggunakan gambar di AWS akun yang berbeda, selama gambar berada di Wilayah yang sama dengan fungsi Lambda. Untuk informasi selengkapnya, lihat [Izin lintas akun Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Memanggil fungsi.
```
aws lambda invoke --function-name hello-world response.json
```
Anda akan melihat tanggapan seperti ini:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Untuk melihat output dari fungsi, periksa `response.json` file.
Untuk memperbarui kode fungsi, Anda harus membangun gambar lagi, mengunggah gambar baru ke repositori Amazon ECR, dan kemudian menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah untuk menyebarkan gambar ke fungsi Lambda.
Lambda menyelesaikan tag gambar ke intisari gambar tertentu. Ini berarti bahwa jika Anda mengarahkan tag gambar yang digunakan untuk menyebarkan fungsi ke gambar baru di Amazon ECR, Lambda tidak secara otomatis memperbarui fungsi untuk menggunakan gambar baru.
Untuk menyebarkan gambar baru ke fungsi Lambda yang sama, Anda harus menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah, meskipun tag gambar di Amazon ECR tetap sama. Dalam contoh berikut, `--publish` opsi membuat versi baru dari fungsi menggunakan gambar kontainer yang diperbarui.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Menggunakan gambar AWS non-dasar
Anda dapat membuat gambar kontainer untuk Go dari gambar AWS non-dasar. Contoh Dockerfile dalam langkah-langkah berikut menggunakan gambar dasar [Alpine](https://hub.docker.com/_/golang/).
Anda harus menyertakan paket [aws-lambda-go/lambda](https://github.com/aws/aws-lambda-go) dengan handler Go Anda. Paket ini mengimplementasikan model pemrograman untuk Go, termasuk antarmuka runtime.
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
+ Go
### Membuat gambar dari gambar dasar alternatif
**Untuk membangun dan menerapkan fungsi Go dengan image dasar Alpine**
1. Buat direktori untuk proyek, dan kemudian beralih ke direktori itu.
```
mkdir hello
cd hello
```
1. Inisialisasi modul Go baru.
```
go mod init example.com/hello-world
```
1. Tambahkan pustaka **lambda** sebagai dependensi modul baru Anda.
```
go get github.com/aws/aws-lambda-go/lambda
```
1. Buat file bernama `main.go` dan kemudian buka di editor teks. Ini adalah kode untuk fungsi Lambda. Anda dapat menggunakan kode contoh berikut untuk pengujian, atau menggantinya dengan kode Anda sendiri.
```
package main
import (
"context"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
response := events.APIGatewayProxyResponse{
StatusCode: 200,
Body: "\"Hello from Lambda!\"",
}
return response, nil
}
func main() {
lambda.Start(handler)
}
```
1. Gunakan editor teks untuk membuat Dockerfile di direktori proyek Anda. Contoh berikut Dockerfile menggunakan gambar dasar [Alpine](https://hub.docker.com/_/golang/). Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example Dockerfile**
**catatan**
Pastikan bahwa versi Go yang Anda tentukan di Dockerfile Anda (misalnya,`golang:1.20`) adalah versi Go yang sama dengan yang Anda gunakan untuk membuat aplikasi Anda.
```
FROM golang:1.20.2-alpine3.16 as build
WORKDIR /helloworld
# Copy dependencies list
COPY go.mod go.sum ./
# Build
COPY main.go .
RUN go build -o main main.go
# Copy artifacts to a clean image
FROM alpine:3.16
COPY --from=build /helloworld/main /main
ENTRYPOINT [ "/main" ]
```
1. Buat image Docker dengan perintah [docker](https://docs.docker.com/engine/reference/commandline/build/) build. Contoh berikut menamai gambar `docker-image` dan memberinya `test` [tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Untuk membuat gambar Anda kompatibel dengan Lambda, Anda harus menggunakan opsi. `--provenance=false`
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**catatan**
Perintah menentukan `--platform linux/amd64` opsi untuk memastikan bahwa container Anda kompatibel dengan lingkungan eksekusi Lambda terlepas dari arsitektur mesin build Anda. Jika Anda berniat untuk membuat fungsi Lambda menggunakan arsitektur set ARM64 instruksi, pastikan untuk mengubah perintah untuk menggunakan `--platform linux/arm64` opsi sebagai gantinya.
### (Opsional) Uji gambar secara lokal
Gunakan [emulator antarmuka runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) untuk menguji gambar secara lokal. Anda dapat [membangun emulator ke dalam gambar Anda](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) atau menggunakan prosedur berikut untuk menginstalnya di mesin lokal Anda.
**Untuk menginstal dan menjalankan emulator antarmuka runtime di mesin lokal Anda**
1. Dari direktori proyek Anda, jalankan perintah berikut untuk mengunduh emulator antarmuka runtime (arsitektur x86-64) dari GitHub dan menginstalnya di mesin lokal Anda.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Untuk menginstal emulator arm64, ganti URL GitHub repositori di perintah sebelumnya dengan yang berikut:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Untuk menginstal emulator arm64, ganti `$downloadLink` dengan yang berikut ini:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Mulai gambar Docker dengan perintah **docker run**. Perhatikan hal-hal berikut:
+ `docker-image`adalah nama gambar dan `test` tag.
+ `/main`adalah `ENTRYPOINT` dari Dockerfile Anda.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/main
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/main
```
------
Perintah ini menjalankan gambar sebagai wadah dan membuat titik akhir lokal di`localhost:9000/2015-03-31/functions/function/invocations`.
**catatan**
Jika Anda membuat image Docker untuk arsitektur set ARM64 instruksi, pastikan untuk menggunakan `--platform linux/arm64` opsi alih-alih. `--platform linux/amd64`
1. Posting acara ke titik akhir lokal.
------
#### [ Linux/macOS ]
Di Linux dan macOS, jalankan perintah berikut: `curl`
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Dalam PowerShell, jalankan `Invoke-WebRequest` perintah berikut:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Dapatkan ID kontainer.
```
docker ps
```
1. Gunakan perintah [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) untuk menghentikan wadah. Dalam perintah ini, ganti `3766c4ab331c` dengan ID kontainer dari langkah sebelumnya.
```
docker kill 3766c4ab331c
```
### Menyebarkan gambar
**Untuk mengunggah gambar ke Amazon ECR dan membuat fungsi Lambda**
1. Jalankan [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)perintah untuk mengautentikasi CLI Docker ke registri Amazon ECR Anda.
+ Tetapkan `--region` nilai ke Wilayah AWS tempat Anda ingin membuat repositori Amazon ECR.
+ Ganti `111122223333` dengan Akun AWS ID Anda.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. [Buat repositori di Amazon ECR menggunakan perintah create-repository.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**catatan**
Repositori Amazon ECR harus sama Wilayah AWS dengan fungsi Lambda.
Jika berhasil, Anda melihat respons seperti ini:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Salin `repositoryUri` dari output pada langkah sebelumnya.
1. Jalankan perintah [tag docker](https://docs.docker.com/engine/reference/commandline/tag/) untuk menandai gambar lokal Anda ke repositori Amazon ECR Anda sebagai versi terbaru. Dalam perintah ini:
+ `docker-image:test`adalah nama dan [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) gambar Docker Anda. Ini adalah nama gambar dan tag yang Anda tentukan dalam `docker build` perintah.
+ Ganti `` dengan `repositoryUri` yang Anda salin. Pastikan untuk menyertakan `:latest` di akhir URI.
```
docker tag docker-image:test :latest
```
Contoh:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Jalankan perintah [docker push](https://docs.docker.com/engine/reference/commandline/push/) untuk menyebarkan gambar lokal Anda ke repositori Amazon ECR. Pastikan untuk menyertakan `:latest` di akhir URI repositori.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Buat peran eksekusi](lambda-intro-execution-role.md#permissions-executionrole-api) untuk fungsi tersebut, jika Anda belum memilikinya. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran tersebut di langkah berikutnya.
1. Buat fungsi Lambda. Untuk`ImageUri`, tentukan URI repositori dari sebelumnya. Pastikan untuk menyertakan `:latest` di akhir URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**catatan**
Anda dapat membuat fungsi menggunakan gambar di AWS akun yang berbeda, selama gambar berada di Wilayah yang sama dengan fungsi Lambda. Untuk informasi selengkapnya, lihat [Izin lintas akun Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Memanggil fungsi.
```
aws lambda invoke --function-name hello-world response.json
```
Anda akan melihat tanggapan seperti ini:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Untuk melihat output dari fungsi, periksa `response.json` file.
Untuk memperbarui kode fungsi, Anda harus membangun gambar lagi, mengunggah gambar baru ke repositori Amazon ECR, dan kemudian menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah untuk menyebarkan gambar ke fungsi Lambda.
Lambda menyelesaikan tag gambar ke intisari gambar tertentu. Ini berarti bahwa jika Anda mengarahkan tag gambar yang digunakan untuk menyebarkan fungsi ke gambar baru di Amazon ECR, Lambda tidak secara otomatis memperbarui fungsi untuk menggunakan gambar baru.
Untuk menyebarkan gambar baru ke fungsi Lambda yang sama, Anda harus menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah, meskipun tag gambar di Amazon ECR tetap sama. Dalam contoh berikut, `--publish` opsi membuat versi baru dari fungsi menggunakan gambar kontainer yang diperbarui.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Bekerja dengan lapisan untuk fungsi Go Lambda
Kami tidak menyarankan menggunakan [lapisan](chapter-layers.md) untuk mengelola dependensi untuk fungsi Lambda yang ditulis dalam Go. Ini karena fungsi Lambda di Go 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 Go Anda, sertakan dependensi tersebut secara langsung dalam paket penerapan Anda. Dengan demikian, Anda menyederhanakan proses penerapan dan juga memanfaatkan pengoptimalan kompiler Go bawaan. Untuk contoh cara mengimpor dan menggunakan dependensi seperti AWS SDK for Go dalam fungsi Anda, lihat. [Tentukan penangan fungsi Lambda di Go](golang-handler.md)
# Log dan pantau fungsi Go Lambda
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
](#golang-logging-output)
+ [
## Melihat log di konsol Lambda
](#golang-logging-console)
+ [
## Melihat log di CloudWatch konsol
](#golang-logging-cwconsole)
+ [
## Melihat log menggunakan AWS Command Line Interface (AWS CLI)
](#golang-logging-cli)
+ [
## Menghapus log
](#golang-logging-delete)
## Membuat fungsi yang mengembalikan log
Untuk menghasilkan log dari kode fungsi, Anda dapat menggunakan metode di [paket fmt](https://golang.org/pkg/fmt/), atau pustaka pencatatan apa pun yang menulis ke `stdout` atau `stderr`. Contoh berikut menggunakan [paket log](https://golang.org/pkg/log/).
**Example [main.go](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-go/function/main.go) – Pencatatan**
```
func handleRequest(ctx context.Context, event events.SQSEvent) (string, error) {
// event
eventJson, _ := json.MarshalIndent(event, "", " ")
log.Printf("EVENT: %s", eventJson)
// environment variables
log.Printf("REGION: %s", os.Getenv("AWS_REGION"))
log.Println("ALL ENV VARS:")
for _, element := range os.Environ() {
log.Println(element)
}
```
**Example format log**
```
START RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Version: $LATEST
2020/03/27 03:40:05 EVENT: {
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
"md5OfBody": "7b27xmplb47ff90a553787216d55d91d",
"md5OfMessageAttributes": "",
"attributes": {
"ApproximateFirstReceiveTimestamp": "1523232000001",
"ApproximateReceiveCount": "1",
"SenderId": "123456789012",
"SentTimestamp": "1523232000000"
},
...
2020/03/27 03:40:05 AWS_LAMBDA_LOG_STREAM_NAME=2020/03/27/[$LATEST]569cxmplc3c34c7489e6a97ad08b4419
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_NAME=blank-go-function-9DV3XMPL6XBC
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_MEMORY_SIZE=128
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_VERSION=$LATEST
2020/03/27 03:40:05 AWS_EXECUTION_ENV=AWS_Lambda_go1.x
END RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71
REPORT RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Duration: 38.66 ms Billed Duration: 243 ms Memory Size: 128 MB Max Memory Used: 54 MB Init Duration: 203.69 ms
XRAY TraceId: 1-5e7d7595-212fxmpl9ee07c4884191322 SegmentId: 42ffxmpl0645f474 Sampled: true
```
Runtime Go akan mencatat baris `START`, `END`, dan `REPORT` untuk setiap invokasi. Baris laporan memberikan detail 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.
## Melihat log di konsol Lambda
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
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)
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
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.
# Menginstrumentasi kode Go di AWS Lambda
Lambda terintegrasi dengan AWS X-Ray untuk membantu Anda melacak, men-debug, dan mengoptimalkan aplikasi Lambda. Anda dapat menggunakan X-Ray untuk melacak permintaan saat melintasi sumber daya dalam aplikasi Anda, yang mungkin termasuk fungsi Lambda dan layanan lainnya. AWS
Untuk mengirim data penelusuran ke X-Ray, Anda dapat menggunakan salah satu dari dua pustaka SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) — Distribusi SDK () yang aman, siap produksi, dan AWS didukung. OpenTelemetry OTel
+ [AWS X-Ray SDK for](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-go.html) Go — SDK untuk menghasilkan dan mengirim data jejak ke X-Ray.
Masing-masing SDKs menawarkan cara untuk mengirim data telemetri Anda ke layanan X-Ray. Anda kemudian dapat menggunakan X-Ray untuk melihat, memfilter, dan mendapatkan wawasan tentang metrik kinerja aplikasi Anda untuk mengidentifikasi masalah dan peluang pengoptimalan.
**penting**
X-Ray dan Powertools untuk AWS Lambda SDKs adalah bagian dari solusi instrumentasi terintegrasi yang ditawarkan oleh. AWS Lapisan Lambda ADOT adalah bagian dari standar industri untuk melacak instrumentasi yang mengumpulkan lebih banyak data secara umum, tetapi mungkin tidak cocok untuk semua kasus penggunaan. Anda dapat menerapkan end-to-end penelusuran di X-Ray menggunakan salah satu solusi. Untuk mempelajari lebih lanjut tentang memilih di antara mereka, lihat [Memilih antara AWS Distro untuk Telemetri Terbuka dan](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) X-Ray. SDKs
**Topics**
+ [
## Menggunakan ADOT untuk instrumen fungsi Go Anda
](#golang-adot)
+ [
## Menggunakan X-Ray SDK untuk instrumen fungsi Go Anda
](#golang-xray-sdk)
+ [
## Mengaktifkan penelusuran dengan konsol Lambda
](#golang-tracing-console)
+ [
## Mengaktifkan penelusuran dengan Lambda API
](#golang-tracing-api)
+ [
## Mengaktifkan penelusuran dengan CloudFormation
](#golang-tracing-cloudformation)
+ [
## Menafsirkan jejak X-Ray
](#golang-tracing-interpretation)
## Menggunakan ADOT untuk instrumen fungsi Go Anda
ADOT menyediakan lapisan [Lambda](chapter-layers.md) yang dikelola sepenuhnya yang mengemas semua yang Anda butuhkan untuk mengumpulkan data telemetri menggunakan SDK. OTel Dengan menggunakan lapisan ini, Anda dapat menginstruksikan fungsi Lambda Anda tanpa harus memodifikasi kode fungsi apa pun. Anda juga dapat mengonfigurasi lapisan Anda untuk melakukan inisialisasi kustom. OTel Untuk informasi selengkapnya, lihat [Konfigurasi khusus untuk Kolektor ADOT di Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) dalam dokumentasi ADOT.
Untuk runtime Go, Anda dapat menambahkan **layer Lambda AWS terkelola untuk ADOT Go untuk** secara otomatis menginstruksikan fungsi Anda. Untuk petunjuk rinci tentang cara menambahkan layer ini, lihat [AWS Distro untuk OpenTelemetry Lambda Support for](https://aws-otel.github.io/docs/getting-started/lambda/lambda-go) Go di dokumentasi ADOT.
## Menggunakan X-Ray SDK untuk instrumen fungsi Go Anda
Untuk merekam detail tentang panggilan yang dilakukan fungsi Lambda ke sumber daya lain di aplikasi, Anda juga dapat menggunakan AWS X-Ray SDK for Go. Untuk mendapatkan SDK, unduh SDK dari [GitHub repositorinya](https://github.com/aws/aws-xray-sdk-go) dengan: `go get`
```
go get github.com/aws/aws-xray-sdk-go
```
Untuk instrumen klien AWS SDK, teruskan klien ke `xray.AWS()` metode. Anda kemudian dapat melacak panggilan dengan menggunakan `WithContext` versi metode.
```
svc := s3.New(session.New())
xray.AWS(svc.Client)
...
svc.ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput)
```
Setelah Anda menambahkan dependensi yang benar dan membuat perubahan kode yang diperlukan, aktifkan penelusuran dalam konfigurasi fungsi Anda melalui konsol Lambda atau API.
## Mengaktifkan penelusuran dengan konsol Lambda
Untuk mengaktifkan penelusuran aktif pada fungsi Lambda Anda dengan konsol, ikuti langkah-langkah berikut:
**Untuk mengaktifkan penelusuran aktif**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi.
1. Pilih **Konfigurasi** dan kemudian pilih **Alat Pemantauan dan operasi**.
1. Di bawah **Alat pemantauan tambahan**, pilih **Edit**.
1. Di bawah **Sinyal CloudWatch Aplikasi dan AWS X-Ray**, pilih **Aktifkan** untuk **jejak layanan Lambda**.
1. Pilih **Simpan**.
## Mengaktifkan penelusuran dengan Lambda API
Konfigurasikan penelusuran pada fungsi Lambda Anda dengan AWS CLI AWS atau SDK, gunakan operasi API berikut:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
Contoh AWS CLI perintah berikut memungkinkan penelusuran aktif pada fungsi bernama **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
Mode penelusuran adalah bagian dari konfigurasi khusus versi saat Anda memublikasikan versi fungsi Anda. Anda tidak dapat mengubah mode pelacakan pada versi yang telah diterbitkan.
## Mengaktifkan penelusuran dengan CloudFormation
Untuk mengaktifkan penelusuran pada `AWS::Lambda::Function` sumber daya dalam CloudFormation templat, gunakan `TracingConfig` properti.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Konfigurasi pelacakan**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Untuk sumber `AWS::Serverless::Function` daya AWS Serverless Application Model (AWS SAM), gunakan `Tracing` properti.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Konfigurasi pelacakan**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Menafsirkan jejak X-Ray
Fungsi Anda memerlukan izin untuk mengunggah data jejak ke X-Ray. [Saat Anda mengaktifkan penelusuran di konsol Lambda, Lambda menambahkan izin yang diperlukan ke peran eksekusi fungsi Anda.](lambda-intro-execution-role.md) Atau, tambahkan kebijakan [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) ke peran eksekusi.
Setelah mengonfigurasi penelusuran aktif, Anda dapat mengamati permintaan tertentu melalui aplikasi Anda. [Grafik layanan X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) menunjukkan informasi tentang aplikasi Anda dan semua komponennya. Contoh berikut menunjukkan aplikasi dengan dua fungsi. Fungsi utama memproses kejadian dan terkadang mengembalikan kesalahan. Fungsi kedua di bagian atas memproses kesalahan yang muncul di grup log pertama dan menggunakan AWS SDK untuk memanggil X-Ray, Amazon Simple Storage Service (Amazon S3), dan Amazon Logs. CloudWatch
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray tidak melacak semua permintaan ke aplikasi Anda. X-Ray menerapkan algoritma pengambilan sampel untuk memastikan bahwa penelusuran efisien, sambil tetap memberikan sampel yang representatif dari semua permintaan. Tingkat pengambilan sampel adalah 1 permintaan per detik dan 5 persen dari permintaan tambahan. Anda tidak dapat mengonfigurasi laju pengambilan sampel X-Ray untuk fungsi Anda.
Di X-Ray, *jejak* merekam informasi tentang permintaan yang diproses oleh satu atau beberapa *layanan*. Lambda mencatat 2 segmen per jejak, yang menciptakan dua node pada grafik layanan. Gambar berikut menyoroti dua node ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/xray-servicemap-function.png)
Node pertama di sebelah kiri mewakili layanan Lambda, yang menerima permintaan pemanggilan. Node kedua mewakili fungsi Lambda spesifik Anda. Contoh berikut menunjukkan jejak dengan dua segmen ini. Keduanya bernama **fungsi saya**, tetapi yang satu memiliki asal `AWS::Lambda` dan yang lainnya memiliki asal usul. `AWS::Lambda::Function` Jika `AWS::Lambda` segmen menunjukkan kesalahan, layanan Lambda mengalami masalah. Jika `AWS::Lambda::Function` segmen menunjukkan kesalahan, fungsi Anda mengalami masalah.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Contoh ini memperluas `AWS::Lambda::Function` segmen untuk menunjukkan tiga subsegmennya.
**catatan**
AWS saat ini menerapkan perubahan pada layanan Lambda. Karena perubahan ini, Anda mungkin melihat perbedaan kecil antara struktur dan konten pesan log sistem dan segmen jejak yang dipancarkan oleh fungsi Lambda yang berbeda di Anda. Akun AWS
Contoh jejak yang ditunjukkan di sini menggambarkan segmen fungsi gaya lama. Perbedaan antara segmen gaya lama dan baru dijelaskan dalam paragraf berikut.
Perubahan ini akan diterapkan selama beberapa minggu mendatang, dan semua fungsi di semua Wilayah AWS kecuali China GovCloud dan wilayah akan bertransisi untuk menggunakan pesan log format baru dan segmen pelacakan.
Segmen fungsi gaya lama berisi subsegmen berikut:
+ **Inisialisasi** – Mewakili waktu yang dihabiskan untuk memuat fungsi dan menjalankan [kode inisialisasi](foundation-progmodel.md). Subsegmen ini hanya muncul untuk peristiwa pertama yang diproses oleh setiap instance fungsi Anda.
+ **Doa** - Merupakan waktu yang dihabiskan untuk menjalankan kode handler Anda.
+ **Overhead** - Merupakan waktu yang dihabiskan runtime Lambda untuk mempersiapkan diri untuk menangani acara berikutnya.
Segmen fungsi gaya baru tidak berisi subsegmen. `Invocation` Sebagai gantinya, subsegmen pelanggan dilampirkan langsung ke segmen fungsi. Untuk informasi lebih lanjut tentang struktur segmen fungsi gaya lama dan baru, lihat. [Memahami jejak X-Ray](services-xray.md#services-xray-traces)
Anda juga dapat melakukan instrumentasi klien HTTP, merekam kueri SQL, dan membuat subsegmen khusus dengan anotasi dan metadata. Untuk informasi selengkapnya, lihat [AWS X-Ray SDK for](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) Go di Panduan *AWS X-Ray Pengembang*.
**Harga**
Anda dapat menggunakan penelusuran X-Ray secara gratis setiap bulan hingga batas tertentu sebagai bagian dari Tingkat AWS Gratis. Di luar ambang batas itu, X-Ray mengenakan biaya untuk penyimpanan dan pengambilan jejak. Untuk informasi lebih lanjut, lihat [ Harga AWS X-Ray](https://aws.amazon.com/xray/pricing/).