Uso de las extensiones Aurora PostgreSQL con Babelfish

Para configurar el clúster de la base de datos de Babelfish con privilegios para las extensiones de Aurora PostgreSQL

1. Conéctese al clúster de base de datos de Babelfish. Use el nombre para el usuario “maestro” (-U) que especificó cuando creó el clúster de bases de datos de Babelfish. El valor predeterminado (postgres) se muestra en los ejemplos.

   Para Linux, macOS o Unix:

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

   En Windows:

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

   El comando responde con una solicitud para ingresar la contraseña del nombre de usuario (-U).

   Password:

   Ingrese la contraseña del nombre de usuario (-U) para el clúster de bases de datos. Cuando se conecte correctamente, verá una respuesta similar a la siguiente.

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

2. Conceda privilegios al usuario interno de Babelfish para crear y cargar extensiones.

   babelfish_db=> GRANT rds_superuser TO master_dbo;
   GRANT ROLE

3. Cree y cargue la extensión aws_s3. La extensión aws_commons es necesaria y se instala de forma automática cuando se instala el aws_s3.

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

4. Cree y cargue la extensión aws_lambda.

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

Para configurar el acceso de la instancia de base de datos de Babelfish al bucket de Simple Storage Service (Amazon S3)

1. Cree un bucket de Simple Storage Service (Amazon S3) para la instancia de Babelfish, si es necesario. Para ello, siga las instrucciones de Crear un bucket en la Guía del usuario de Amazon Simple Storage Service.

2. Cargue los archivos en el bucket de Simple Storage Service (Amazon S3). Para ello, siga los pasos de Add an object to a bucket (Agregar un objeto a un bucket) en la Guía del usuario de Amazon Simple Storage Service.

3. Configure los permisos necesarios:

   • Para importar datos de Amazon S3, el clúster de base de datos de Babelfish necesita permiso para acceder al bucket. Se recomienda usar un rol de AWS Identity and Access Management (IAM) y adjuntar una política de IAM a ese rol para el clúster. Para ello, siga los pasos que se indican en Uso de un rol de IAM para obtener acceso a un bucket de Amazon S3.

   • Para exportar datos del clúster de base de datos de Babelfish, el clúster debe tener acceso al bucket de Amazon S3. Al igual que con la importación, se recomienda usar un rol y una política de IAM. Para ello, siga los pasos que se indican en Configuración del acceso a un bucket de Amazon S3.

Para importar datos de Simple Storage Service (Amazon S3) a Babelfish y para exportar datos de Babelfish a Amazon S3

1. Use la extensión aws_s3 con el clúster de bases de datos de Babelfish.

   Cuando lo haga, asegúrese de hacer referencia a las tablas, tal y como existen en el contexto de PostgreSQL. Es decir, si quiere importar a una tabla de Babelfish llamada [database].[schema].[tableA], haga referencia a esa tabla como database_schema_tableA en la función aws_s3:

   • Para ver un ejemplo del uso de una función aws_s3 para importar datos, consulte Importación de datos de Amazon S3 a un clúster de base de datos Aurora PostgreSQL.

   • Para ver ejemplos del uso de las funciones de aws_s3 para exportar datos, consulte Exportación de datos de consulta mediante la función aws_s3.query_export_to_s3.

2. Asegúrese de hacer referencia a las tablas de Babelfish mediante la nomenclatura de PostgreSQL cuando utilice la extensión aws_s3 y Simple Storage Service (Amazon S3), como se muestra en la siguiente tabla.

Para configurar el acceso al clúster de la base de datos de Babelfish para trabajar con Lambda

Este procedimiento usa la AWS CLI para crear el rol y la política de IAM, así como para asociarlos al clúster de base de datos de Babelfish.

1. Cree una política de IAM que permita el acceso a Lambda desde el clúster de bases de datos de 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. Cree un rol de IAM que la política pueda asumir en tiempo de ejecución.

   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. Asocie la política de al rol.

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

4. Adjunte el rol al clúster de base de datos de 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

Para invocar una función Lambda desde el clúster de bases de datos de Babelfish

AWS Lambda admite funciones escritas en Java, Node.js, Python, Ruby y otros lenguajes. Si la función devuelve texto cuando se invoca, puede invocarla desde el clúster de bases de datos de Babelfish. El siguiente ejemplo es una función Python de marcador de posición que muestra un saludo.

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

Actualmente, Babelfish no es compatible con JSON. Si la función devuelve JSON, debe usar una capa para gestionar el resultado JSON. Por ejemplo, digamos que lambda_function.py, como hemos mostrado anteriormente, se almacena en Lambda como my-function.

1. Conéctese al clúster de bases de datos de Babelfish con el cliente psql (o el cliente pgAdmin). Para obtener más información, consulte Conexión al clúster de bases de datos mediante psql.

2. Cree la capa. En este ejemplo se usa el lenguaje procedimental de PostgreSQL para SQL, PL/pgSQL. Para obtener más información, consulte PL/pgSQL–SQL Procedural Language (Lenguaje procedimental PL/pgSQL-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 función ahora se puede ejecutar desde el puerto TDS de Babelfish (1433) o desde el puerto de PostgreSQL (5433).

   1. Para invocar (llamar) esta función desde el puerto de PostgreSQL:

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

      El resultado es similar al siguiente:

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

   2. Para invocar (llamar) esta función desde el puerto TDS, conéctese al puerto con el cliente de línea de comandos sqlcmd de SQL Server. Para obtener más información, consulte Uso de un cliente de SQL Server para conectarse al clúster de su base de datos. Cuando se haya conectado, ejecute lo siguiente:

      1> select lambda_wrapper();
      2> go
      

      El comando devuelve un resultado similar al siguiente:

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