Come faccio a creare una funzione AWS Lambda che esegue le query in Amazon Redshift?

Risoluzione

Prerequisiti

Prima di creare una funzione Lambda, devi configurare i seguenti endpoint Amazon Virtual Private Cloud (Amazon VPC):

1. Crea un VPC con una sottorete privata.

2. Crea un gruppo di sottoreti. Aggiungi il VPC e la sottorete che hai appena creato.

3. Crea un cluster Amazon Redshift privato. Seleziona il VPC e il gruppo di sottorete che hai appena creato.

4. Crea un nuovo segreto per Amazon Redshift con AWS Secrets Manager. Dai un nome al tuo redshift segreto.

Scegli la tua funzione Lambda

Per creare una funzione Lambda che interroga il tuo cluster Amazon Redshift, segui questi passaggi:

1. Apri la console Lambda.

2. Scegli Crea funzione.

3. Scegli l'opzione Crea da zero.

4. Aggiorna i seguenti campi:
   Nome della funzione: Inserisci un nome personalizzato.
   Durata: Inserisci il tuo ambiente di codice. (Gli esempi in questa risoluzione sono compatibili con Python 3.9.)
   Architettura: Inserisci l'architettura del tuo sistema. (Gli esempi in questa risoluzione sono compatibili con x86_64.)
   Autorizzazioni: Scegli Crea un nuovo ruolo con autorizzazioni Lambda di base.

5. Scegli Crea funzione.

Imposta le autorizzazioni corrette per la tua funzione Lambda

1. Nella console Lambda, scegli Configurazione.

2.    Scegli Autorizzazioni.

3. Scegli il ruolo creato per la tua funzione Lambda.

4. Scegli Aggiungi autorizzazioni.

5. Scegli Attach Policies (Associa policy).

6. Aggiungi le policy AmazonRedShiftDataFullAccess e SecretsManagerReadWrite al tuo ruolo di esecuzione Lambda.

Nota: è consigliabile concedere il privilegio minimo solo per le autorizzazioni necessarie per eseguire un'attività. Per ulteriori informazioni, consulta Applicare le autorizzazioni con privilegi minimi.

Aggiungi codice Python alla tua funzione Lambda

1. Nella console Lambda, scegli Codice.

2. Incolla il seguente codice nella casella Codice:

Importante:

• sostituisci "dev" con il nome del tuo database.
• Aggiungi una variabile di ambiente nella sezione di configurazione della funzione Lambda per la chiave SecretId e secret_name.

import os
import json
import boto3
import botocore
import botocore.session as bc
from botocore.client import Config

print('Loading function')

secret_name=os.environ['SecretId'] # getting SecretId from Environment varibales
session = boto3.session.Session()
region = session.region_name

# Initializing Secret Manager's client    
client = session.client(
    service_name='secretsmanager',
        region_name=region
    )

get_secret_value_response = client.get_secret_value(
        SecretId=secret_name
    )
secret_arn=get_secret_value_response['ARN']

secret = get_secret_value_response['SecretString']

secret_json = json.loads(secret)

cluster_id=secret_json['dbClusterIdentifier']

# Initializing Botocore client
bc_session = bc.get_session()

session = boto3.Session(
        botocore_session=bc_session,
        region_name=region
    )

# Initializing Redshift's client   
config = Config(connect_timeout=5, read_timeout=5)
client_redshift = session.client("redshift-data", config = config)

def lambda_handler(event, context):
    print("Entered lambda_handler")

    query_str = "create table public.lambda_func (id int);"
    try:
        result = client_redshift.execute_statement(Database= 'dev', SecretArn= secret_arn, Sql= query_str, ClusterIdentifier= cluster_id)
        print("API successfully executed")

    except botocore.exceptions.ConnectionError as e:
        client_redshift_1 = session.client("redshift-data", config = config)
        result = client_redshift_1.execute_statement(Database= 'dev', SecretArn= secret_arn, Sql= query_str, ClusterIdentifier= cluster_id)
        print("API executed after reestablishing the connection")
        return str(result)

    except Exception as e:
        raise Exception(e)

    return str(result)

In questo esempio, Lambda si connette al database Amazon Redshift e crea una tabella lambda_func nello schema pubblico.