Utilizzo delle estensioni Aurora PostgreSQL con Babelfish

Per configurare il cluster database Babelfish con privilegi per le estensioni Aurora PostgreSQL

1. Connettiti al cluster database Babelfish. Utilizza il nome per l'utente "master" (-U) specificato al momento della creazione del cluster database Babelfish. Il valore predefinito (postgres) viene visualizzato negli esempi.

   PerLinux, omacOS: Unix

   psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com \
   -U postgres \
   -d babelfish_db \
   -p 5432

   Per Windows:

   psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com ^
   -U postgres ^
   -d babelfish_db ^
   -p 5432

   Il comando risponde con un prompt per inserire la password per il nome utente (-U).

   Password:

   Inserisci la password del nome utente (-U) per il cluster database. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente.

   psql (13.4)
   SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
   Type "help" for help.
   
   postgres=>

2. Concedi i privilegi all'utente Babelfish interno per creare e caricare le estensioni.

   babelfish_db=> GRANT rds_superuser TO master_dbo;
   GRANT ROLE

3. Crea e carica l'estensione aws_s3. L'estensione aws_commons è obbligatoria e viene installata automaticamente quando viene installato aws_s3.

   babelfish_db=> create extension aws_s3 cascade;
   NOTICE:  installing required extension "aws_commons"
   CREATE EXTENSION

4. Crea e carica l'estensione aws_lambda.

   babelfish_db=> create extension aws_lambda cascade;
   CREATE EXTENSION
   babelfish_db=>

Per configurare l'accesso per la tua istanza database Babelfish al bucket Simple Storage Service (Amazon S3)

1. Se necessario, crea un bucket Simple Storage Service (Amazon S3) per la tua istanza Babelfish. Per farlo, segui le istruzioni riportate in Create a bucket (Creazione di un bucket) nella Guida per l'utente di Amazon Simple Storage Service.

2. Carica i file nel tuo bucket Simple Storage Service (Amazon S3). A tale scopo, attieniti alla procedura descritta in Add an object to a bucket (Aggiunta di un oggetto a un bucket) nella Guida per l'utente di Amazon Simple Storage Service.

3. Imposta le autorizzazioni come necessario:

   • Per importare dati da Amazon S3, il cluster database Babelfish richiede l'autorizzazione per accedere al bucket. Ti consigliamo di utilizzare un ruolo AWS Identity and Access Management (IAM) e di associare una policy IAM a quel ruolo per il tuo cluster. A tale scopo, segui la procedura in Utilizzo di un IAM ruolo per accedere a un bucket Amazon S3.

   • Per esportare i dati dal cluster database Babelfish, è necessario concedere al cluster l'accesso al bucket Amazon S3. Come per l'importazione, si consiglia di utilizzare un ruolo e una policy IAM. A tale scopo, segui la procedura in Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3).

Per importare dati da Simple Storage Service (Amazon S3) in Babelfish ed esportare dati Babelfish in Simple Storage Service (Amazon S3)

1. Utilizzo dell'estensione aws_s3 con il cluster database Babelfish.

   In questa situazione, assicurati di fare riferimento alle tabelle così come sono presenti nel contesto di PostgreSQL. Vale a dire, se vuoi importare in una tabella Babelfish denominata [database].[schema].[tableA], fai riferimento a quella tabella come database_schema_tableA nella funzione aws_s3:

   • Per un esempio di utilizzo di una funzione aws_s3 per importare dati, vedi .

   • Per esempi di utilizzo di funzioni aws_s3 per esportare dati, vedi Esportazione dei dati della query utilizzando la funzione aws_s3.query_export_to_s3.

2. Assicurati di fare riferimento alle tabelle Babelfish usando la denominazione PostgreSQL quando utilizzi l'estensione aws_s3 e Simple Storage Service (Amazon S3), come illustrato nella tabella seguente.

Per configurare l'accesso per il cluster database Babelfish per il funzionamento con Lambda

Questa procedura utilizza AWS CLI per creare la politica e il ruolo IAM e associarli al cluster Babelfish DB.

1. Crea una policy IAM che consente l'accesso a Lambda dal cluster database Babelfish.

   aws iam create-policy  --policy-name rds-lambda-policy --policy-document '{
       "Version": "2012-10-17",
       "Statement": [
           {
           "Sid": "AllowAccessToExampleFunction",
           "Effect": "Allow",
           "Action": "lambda:InvokeFunction",
           "Resource": "arn:aws:lambda:aws-region:444455556666:function:my-function"
           }
       ]
   }'

2. Crea un ruolo IAM che la policy può assumere in fase di esecuzione.

   aws iam create-role  --role-name rds-lambda-role --assume-role-policy-document '{
       "Version": "2012-10-17",
       "Statement": [
           {
           "Effect": "Allow",
           "Principal": {
               "Service": "rds.amazonaws.com"
           },
           "Action": "sts:AssumeRole"
           }
       ]
   }'

3. Collegare la policy al ruolo.

   aws iam attach-role-policy \
       --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \
       --role-name rds-lambda-role --region aws-region
   

4. Associa il ruolo al tuo cluster database Babelfish

   aws rds add-role-to-db-cluster \
          --db-cluster-identifier my-cluster-name \
          --feature-name Lambda \
          --role-arn  arn:aws:iam::444455556666:role/rds-lambda-role   \
          --region aws-region

Per richiamare una funzione Lambda dal cluster database Babelfish

AWS Lambda supporta funzioni scritte in Java, Node.js, Python, Ruby e altri linguaggi. Se la funzione restituisce un testo quando viene richiamata, è possibile richiamarla dal cluster database Babelfish. L'esempio seguente è una funzione python segnaposto che restituisce un saluto.

lambda_function.py
import json
def lambda_handler(event, context):
    #TODO implement
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')

Attualmente, Babelfish non supporta JSON. Se la funzione restituisce JSON, si utilizza un wrapper per gestire il JSON. Ad esempio, diciamo che la funzione lambda_function.py mostrata in precedenza è memorizzata in Lambda come my-function.

1. Collegati al cluster database Babelfish utilizzando il client psql (o il client pgAdmin). Per ulteriori informazioni, consulta Usare psql per connettersi al cluster di database.

2. Crea il wrapper. Questo esempio utilizza il linguaggio procedurale di PostgreSQL per SQL, PL/pgSQL. Per ulteriori informazioni, consulta PL/pgSQL–SQL Procedural Language (PL/pgSQL - Linguaggio procedurale SQL).

   create or replace function master_dbo.lambda_wrapper()
   returns text
   language plpgsql
   as
   $$
   declare
      r_status_code integer;
      r_payload text;
   begin
      SELECT payload INTO r_payload
        FROM aws_lambda.invoke(  aws_commons.create_lambda_function_arn('my-function', 'us-east-1')
                               ,'{"body": "Hello from Postgres!"}'::json );
      return r_payload ;
   end;
   $$;

   La funzione ora può essere eseguita dalla porta TDS Babelfish (1433) o dalla porta PostgreSQL (5433).

   1. Per richiamare (chiamare) questa funzione dalla porta PostgreSQL:

      SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'us-east-1'), '{"body": "Hello from Postgres!"}'::json );
      
      

      L'output è simile a quello riportato di seguito:

      status_code |                        payload                        | executed_version | log_result
      -------------+-------------------------------------------------------+------------------+------------
               200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST          |
      (1 row)
      

   2. Per richiamare (chiamare) questa funzione dalla porta TDS, connettiti alla porta utilizzando il client della riga di comando sqlcmd di SQL Server. Per informazioni dettagliate, vedi Utilizzo di un client SQL Server per la connessione al cluster database. Una volta connesso, esegui quanto segue:

      1> select lambda_wrapper();
      2> go
      

      Il comando restituisce un output simile al seguente:

      {"statusCode": 200, "body": "\"Hello from Lambda!\""}