Usar extensões do Aurora PostgreSQL com o Babelfish

Para configurar seu cluster de banco de dados do Babelfish com privilégios para as extensões do Aurora PostgreSQL

1. Conecte-se ao seu cluster de banco de dados do Babelfish. Use o nome para o usuário “primário” (-U) que você especificou quando criou o cluster de banco de dados do Babelfish. O padrão (postgres) é mostrado nos exemplos.

   Para Linux, macOS ou Unix:

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

   Para Windows:

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

   O comando responde com um prompt para inserir a senha para o nome de usuário (-U).

   Password:

   Insira a senha do nome de usuário (-U) para o cluster de banco de dados. Quando a conexão é bem-sucedida, a saída é semelhante à seguinte:

   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 privilégios ao usuário interno do Babelfish para criar e carregar extensões.

   babelfish_db=> GRANT rds_superuser TO master_dbo;
   GRANT ROLE

3. Crie e carregue a extensão aws_s3. A extensão aws_commons é necessária e é instalada automaticamente quando o aws_s3está instalado.

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

4. Crie e carregue a extensão aws_lambda.

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

Para configurar o acesso da instância de banco de dados do Babelfish ao bucket do Simple Storage Service (Amazon S3)

1. Crie um bucket do Simple Storage Service (Amazon S3) para a instância do Babelfish, se necessário. Para isso, siga as instruções em Criar um bucket no Guia do usuário do Amazon Simple Storage Service.

2. Carregue arquivos no seu bucket do Simple Storage Service (Amazon S3). Para isso, siga as etapas em Adicionar um objeto a um bucket no Guia do usuário do Amazon Simple Storage Service.

3. Configure permissões conforme necessário:

   • Para importar dados do Amazon S3, o cluster de banco de dados do Babelfish precisa de permissão para acessar o bucket. Recomendamos usar uma função AWS Identity and Access Management (IAM) e anexar uma política do IAM a essa função para o cluster. Para isso, siga as etapas em Usar uma função do IAM para acessar um bucket do Amazon S3.

   • Para exportar dados de seu cluster de banco de dados do Babelfish, seu cluster deve ter acesso ao bucket do Amazon S3. Assim como na importação, recomendamos o uso de uma função e uma política do IAM. Para isso, siga as etapas em Configurar o acesso a um bucket do Amazon S3.

Para importar dados do Simple Storage Service (Amazon S3) para o Babelfish e exportar dados do Babelfish para o Simple Storage Service (Amazon S3)

1. Use a extensão aws_s3 com seu cluster de banco de dados do Babelfish.

   Ao fazer isso, certifique-se de fazer referência às tabelas conforme elas existem no contexto do PostgreSQL. Ou seja, se você quiser importar para uma tabela Babelfish chamada [database].[schema].[tableA], consulte essa tabela como database_schema_tableA na função aws_s3:

   • Para um exemplo de uso de uma função aws_s3 para importar dados, consulte Importar dados do Amazon S3 para um cluster de banco de dados do Aurora PostgreSQL.

   • Para exemplos de uso de funções aws_s3 para exportar dados, consulte Exportar dados de consulta usando a função aws_s3.query_export_to_s3.

2. Certifique-se de fazer referência a tabelas do Babelfish usando a nomeação do PostgreSQL ao usar a extensão aws_s3 e o Simple Storage Service (Amazon S3), conforme mostrado na tabela a seguir.

Para configurar o acesso para o cluster de banco de dados do Babelfish para trabalhar com o Lambda

Este procedimento usa a AWS CLI para criar a política e o perfil do IAM e associá-los ao cluster de banco de dados do Babelfish.

1. Crie uma política do IAM que permita acesso ao Lambda a partir do seu cluster de banco de dados do 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. Crie uma função do IAM que a política possa assumir em tempo de execução.

   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. Anexe a política ao perfil.

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

4. Anexar o perfil ao seu cluster de banco de dados do 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 uma função Lambda a partir do seu cluster de banco de dados do Babelfish

O AWS Lambda suporta funções escritas em Java, Node.js, Python, Ruby e outras linguagens. Se a função retornar texto quando invocada, você poderá chamá-la do cluster de banco de dados do Babelfish. O exemplo a seguir é uma função placeholder do python que retorna uma saudação.

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

Atualmente, o Babelfish não é compatível com o JSON. Se sua função retornar JSON, você usa um wrapper para lidar com o JSON. Por exemplo, digamos que a lambda_function.py mostrada antes é armazenada no Lambda como my-function.

1. Conecte-se ao seu cluster de banco de dados do Babelfish usando o cliente psql (ou o cliente pgAdmin). Para obter mais informações, consulte Utilizar o psql para se conectar ao cluster de banco de dados.

2. Crie o wrapper. Este exemplo usa a linguagem processual do PostgreSQL para SQL ,PL/pgSQL. Para saber mais, consulte Linguagem processual 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;
   $$;

   A função agora pode ser executada a partir da porta Babelfish TDS (1433) ou da porta PostgreSQL (5433).

   1. Para invocar (chamar) essa função a partir da sua porta PostgreSQL:

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

      A saída é semelhante à seguinte:

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

   2. Para invocar (chamar) essa função a partir da porta TDS, conecte-se à porta usando o cliente da linha de comando sqlcmd do SQL Server. Para obter detalhes, consulte Utilizar um cliente SQL Server para se conectar ao seu cluster de banco de dados. Quando conectado, execute o seguinte:

      1> select lambda_wrapper();
      2> go
      

      Esse comando retorna uma saída semelhante à seguinte:

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