Utilisation des SQL extensions Aurora Postgre avec Babelfish

Pour configurer votre cluster de base de données Babelfish avec des privilèges pour les extensions Aurora Postgre SQL

1. Connectez-vous à votre cluster de base de données Babelfish. Utilisez le nom de l'utilisateur « principal » (-U) que vous avez spécifié lors de la création du cluster de base de données Babelfish. La valeur par défaut (postgres) est illustrée dans les exemples.

   Dans Linux, macOS, ou Unix:

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

   Dans Windows:

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

   La commande répond par une invite à saisir le mot de passe du nom d'utilisateur (-U).

   Password:

   Saisissez le mot de passe du nom d'utilisateur (-U) du cluster de base de données. Lorsque vous serez connecté, vous obtiendrez une sortie similaire à ce qui suit.

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

2. Accordez des privilèges à l'utilisateur Babelfish interne pour créer et charger des extensions.

   babelfish_db=> GRANT rds_superuser TO master_dbo;
   GRANT ROLE

3. Créez et chargez l'extension aws_s3. L'extension aws_commons est nécessaire et elle est installée automatiquement lorsque l'extension aws_s3 est installée.

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

4. Créez et chargez l'extension aws_lambda.

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

Pour configurer l'accès de votre instance de base de données Babelfish à votre compartiment Amazon S3

1. Créez un compartiment Amazon S3 pour votre instance Babelfish, si nécessaire. Pour ce faire, suivez les instructions de la section Create a Bucket (Créer un compartiment) dans le Guide de l'utilisateur Amazon Simple Storage Service.

2. Chargez les fichiers dans votre compartiment Amazon S3. Pour ce faire, suivez les étapes de la section Add an object to a bucket (Ajouter un objet à un compartiment) dans le Guide de l'utilisateur Amazon Simple Storage Service.

3. Configurez les autorisations nécessaires :

   • Pour importer des données à partir d'Amazon S3, le cluster de base de données Babelfish doit être autorisé à accéder au compartiment. Nous vous recommandons d'utiliser un rôle AWS Identity and Access Management (IAM) et d'associer une IAM politique à ce rôle pour votre cluster. Pour ce faire, suivez les étapes de Utilisation d'un IAM rôle pour accéder à un compartiment Amazon S3.

   • Pour exporter des données à partir de votre cluster de base de données Babelfish, votre cluster doit avoir accès au compartiment Amazon S3. Comme pour l'importation, nous vous recommandons d'utiliser un IAM rôle et une politique. Pour ce faire, suivez les étapes de Configuration de l'accès à un compartiment Amazon S3.

Pour importer des données à partir d'Amazon S3 vers Babelfish et pour exporter des données Babelfish vers Amazon S3

1. Utilisez l'extension aws_s3 avec votre cluster de base de données Babelfish.

   Lorsque vous le faites, assurez-vous de référencer les tables telles qu'elles existent dans le contexte de PostgreSQL. En d'autres termes, si vous souhaitez importer vers une table Babelfish nommée [database].[schema].[tableA], référez-vous à cette table en tant que database_schema_tableA dans la fonctionaws_s3 :

   • Pour obtenir un exemple d'utilisation de fonction aws_s3 pour importer des données, veuillez consulter Importation de données depuis Amazon S3 vers votre cluster de SQL base de données Aurora Postgre RDS.

   • Pour obtenir des exemples d'utilisation de fonctions aws_s3 pour exporter des données, veuillez consulter Exportation de données de requête à l'aide de la fonction aws_s3.query_export_to_s3.

2. Assurez-vous de référencer les tables Babelfish en utilisant le nom SQL Postgre lorsque vous utilisez l'aws_s3extension et Amazon S3, comme indiqué dans le tableau suivant.

Pour configurer l'accès à votre cluster de base de données Babelfish afin qu'il fonctionne avec Lambda

Cette procédure utilise le AWS CLI pour créer la IAM politique et le rôle, et les associer au cluster de base de données Babelfish.

1. Créez une IAM politique qui autorise l'accès à Lambda depuis votre cluster de base de données 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. Créez un IAM rôle que la politique peut assumer lors de l'exécution.

   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. Attachez la stratégie au rôle.

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

4. Attacher le rôle à votre cluster de base de données 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

Pour appeler une fonction Lambda à partir de votre cluster de base de données Babelfish

AWS Lambda prend en charge les fonctions écrites en Java, Node.js, Python, Ruby et dans d'autres langages. Si la fonction renvoie du texte lorsqu'elle est appelée, vous pouvez l'appeler à partir de votre cluster de base de données Babelfish. L'exemple suivant est une fonction Python d'espace réservé qui renvoie un message de salutation.

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

Babelfish n'est actuellement pas compatible. JSON Si votre fonction revientJSON, vous utilisez un wrapper pour gérer leJSON. Par exemple, disons que la fonction lambda_function.py illustrée ci-dessus est stockée dans Lambda en tant que my-function.

1. Connectez-vous à votre cluster de base de données Babelfish à l'aide du psql client (ou du pgAdmin client). Pour de plus amples informations, veuillez consulter Utilisation de psql pour se connecter au cluster de bases de données.

2. Créez l'encapsuleur. Cet exemple utilise le langage procédural SQL de Postgre pourSQL,PL/pgSQL. Pour en savoir plus, consultez PL/Pg SQL — Langage SQL procédural.

   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 fonction peut désormais être exécutée depuis le port Babelfish (1433) ou depuis le TDS port Postgre SQL (5433).

   1. Pour invoquer (appeler) cette fonction depuis votre SQL port Postgre :

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

      La sortie est similaire à ce qui suit :

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

   2. Pour invoquer (appeler) cette fonction depuis le TDS port, connectez-vous au port à l'aide du client de ligne de sqlcmd commande SQL du serveur. Pour plus de détails, consultez Utilisation d'un client SQL Server pour se connecter au cluster de bases de données. Une fois connecté, exécutez les opérations suivantes :

      1> select lambda_wrapper();
      2> go
      

      La commande renvoie un résultat semblable à ce qui suit :

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