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

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

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
<a name="golang-context-library"></a>

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
<a name="golang-context-access"></a>

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
<a name="golang-context-sdk"></a>

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.