Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Gunakan rahasia Secrets Manager dalam fungsi Lambda
AWS Secrets Manager membantu Anda mengelola kredensi, kunci API, dan rahasia lain yang dibutuhkan fungsi Lambda Anda. Anda memiliki dua pendekatan utama untuk mengambil rahasia dalam fungsi Lambda Anda, keduanya menawarkan kinerja yang lebih baik dan biaya yang lebih rendah dibandingkan dengan mengambil rahasia secara langsung menggunakan SDK: AWS
+ **AWS parameter dan rahasia Ekstensi Lambda** - Solusi runtime-agnostik yang menyediakan antarmuka HTTP sederhana untuk mengambil rahasia
+ **Powertools untuk utilitas AWS Lambda parameter** - Solusi terintegrasi kode yang mendukung beberapa penyedia (Secrets Manager, Parameter Store, AppConfig) dengan transformasi bawaan
Kedua pendekatan mempertahankan cache rahasia lokal, menghilangkan kebutuhan fungsi Anda untuk memanggil Secrets Manager untuk setiap pemanggilan. Ketika fungsi Anda meminta rahasia, cache diperiksa terlebih dahulu. Jika rahasia tersedia dan belum kedaluwarsa, itu segera dikembalikan. Jika tidak, itu diambil dari Secrets Manager, di-cache, dan dikembalikan. Mekanisme caching ini menghasilkan waktu respons yang lebih cepat dan mengurangi biaya dengan meminimalkan panggilan API.
## Memilih pendekatan
Pertimbangkan faktor-faktor ini ketika memilih antara ekstensi dan PowerTools:
Gunakan AWS parameter dan rahasia ekstensi Lambda saat:
+ Anda menginginkan solusi runtime-agnostik yang berfungsi dengan runtime Lambda apa pun
+ Anda memilih untuk tidak menambahkan dependensi kode ke fungsi Anda
+ Anda hanya perlu mengambil rahasia dari Secrets Manager atau Parameter Store
Gunakan Powertools untuk utilitas AWS Lambda parameter saat:
+ Anda menginginkan pengalaman pengembangan terintegrasi dengan kode aplikasi Anda
+ Anda memerlukan dukungan untuk beberapa penyedia (Secrets Manager, Parameter Store, AppConfig)
+ Anda ingin transformasi data bawaan (penguraian JSON, decoding base64)
+ Anda menggunakan runtime Python,, Java TypeScript, atau .NET
## Kapan menggunakan Secrets Manager dengan Lambda
Skenario umum untuk menggunakan Secrets Manager dengan Lambda meliputi:
+ Menyimpan kredensi database yang digunakan fungsi Anda untuk terhubung ke Amazon RDS atau database lainnya
+ Mengelola kunci API untuk layanan eksternal yang dipanggil fungsi Anda
+ Menyimpan kunci enkripsi atau data konfigurasi sensitif lainnya
+ Memutar kredensil secara otomatis tanpa perlu memperbarui kode fungsi Anda
## Menggunakan AWS parameter dan rahasia ekstensi Lambda
AWS Parameter dan rahasia ekstensi Lambda menggunakan antarmuka HTTP sederhana yang kompatibel dengan runtime Lambda apa pun. Secara default, ini menyimpan rahasia selama 300 detik (5 menit) dan dapat menampung hingga 1.000 rahasia. Anda dapat [menyesuaikan pengaturan ini dengan variabel lingkungan](#lambda-secrets-manager-env-vars).
### Gunakan Secrets Manager dalam fungsi Lambda
Bagian ini mengasumsikan bahwa Anda sudah memiliki rahasia Secrets Manager. Untuk membuat rahasia, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
#### Buat paket deployment
Pilih runtime pilihan Anda dan ikuti langkah-langkah untuk membuat fungsi yang mengambil rahasia dari Secrets Manager. Fungsi contoh mengambil rahasia dari Secrets Manager dan dapat digunakan untuk mengakses kredensi database, kunci API, atau data konfigurasi sensitif lainnya dalam aplikasi Anda.
------
#### [ Python ]
**Untuk membuat fungsi Python**
1. Buat dan arahkan ke direktori proyek baru. Contoh:
```
mkdir my_function
cd my_function
```
1. Buat file bernama `lambda_function.py` dengan kode berikut. Untuk`secret_name`, gunakan nama atau Amazon Resource Name (ARN) rahasia Anda.
```
import json
import os
import requests
def lambda_handler(event, context):
try:
# Replace with the name or ARN of your secret
secret_name = "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME"
secrets_extension_endpoint = f"http://localhost:2773/secretsmanager/get?secretId={secret_name}"
headers = {"X-Aws-Parameters-Secrets-Token": os.environ.get('AWS_SESSION_TOKEN')}
response = requests.get(secrets_extension_endpoint, headers=headers)
print(f"Response status code: {response.status_code}")
secret = json.loads(response.text)["SecretString"]
print(f"Retrieved secret: {secret}")
return {
'statusCode': response.status_code,
'body': json.dumps({
'message': 'Successfully retrieved secret',
'secretRetrieved': True
})
}
except Exception as e:
print(f"Error: {str(e)}")
return {
'statusCode': 500,
'body': json.dumps({
'message': 'Error retrieving secret',
'error': str(e)
})
}
```
1. Buat file bernama `requirements.txt` dengan konten ini:
```
requests
```
1. Instal dependensi:
```
pip install -r requirements.txt -t .
```
1. Buat file.zip yang berisi semua file:
```
zip -r function.zip .
```
------
#### [ Node.js ]
**Untuk membuat fungsi Node.js**
1. Buat dan arahkan ke direktori proyek baru. Contoh:
```
mkdir my_function
cd my_function
```
1. Buat file bernama `index.mjs` dengan kode berikut. Untuk`secret_name`, gunakan nama atau Amazon Resource Name (ARN) rahasia Anda.
```
import http from 'http';
export const handler = async (event) => {
try {
// Replace with the name or ARN of your secret
const secretName = "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME";
const options = {
hostname: 'localhost',
port: 2773,
path: `/secretsmanager/get?secretId=${secretName}`,
headers: {
'X-Aws-Parameters-Secrets-Token': process.env.AWS_SESSION_TOKEN
}
};
const response = await new Promise((resolve, reject) => {
http.get(options, (res) => {
let data = '';
res.on('data', (chunk) => { data += chunk; });
res.on('end', () => {
resolve({
statusCode: res.statusCode,
body: data
});
});
}).on('error', reject);
});
const secret = JSON.parse(response.body).SecretString;
console.log('Retrieved secret:', secret);
return {
statusCode: response.statusCode,
body: JSON.stringify({
message: 'Successfully retrieved secret',
secretRetrieved: true
})
};
} catch (error) {
console.error('Error:', error);
return {
statusCode: 500,
body: JSON.stringify({
message: 'Error retrieving secret',
error: error.message
})
};
}
};
```
1. Buat file.zip yang berisi `index.mjs` file:
```
zip -r function.zip index.mjs
```
------
#### [ Java ]
**Untuk membuat fungsi Java**
1. Buat proyek Maven:
```
mvn archetype:generate \
-DgroupId=example \
-DartifactId=lambda-secrets-demo \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DarchetypeVersion=1.4 \
-DinteractiveMode=false
```
1. Arahkan ke direktori proyek:
```
cd lambda-secrets-demo
```
1. Buka `pom.xml` dan ganti isinya dengan yang berikut:
```
4.0.0
example
lambda-secrets-demo
1.0-SNAPSHOT
11
11
com.amazonaws
aws-lambda-java-core
1.2.1
org.apache.maven.plugins
maven-shade-plugin
3.2.4
package
shade
false
function
```
1. Ganti nama `/lambda-secrets-demo/src/main/java/example/App.java` `Hello.java` untuk mencocokkan nama penangan Java default Lambda (): `example.Hello::handleRequest`
```
mv src/main/java/example/App.java src/main/java/example/Hello.java
```
1. Buka `Hello.java` file dan ganti isinya dengan yang berikut ini. Untuk`secretName`, gunakan nama atau Amazon Resource Name (ARN) rahasia Anda.
```
package example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Hello implements RequestHandler {
private final HttpClient client = HttpClient.newHttpClient();
@Override
public String handleRequest(Object input, Context context) {
try {
// Replace with the name or ARN of your secret
String secretName = "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME";
String endpoint = "http://localhost:2773/secretsmanager/get?secretId=" + secretName;
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(endpoint))
.header("X-Aws-Parameters-Secrets-Token", System.getenv("AWS_SESSION_TOKEN"))
.GET()
.build();
HttpResponse response = client.send(request,
HttpResponse.BodyHandlers.ofString());
String secret = response.body();
secret = secret.substring(secret.indexOf("SecretString") + 15);
secret = secret.substring(0, secret.indexOf("\""));
System.out.println("Retrieved secret: " + secret);
return String.format(
"{\"statusCode\": %d, \"body\": \"%s\"}",
response.statusCode(), "Successfully retrieved secret"
);
} catch (Exception e) {
e.printStackTrace();
return String.format(
"{\"body\": \"Error retrieving secret: %s\"}",
e.getMessage()
);
}
}
}
```
1. Hapus direktori pengujian. Maven membuat ini secara default, tetapi kami tidak membutuhkannya untuk contoh ini.
```
rm -rf src/test
```
1. Membangun proyek:
```
mvn package
```
1. Unduh file JAR (`target/function.jar`) untuk digunakan nanti.
------
#### Buat fungsi
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih **Buat fungsi**.
1. Pilih **Penulis dari awal**.
1. Untuk **Nama fungsi**, masukkan **secret-retrieval-demo**.
1. Pilih **Runtime** pilihan Anda.
1. Pilih **Buat fungsi**.
**Untuk meng-upload paket deployment**
1. Di tab **Kode** fungsi, pilih **Unggah dari** dan pilih **file.zip** (untuk Python dan Node.js) **atau file.jar** (untuk Java).
1. Unggah paket penerapan yang Anda buat sebelumnya.
1. Pilih **Simpan**.
#### Tambahkan ekstensi
**Untuk menambahkan ekstensi AWS Parameter dan Rahasia Lambda sebagai lapisan**
1. Di tab **Code** fungsi, gulir ke bawah ke **Layers**.
1. Pilih **Tambahkan lapisan**.
1. Pilih **AWS layer**.
1. Pilih **AWS-Parameter-dan-rahasia-Lambda-ekstensi**.
1. Pilih versi terbaru.
1. Pilih **Tambahkan**.
#### Tambahkan izin
**Untuk menambahkan izin Secrets Manager ke peran eksekusi**
1. Pilih tab **Konfigurasi**, lalu pilih **Izin**.
1. Di bawah **Nama peran**, pilih tautan ke peran eksekusi Anda. Tautan ini membuka peran di konsol IAM.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/execution-role-console.png)
1. Pilih **Tambahkan izin**, lalu pilih **Buat kebijakan sebaris**.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/create-inline-policy.png)
1. Pilih tab **JSON** dan tambahkan kebijakan berikut. Untuk`Resource`, masukkan ARN rahasia Anda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME"
}
]
}
```
------
1. Pilih **Berikutnya**.
1. Masukkan nama untuk kebijakan.
1. Pilih **Buat kebijakan**.
#### Uji fungsi
**Untuk menguji fungsi**
1. Kembali ke konsol Lambda.
1. Pilih tab **Uji**.
1. Pilih **Uji**. Anda akan melihat tanggapan berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/execution-results-secret.png)
### Variabel-variabel lingkungan
Ekstensi AWS Parameter dan Rahasia Lambda menggunakan pengaturan default berikut. Anda dapat mengganti pengaturan ini dengan membuat [variabel lingkungan](configuration-envvars.md#create-environment-variables) yang sesuai. Untuk melihat pengaturan saat ini untuk suatu fungsi, setel `PARAMETERS_SECRETS_EXTENSION_LOG_LEVEL` ke`DEBUG`. Ekstensi akan mencatat informasi konfigurasinya ke CloudWatch Log pada awal setiap pemanggilan fungsi.
| Pengaturan | Nilai default | Nilai valid | Variabel lingkungan | Detail |
| --- | --- | --- | --- | --- |
| Port HTTP | 2773 | 1 - 65535 | PARAMETER\$1SECRETS\$1EXTENSION\$1HTTP\$1PORT | Port untuk server HTTP lokal |
| Cache diaktifkan | BETUL | TRUE \$1 FALSE | PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1ENABLED | Aktifkan atau nonaktifkan cache |
| Ukuran cache | 1000 | 0 - 1000 | PARAMETER\$1SECRETS\$1EXTENSION\$1CACHE\$1SIZE | Setel ke 0 untuk menonaktifkan caching |
| Secrets Manager TTL | 300 detik | 0 - 300 detik | SECRETS\$1MANAGER\$1TTL | Time-to-live untuk rahasia yang di-cache. Setel ke 0 untuk menonaktifkan caching. Variabel ini diabaikan jika nilai untuk PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1SIZE adalah 0. |
| Parameter Toko TTL | 300 detik | 0 - 300 detik | SSM\$1PARAMETER\$1STORE\$1TTL | Time-to-live untuk parameter cache. Setel ke 0 untuk menonaktifkan caching. Variabel ini diabaikan jika nilai untuk PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1SIZE adalah 0. |
| Tingkat log | INFO | DEBUG \$1 INFO \$1 PERINGATAN \$1 KESALAHAN \$1 TIDAK ADA | PARAMETER\$1SECRETS\$1EXTENSION\$1LOG\$1LEVEL | Tingkat detail yang dilaporkan dalam log untuk ekstensi |
| Koneksi maks | 3 | 1 atau lebih | PARAMETER\$1SECRETS\$1EXTENSION\$1MAX\$1CONNECTIONS | Jumlah maksimum koneksi HTTP untuk permintaan ke Parameter Store atau Secrets Manager |
| Batas waktu Secrets Manager | 0 (tidak ada batas waktu) | Semua bilangan bulat | SECRETS\$1MANAGER\$1TIMEOUT\$1MILLIS | Batas waktu untuk permintaan ke Secrets Manager (dalam milidetik) |
| Batas waktu penyimpanan Parameter | 0 (tidak ada batas waktu) | Semua bilangan bulat | SSM\$1PARAMETER\$1STORE\$1TIMEOUT\$1MILLIS | Batas waktu untuk permintaan ke Parameter Store (dalam milidetik) |
### Bekerja dengan rotasi rahasia
Jika Anda sering memutar rahasia, durasi cache default 300 detik dapat menyebabkan fungsi Anda menggunakan rahasia yang sudah ketinggalan zaman. Anda memiliki dua opsi untuk memastikan fungsi Anda menggunakan nilai rahasia terbaru:
+ Kurangi cache TTL dengan mengatur variabel `SECRETS_MANAGER_TTL` lingkungan ke nilai yang lebih rendah (dalam hitungan detik). Misalnya, mengaturnya untuk `60` memastikan fungsi Anda tidak akan pernah menggunakan rahasia yang berumur lebih dari satu menit.
+ Gunakan label `AWSCURRENT` atau `AWSPREVIOUS` pementasan dalam permintaan rahasia Anda untuk memastikan Anda mendapatkan versi spesifik yang Anda inginkan:
```
secretsmanager/get?secretId=YOUR_SECRET_NAME&versionStage=AWSCURRENT
```
Pilih pendekatan yang paling menyeimbangkan kebutuhan Anda akan kinerja dan kesegaran. TTL yang lebih rendah berarti panggilan yang lebih sering ke Secrets Manager tetapi memastikan Anda bekerja dengan nilai rahasia terbaru.
## Menggunakan utilitas parameter dari Powertools untuk AWS Lambda
Utilitas parameter dari Powertools untuk AWS Lambda menyediakan antarmuka terpadu untuk mengambil rahasia dari beberapa penyedia termasuk Secrets Manager, penyimpanan parameter, dan. AppConfig Ini menangani caching, transformasi, dan memberikan pengalaman pengembangan yang lebih terintegrasi dibandingkan dengan pendekatan ekstensi.
### Manfaat utilitas parameter
+ **Beberapa penyedia** - Ambil parameter dari Secrets Manager, Parameter Store, dan AppConfig menggunakan antarmuka yang sama
+ **Transformasi bawaan** - Penguraian JSON otomatis, decoding base64, dan transformasi data lainnya
+ **Caching terintegrasi - Caching** yang dapat dikonfigurasi dengan dukungan TTL untuk mengurangi panggilan API
+ **Keamanan tipe** - Dukungan pengetikan yang kuat di TypeScript dan runtime lain yang didukung
+ **Penanganan kesalahan** - Logika coba ulang bawaan dan penanganan kesalahan
### Contoh kode
Contoh berikut menunjukkan cara mengambil rahasia menggunakan utilitas Parameter di runtime yang berbeda:
**Python**
Untuk contoh lengkap dan petunjuk penyiapan, lihat [dokumentasi utilitas Parameter](https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/).
Mengambil rahasia dari Secrets Manager dengan Powertools untuk utilitas AWS Lambda Parameter.
```
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities import parameters
logger = Logger()
def lambda_handler(event, context):
try:
# Get secret with caching (default TTL: 5 seconds)
secret_value = parameters.get_secret("my-secret-name")
# Get secret with custom TTL
secret_with_ttl = parameters.get_secret("my-secret-name", max_age=300)
# Get secret and transform JSON
secret_json = parameters.get_secret("my-json-secret", transform="json")
logger.info("Successfully retrieved secrets")
return {
'statusCode': 200,
'body': 'Successfully retrieved secrets'
}
except Exception as e:
logger.error(f"Error retrieving secret: {str(e)}")
return {
'statusCode': 500,
'body': f'Error: {str(e)}'
}
```
**TypeScript**
Untuk contoh lengkap dan petunjuk penyiapan, lihat [dokumentasi utilitas Parameter](https://docs.aws.amazon.com/powertools/typescript/2.1.1/utilities/parameters/).
Mengambil rahasia dari Secrets Manager dengan Powertools untuk utilitas AWS Lambda Parameter.
```
import { Logger } from '@aws-lambda-powertools/logger';
import { getSecret } from '@aws-lambda-powertools/parameters/secrets';
import type { Context } from 'aws-lambda';
const logger = new Logger();
export const handler = async (event: any, context: Context) => {
try {
// Get secret with caching (default TTL: 5 seconds)
const secretValue = await getSecret('my-secret-name');
// Get secret with custom TTL
const secretWithTtl = await getSecret('my-secret-name', { maxAge: 300 });
// Get secret and transform JSON
const secretJson = await getSecret('my-json-secret', { transform: 'json' });
logger.info('Successfully retrieved secrets');
return {
statusCode: 200,
body: 'Successfully retrieved secrets'
};
} catch (error) {
logger.error('Error retrieving secret', { error });
return {
statusCode: 500,
body: `Error: ${error}`
};
}
};
```
**Java**
Untuk contoh lengkap dan petunjuk penyiapan, lihat [dokumentasi utilitas Parameter](https://docs.powertools.aws.dev/lambda/java/latest/utilities/parameters/).
Mengambil rahasia dari Secrets Manager dengan Powertools untuk utilitas AWS Lambda Parameter.
```
import software.amazon.lambda.powertools.logging.Logging;
import software.amazon.lambda.powertools.parameters.SecretsProvider;
import software.amazon.lambda.powertools.parameters.ParamManager;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class SecretHandler implements RequestHandler {
private final SecretsProvider secretsProvider = ParamManager.getSecretsProvider();
@Logging
@Override
public String handleRequest(Object input, Context context) {
try {
// Get secret with caching (default TTL: 5 seconds)
String secretValue = secretsProvider.get("my-secret-name");
// Get secret with custom TTL (300 seconds)
String secretWithTtl = secretsProvider.withMaxAge(300).get("my-secret-name");
// Get secret and transform JSON
MySecret secretJson = secretsProvider.get("my-json-secret", MySecret.class);
return "Successfully retrieved secrets";
} catch (Exception e) {
return "Error retrieving secret: " + e.getMessage();
}
}
public static class MySecret {
// Define your secret structure here
}
}
```
**.NET**
Untuk contoh lengkap dan petunjuk penyiapan, lihat [dokumentasi utilitas Parameter](https://docs.aws.amazon.com/powertools/typescript/latest/features/parameters/).
Mengambil rahasia dari Secrets Manager dengan Powertools untuk utilitas AWS Lambda Parameter.
```
using AWS.Lambda.Powertools.Logging;
using AWS.Lambda.Powertools.Parameters;
using Amazon.Lambda.Core;
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
public class Function
{
private readonly ISecretsProvider _secretsProvider;
public Function()
{
_secretsProvider = ParametersManager.SecretsProvider;
}
[Logging]
public async Task FunctionHandler(object input, ILambdaContext context)
{
try
{
// Get secret with caching (default TTL: 5 seconds)
var secretValue = await _secretsProvider.GetAsync("my-secret-name");
// Get secret with custom TTL
var secretWithTtl = await _secretsProvider.WithMaxAge(TimeSpan.FromMinutes(5))
.GetAsync("my-secret-name");
// Get secret and transform JSON
var secretJson = await _secretsProvider.GetAsync("my-json-secret");
return "Successfully retrieved secrets";
}
catch (Exception e)
{
return $"Error retrieving secret: {e.Message}";
}
}
public class MySecret
{
// Define your secret structure here
}
}
```
### Pengaturan dan izin
Untuk menggunakan utilitas Parameter, Anda perlu:
1. Instal Powertools AWS Lambda untuk runtime Anda. Lihat perinciannya di [Powertools untuk AWS Lambda](powertools-for-lambda.md).
1. Tambahkan izin IAM yang diperlukan ke peran eksekusi fungsi Anda. Lihat [Mengelola izin di AWS Lambda](lambda-permissions.md) untuk detailnya.
1. Konfigurasikan pengaturan opsional apa pun melalui [variabel lingkungan](configuration-envvars.md).
Izin IAM yang diperlukan sama dengan pendekatan ekstensi. Utilitas akan secara otomatis menangani caching dan panggilan API ke Secrets Manager berdasarkan konfigurasi Anda.