Habilitar extensões do Aurora PostgreSQL em seu cluster de banco de dados do Babelfish Usar o Babelfish com o Simple Storage Service (Amazon S3)Usar o Babelfish com o AWS Lambda

Usar extensões do Aurora PostgreSQL com o Babelfish

O Aurora PostgreSQL fornece extensões para trabalhar com outros serviços da AWS. Essas são extensões opcionais que oferecem suporte a vários casos de uso, como usar o Simple Storage Service (Amazon S3) com seu cluster de banco de dados para importar ou exportar dados.

Para importar dados de um bucket do Amazon S3 para seu cluster de banco de dados do Babelfish, configure a extensão aws_s3 do Aurora PostgreSQL. Essa extensão também permite exportar dados do seu cluster de bancos de dados Aurora PostgreSQL para um bucket do Simple Storage Service (Amazon S3).
O AWS Lambda é um serviço de computação que permite executar código sem o provisionamento ou gerenciamento de servidores. Por exemplo, você pode usar funções Lambda para realizar certas ações, como processar notificações de eventos de uma instância de banco de dados. Para saber mais sobre o Lambda, consulte O que é o AWS Lambda? no Guia do desenvolvedor do AWS Lambda. Para invocar funções do Lambda a partir do cluster de banco de dados do Babelfish, configure a extensão aws_lambda do Aurora PostgreSQL.

Para configurar essas extensões para o cluster do Babelfish, primeiro você precisa conceder permissão ao usuário interno do Babelfish para carregar as extensões. Depois de conceder permissão, você pode carregar extensões do Aurora PostgreSQL.

Habilitar extensões do Aurora PostgreSQL em seu cluster de banco de dados do Babelfish

Antes que você possa carregar o aws_s3 ou as extensões do aws_lambda, você concede os privilégios necessários ao cluster de banco de dados do Babelfish.

O procedimento a seguir usa a ferramenta da linha de comando psql do PostgreSQL para se conectar ao cluster de banco de dados. Para obter mais informações, consulte Utilizar o psql para se conectar ao cluster de banco de dados. Você também pode usar o pgAdmin. Para obter mais detalhes, consulte Utilizar o pgAdmin para se conectar ao cluster de banco de dados.

Este procedimento carrega ambos aws_s3 e aws_lambda, um após o outro. Você não precisa carregar os dois se quiser usar apenas uma dessas extensões. A extensão aws_commons é necessária para cada um, e é carregada por padrão, conforme mostrado na saída.

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

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=>
```
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
```
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
```

Crie e carregue a extensão aws_lambda.


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

Usar o Babelfish com o Simple Storage Service (Amazon S3)

Se ainda não tiver um bucket do Simple Storage Service (Amazon S3) para usar com o cluster de banco de dados do Babelfish, crie um. Para qualquer bucket do Simple Storage Service (Amazon S3) que você deseja usar, você fornece acesso.

Antes de tentar importar ou exportar dados usando um bucket do Simple Storage Service (Amazon S3), conclua as etapas únicas a seguir.

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

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.
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.
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.

Agora você pode usar o Amazon S3 com a extensão aws_s3 com seu cluster de banco de dados do Babelfish.

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

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.
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.

Mesa Babelfish	Mesa Aurora PostgreSQL
`database.schema.table`	`database_schema_table`

Para saber mais sobre como usar o Simple Storage Service (Amazon S3) com o Aurora PostgreSQL, consulte Importar dados do Amazon S3 para um cluster de banco de dados do Aurora PostgreSQL e Exportar dados de um cluster de banco de dados do Aurora PostgreSQL para o Amazon S3.

Usar o Babelfish com o AWS Lambda

Depois que a extensão aws_lambda é carregada em seu cluster de banco de dados do Babelfish, mas antes que você possa chamar funções Lambda, você dá acesso ao Lambda ao cluster de banco de dados seguindo este procedimento.

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.

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"
        }
    ]
}'

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"
        }
    ]
}'

Anexe a política à função.


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

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

Depois de concluir essas tarefas, você pode invocar suas funções Lambda. Para obter mais informações e exemplos de configuração do AWS Lambda para o cluster de bancos de dados Aurora PostgreSQL com o AWS Lambda, consulte Etapa 2: configurar o IAM para o cluster de bancos de dados Aurora PostgreSQL e AWS Lambda.

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.

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.

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).

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)

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 mais 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!\""}
```

Para saber mais sobre como usar o Lambda com o Aurora PostgreSQL, consulte Invocar uma função do AWS Lambda de um cluster de bancos de dados Aurora PostgreSQL. Para obter mais informações sobre como usar funções Lambda, consulte Conceitos básicos do Lambda no Guia do desenvolvedor do AWS Lambda.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar o plano de explicação para melhorar a performance das consultas

Usar dicas de consulta T-SQL para melhorar a performance de consultas do Babelfish