Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Uso dei segreti in Secrets Manager nelle funzioni Lambda Gestione dei segreti AWS ti aiuta a gestire credenziali, chiavi API e altri segreti necessari alle tue funzioni Lambda. Esistono due approcci principali per il recupero dei segreti nelle funzioni Lambda, entrambi offrono prestazioni migliori e costi inferiori rispetto al recupero diretto dei segreti tramite l'SDK: AWS + **AWS parametri e segreti Estensione Lambda**: una soluzione indipendente dal runtime che fornisce una semplice interfaccia HTTP per il recupero dei segreti + **Powertools for AWS Lambda parameters utility**: una soluzione integrata nel codice che supporta più provider (Secrets Manager, Parameter Store AppConfig) con trasformazioni integrate Entrambi gli approcci mantengono cache locali di segreti, eliminando la necessità per la funzione di chiamare Secrets Manager per ogni invocazione. Quando la funzione richiede un segreto, la cache viene controllata per prima. Se il segreto è disponibile e non è scaduto, viene restituito immediatamente. Altrimenti, viene recuperato da Secrets Manager, memorizzato nella cache e restituito. Questo meccanismo di memorizzazione nella cache consente tempi di risposta più rapidi e costi ridotti riducendo al minimo le chiamate API. ## Scelta di un approccio Considerate questi fattori quando scegliete tra l'estensione e: PowerTools Usa l'estensione Lambda AWS Parametri e segreti quando: + Vuoi una soluzione indipendente dal runtime che funzioni con qualsiasi runtime Lambda + Preferisci non aggiungere dipendenze di codice alla tua funzione + Devi solo recuperare i segreti da Secrets Manager o Parameter Store Utilizzate Powertools per l'utilità AWS Lambda dei parametri quando: + Vuoi un'esperienza di sviluppo integrata con il codice dell'applicazione + È necessario il supporto per più provider (Secrets Manager, Parameter Store, AppConfig) + Desideri trasformazioni di dati integrate (analisi JSON, decodifica base64) + Stai usando i runtime Python TypeScript, Java o.NET ## Quando usare Secrets Manager con Lambda Gli scenari più comuni per l'utilizzo di Secrets Manager con Lambda includono: + Memorizzazione delle credenziali del database utilizzate dalla funzione per connettersi ad Amazon RDS o ad altri database + Gestione delle chiavi API per i servizi esterni chiamati dalle tue funzioni + Memorizzazione delle chiavi di crittografia o di altri dati di configurazione sensibili + Rotazione automatica delle credenziali senza dover aggiornare il codice della funzione ## Utilizzo dei AWS parametri e dei segreti (estensione Lambda) L'estensione Lambda AWS Parameters and Secrets utilizza una semplice interfaccia HTTP compatibile con qualsiasi runtime Lambda. Per impostazione predefinita, memorizza nella cache i segreti per 300 secondi (5 minuti) e può contenere fino a 1.000 segreti. Puoi [personalizzare queste impostazioni con variabili di ambiente](#lambda-secrets-manager-env-vars). ### Usa Secrets Manager in una funzione Lambda Questa sezione presuppone che tu abbia già un segreto Secrets Manager. Per creare un segreto, consulta [Creare un Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) segreto. #### Creazione del pacchetto di implementazione Scegli il tuo runtime preferito e segui i passaggi per creare una funzione che recuperi segreti da Secrets Manager. La funzione di esempio recupera un segreto da Secrets Manager e può essere utilizzata per accedere alle credenziali del database, alle chiavi API o ad altri dati di configurazione sensibili nelle applicazioni. ------ #### [ Python ] **Per creare una funzione Python** 1. Crea e vai in una nuova directory di progetto. Esempio: ``` mkdir my_function cd my_function ``` 1. Crea un file denominato `lambda_function.py` con il codice seguente. Per `secret_name`, utilizza il nome o il nome della risorsa Amazon (ARN) del segreto. ``` 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. Creare un file denominato `requirements.txt` con il seguente contenuto: ``` requests ``` 1. Installare le dipendenze: ``` pip install -r requirements.txt -t . ``` 1. Crea un file .zip contenente tutti i file: ``` zip -r function.zip . ``` ------ #### [ Node.js ] **Per creare una funzione Node.js.** 1. Crea e vai in una nuova directory di progetto. Esempio: ``` mkdir my_function cd my_function ``` 1. Crea un file denominato `index.mjs` con il codice seguente. Per `secret_name`, utilizza il nome o il nome della risorsa Amazon (ARN) del segreto. ``` 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. Crea un file .zip contenente il file `index.mjs`: ``` zip -r function.zip index.mjs ``` ------ #### [ Java ] **Per creare una funzione Java** 1. Crea un progetto Maven: ``` mvn archetype:generate \ -DgroupId=example \ -DartifactId=lambda-secrets-demo \ -DarchetypeArtifactId=maven-archetype-quickstart \ -DarchetypeVersion=1.4 \ -DinteractiveMode=false ``` 1. Vai alla directory del progetto: ``` cd lambda-secrets-demo ``` 1. Apri `pom.xml` e sostituisci il contenuto con quanto riportato di seguito. ``` 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. Rinomina `/lambda-secrets-demo/src/main/java/example/App.java` in `Hello.java` in modo che corrisponda al nome del gestore Java predefinito di Lambda (`example.Hello::handleRequest`): ``` mv src/main/java/example/App.java src/main/java/example/Hello.java ``` 1. Apri il file `Hello.java` e sostituisci il contenuto con quanto riportato di seguito. Per `secretName`, utilizza il nome o il nome della risorsa Amazon (ARN) del segreto. ``` 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. Rimuovi la directory di test. Maven la crea per impostazione predefinita, ma non ne abbiamo bisogno per questo esempio. ``` rm -rf src/test ``` 1. Compila il progetto: ``` mvn package ``` 1. Scarica il file JAR (`target/function.jar`) per un uso successivo. ------ #### Creazione della funzione 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegli **Crea funzione**. 1. Scegli **Crea da zero**. 1. Nel campo **Function name (Nome funzione)**, immettere **secret-retrieval-demo**. 1. Scegli il **runtime** preferito. 1. Scegli **Crea funzione**. **Per caricare il pacchetto di implementazione** 1. Nella scheda **Codice** della funzione, scegli **Carica da** e seleziona il **file.zip** (per Python e Node.js) **o.jar (per** Java). 1. Carica il pacchetto di implementazione creato in precedenza. 1. Scegli **Save** (Salva). #### Aggiunta dell'estensione **Per aggiungere l'estensione Lambda AWS Parameters and Secrets come livello** 1. Nella scheda **Codice** della funzione, scorri verso il basso fino a **Livelli**. 1. Scegliere **Add a layer (Aggiungi un livello)**. 1. Seleziona **AWS livelli**. 1. Scegli **AWS-Parameters-and-Secrets-Lambda-Extension**. 1. Scegli la versione più recente. 1. Scegliere **Aggiungi**. #### Aggiunta di autorizzazioni **Per aggiungere i permessi di Secrets Manager al ruolo di esecuzione** 1. Quindi, seleziona la scheda **Configuration** (Configurazione) e poi **Permissions** (Autorizzazioni). 1. In **Nome del ruolo**, scegli il link al tuo ruolo di esecuzione. Questo ruolo si apre nella console IAM. ![Link al ruolo di esecuzione](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/execution-role-console.png) 1. Scegli **Aggiungi autorizzazioni**, quindi seleziona **Crea policy in linea**. ![Collegare le policy nella console IAM](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/create-inline-policy.png) 1. Scegli la scheda **JSON** e aggiungi la policy seguente. Per `Resource`, inserisci l'ARN del tuo segreto. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "secretsmanager:GetSecretValue", "Resource": "{{arn:aws:secretsmanager:us-east-1:{{111122223333}}:secret:SECRET_NAME}}" } ] } ``` ------ 1. Scegli **Next (Successivo)**. 1. Inserisci un nome per la policy. 1. Scegli **Crea policy**. #### Test della funzione **Per testare la funzione** 1. Torna alla console Lambda. 1. Seleziona la scheda **Test**. 1. Scegli **Test (Esegui test)**. Dovrebbe essere visualizzata la seguente risposta: ![Risultato di test con esito positivo](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/execution-results-secret.png) ### Variabili di ambiente L'estensione Lambda AWS Parameters and Secrets utilizza le seguenti impostazioni predefinite. Puoi sovrascrivere queste impostazioni creando le variabili [ambiente corrispondenti.](configuration-envvars.md#create-environment-variables) Per visualizzare le impostazioni correnti di una funzione, imposta `PARAMETERS_SECRETS_EXTENSION_LOG_LEVEL` su `DEBUG`. L'estensione registrerà le informazioni di configurazione in CloudWatch Logs all'inizio di ogni chiamata di funzione. | Impostazione | Valore predefinito | Valori validi | Variabile di ambiente | Informazioni | | --- | --- | --- | --- | --- | | Porta HTTP | 2773 | 1 - 65535 | PARAMETERS\_SECRETS\_EXTENSION\_HTTP\_PORT | Porta per il server HTTP locale | | Cache abilitata | TRUE | TRUE \| FALSE | PARAMETERS\_SECRETS\_EXTENSION\_CACHE\_ENABLED | Abilita o disabilita la cache | | Dimensioni della cache | 1000 | 0 - 1.000 | PARAMETERS\_SECRETS\_EXTENSION\_CACHE\_SIZE | Imposta su 0 per disabilitare la memorizzazione nella cache | | TTL di Secrets Manager. | 300 secondi | 0 - 300 secondi | SECRETS\_MANAGER\_TTL | Time-to-live per segreti memorizzati nella cache. Imposta su 0 per disabilitare la memorizzazione nella cache. Questa variabile viene ignorata se il valore per PARAMETERS\_SECRETS\_EXTENSION\_CACHE\_SIZE è 0. | | TTL Parameter Store | 300 secondi | 0 - 300 secondi | SSM\_PARAMETER\_STORE\_TTL | Time-to-live per i parametri memorizzati nella cache. Imposta su 0 per disabilitare la memorizzazione nella cache. Questa variabile viene ignorata se il valore per PARAMETERS\_SECRETS\_EXTENSION\_CACHE\_SIZE è 0. | | Livello di log | INFO | DEBUG \| INFO \| WARN \| ERROR \| NONE | PARAMETERS\_SECRETS\_EXTENSION\_LOG\_LEVEL | Il livello di dettaglio riportato nei log per l'estensione | | Connessioni max | 3 | Uguale o maggiore di 1 | PARAMETERS\_SECRETS\_EXTENSION\_MAX\_CONNECTIONS | Numero massimo di connessioni HTTP per richieste a Parameter Store o Secrets Manager | | Timeout di Secrets Manager | 0 (nessun timeout) | Tutti i numeri interi | SECRETS\_MANAGER\_TIMEOUT\_MILLIS | Timeout per le richieste a Secrets Manager (in millisecondi) | | Timeout Parameter Store | 0 (nessun timeout) | Tutti i numeri interi | SSM\_PARAMETER\_STORE\_TIMEOUT\_MILLIS | Timeout per le richieste a Parameter Store (in millisecondi). | ### Operazioni con rotazione di un segreto Se ruoti spesso i segreti, la durata predefinita di 300 secondi della cache potrebbe far sì che la funzione utilizzi segreti obsoleti. Sono disponibili due opzioni per garantire che la funzione utilizzi il valore segreto più recente: + Ridurre il TTL della cache impostando la variabile di ambiente `SECRETS_MANAGER_TTL` su un valore inferiore (in secondi). Ad esempio, impostandolo su `60` garantire che la funzione non utilizzi mai un segreto vecchio più di un minuto. + Usare le etichette temporanee `AWSCURRENT` o `AWSPREVIOUS` nella tua richiesta di segreto per assicurarti di ottenere la versione specifica che desideri: ``` secretsmanager/get?secretId=YOUR_SECRET_NAME&versionStage=AWSCURRENT ``` Scegli l'approccio che meglio bilancia le tue esigenze di prestazioni e aggiornamento. Un TTL inferiore significa chiamate più frequenti a Secrets Manager, ma garantisce l'utilizzo dei valori segreti più recenti. ## Utilizzo dell'utilità di parametrizzazione di Powertools per AWS Lambda L'utilità dei parametri di Powertools for AWS Lambda fornisce un'interfaccia unificata per il recupero di segreti da più provider, tra cui Secrets Manager, Parameter Store e. AppConfig Gestisce la memorizzazione nella cache, le trasformazioni e offre un'esperienza di sviluppo più integrata rispetto all'approccio di estensione. ### Vantaggi dell'utilità parametri + **Provider multipli**: recupera i parametri da Secrets Manager, Parameter Store e AppConfig utilizza la stessa interfaccia + **Trasformazioni integrate**: analisi JSON automatica, decodifica base64 e altre trasformazioni dei dati + **Memorizzazione nella cache integrata**: memorizzazione nella cache configurabile con supporto TTL per ridurre le chiamate API + **Sicurezza dei tipi**: forte supporto alla digitazione in altri TypeScript runtime supportati + **Gestione degli errori**: logica di ripetizione dei tentativi e gestione degli errori integrate ### Esempi di codice Negli esempi seguenti viene illustrato come recuperare i segreti utilizzando l'utilità Parametri in runtime diversi: **Python** Per esempi completi e istruzioni di configurazione, consulta la [documentazione dell'utilità Parametri](https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/). Recupero di segreti da Secrets Manager con l'utilità Powertools for AWS Lambda Parameters. ``` 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** Per esempi completi e istruzioni di configurazione, consulta la [documentazione dell'utilità Parametri](https://docs.aws.amazon.com/powertools/typescript/2.1.1/utilities/parameters/). Recupero di segreti da Secrets Manager con l'utilità Powertools for AWS Lambda Parameters. ``` 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** Per esempi completi e istruzioni di configurazione, consulta la [documentazione dell'utilità Parametri](https://docs.powertools.aws.dev/lambda/java/latest/utilities/parameters/). Recupero di segreti da Secrets Manager con l'utilità Powertools for AWS Lambda Parameters. ``` 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** Per esempi completi e istruzioni di configurazione, consulta la [documentazione dell'utilità Parametri](https://docs.aws.amazon.com/powertools/typescript/latest/features/parameters/). Recupero di segreti da Secrets Manager con l'utilità Powertools for AWS Lambda Parameters. ``` 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 } } ``` ### Configurazione e autorizzazioni Per utilizzare l'utilità Parametri, devi: 1. Installa Powertools per AWS Lambda il tuo runtime. Per informazioni dettagliate, vedi [Utensili elettrici per AWS Lambda](powertools-for-lambda.md). 1. Aggiungere le autorizzazioni IAM necessarie al ruolo di esecuzione della tua funzione. Fare riferimento a [Gestione delle autorizzazioni in AWS Lambda](lambda-permissions.md) per ulteriori dettagli. 1. Configura eventuali impostazioni opzionali tramite [variabili di ambiente](configuration-envvars.md). Le autorizzazioni IAM richieste sono le stesse dell'approccio di estensione. L'utilità gestirà automaticamente la memorizzazione nella cache e le chiamate API a Secrets Manager in base alla configurazione dell'utente.