Utilizzo delle estensioni Aurora SQL Postgre con Babelfish

Per configurare il cluster Babelfish DB con i privilegi per le estensioni Aurora Postgre SQL

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.

   In Linux, macOS, oppure Unix:

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

   In 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 IAM policy 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, consigliamo di utilizzare un IAM ruolo e una politica. 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.

   Quando lo fai, assicurati di fare riferimento alle tabelle così come esistono nel contesto di SQL Postgre. 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 SQL denominazione Postgre quando usi l'estensione e aws_s3 Amazon S3, come mostrato 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 IAM politica e il ruolo e associarli al cluster Babelfish DB.

1. Crea una IAM policy che consenta l'accesso a Lambda dal tuo cluster Babelfish DB.

   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 IAM ruolo che la policy possa 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 tua funzione ritornaJSON, usi 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. Connect al cluster Babelfish DB utilizzando il psql client (o il pgAdmin client). Per ulteriori informazioni, consulta Usare psql per connettersi al cluster di database.

2. Crea il wrapper. Questo esempio utilizza il linguaggio procedurale di Postgres SQL per,. SQL PL/pgSQL Per saperne di più, vedi SQLPL/pg — Procedural Language. 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 può ora essere eseguita dalla porta Babelfish (1433) o dalla TDS porta Postgre (5433). SQL

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

      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 TDS porta, connettiti alla porta usando il client a riga di comando SQL Serversqlcmd. Per informazioni dettagliate, consultare 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!\""}