Verwenden von Aurora PostgreSQL-Erweiterungen mit Babelfish

Richten Sie Babelfish-DB-Cluster mit Berechtigungen für die Aurora-PostgreSQL-Erweiterungen ein

1. Stellen Sie eine Verbindung mit Ihrem Babelfish-DB-Cluster her. Verwenden Sie den Namen für den „Hauptbenutzer“ (-U), den Sie beim Erstellen des Babelfish-DB-Clusters angegeben haben. In den Beispielen wird der Standard (postgres) dargestellt.

   Für LinuxmacOS, oderUnix:

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

   Windows:

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

   Der Befehl antwortet mit einer Aufforderung zur Eingabe des Passworts für den Benutzernamen (-U).

   Password:

   Geben Sie das Passwort für den Benutzernamen (-U) für den DB-Cluster ein. Wenn die Verbindung erfolgreich ist, wird eine Ausgabe ähnlich der Folgenden angezeigt.

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

2. Erteilen Sie dem internen Babelfish-Benutzer Berechtigungen zum Erstellen und Laden von Erweiterungen.

   babelfish_db=> GRANT rds_superuser TO master_dbo;
   GRANT ROLE

3. Erstellen und laden Sie die aws_s3-Erweiterung. Die aws_commons-Erweiterung ist erforderlich und wird automatisch mit aws_s3 installiert.

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

4. Erstellen und laden Sie die aws_lambda-Erweiterung.

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

Gewähren Sie Ihrer Babelfish-DB-Instance Zugriff auf Ihren Amazon-S3-Bucket

1. Erstellen Sie bei Bedarf einen Amazon-S3-Bucket für Ihre Babelfish-Instance. Befolgen Sie dazu die Anweisungen unter Erstellen eines Buckets im Benutzerhandbuch zum Amazon Simple Storage Service.

2. Laden Sie Dateien in Ihren Amazon-S3-Bucket hoch. Befolgen Sie dazu die Schritte unter Hinzufügen eines Objekts zu einem Bucket im Benutzerhandbuch zum Amazon Simple Storage Service.

3. Richten Sie Berechtigungen nach Bedarf ein:

   • Zum Importieren von Daten aus Amazon S3 benötigt der Babelfish-DB-Cluster die Berechtigung für den Zugriff auf den Bucket. Wir empfehlen, eine AWS Identity and Access Management (IAM-) Rolle zu verwenden und dieser Rolle für Ihren Cluster eine IAM-Richtlinie zuzuordnen. Eine Schritt-für-Schritt-Anleitung hierzu finden Sie unter Verwenden einer IAM Rolle für den Zugriff auf einen Amazon S3 S3-Bucket.

   • Wenn Sie Daten aus Ihrem Babelfish-DB-Cluster exportieren möchten, muss Ihrem Cluster Zugriff auf den Amazon S3 Bucket gewährt werden. Wie beim Importieren empfehlen wir die Verwendung einer IAM-Rolle und -Richtlinie. Eine Schritt-für-Schritt-Anleitung hierzu finden Sie unter Einrichten des Zugriffs auf einen Amazon S3-Bucket.

Importieren von Daten aus Amazon S3 nach Babelfish und exportieren von Babelfish-Daten nach Amazon S3

1. Verwenden Sie die aws_s3-Erweiterung mit Ihrem Babellfish-DB-Cluster.

   Verweisen Sie in diesem Fall auf die Tabellen, wie sie in PostgreSQL existieren. Das heißt, beim Import in eine Babelfish-Tabelle namens [database].[schema].[tableA] bezeichnen Sie diese Tabelle in der aws_s3-Funktion als database_schema_tableA:

   • Ein Beispiel für die Verwendung einer aws_s3-Funktion zum Importieren von Daten finden Sie unter Daten von Amazon S3 in Ihren Aurora SQL Postgre-DB-Cluster importieren.

   • Beispiele für die Verwendung von aws_s3-Funktionen zum Exportieren von Daten finden Sie unter Exportieren von Abfragedaten mithilfe der Funktion aws_s3.query_export_to_s3.

2. Verweisen Sie mit der PostgreSQL-Benennung auf Babelfish-Tabellen, wenn Sie die aws_s3-Erweiterung und Amazon S3 wie in folgender Tabelle verwenden.

Richten Sie den Zugriff für Ihren Babelfish-DB-Cluster zur Funktion mit Lambda ein

Dieses Verfahren verwendet die AWS CLI , um die IAM-Richtlinie und -Rolle zu erstellen und diese dem Babelfish-DB-Cluster zuzuordnen.

1. Erstellen Sie eine IAM-Richtlinie, die den Zugriff auf Lambda von Ihrem Babelfish-DB-Cluster aus erlaubt.

   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. Erstellen Sie eine IAM-Rolle, die die Richtlinie zur Laufzeit annehmen kann.

   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. Fügen Sie der Rolle die -Richtlinie an.

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

4. Hängen Sie die Rolle an Ihren Babelfish-DB-Cluster an.

   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

Aufrufen einer Lambda-Funktion aus Ihrem Babelfish-DB-Cluster

AWS Lambda unterstützt Funktionen, die in Java, Node.js, Python, Ruby und anderen Sprachen geschrieben wurden. Wenn die Funktion beim Aufruf Text zurückgibt, können Sie sie von Ihrem Babelfish-DB-Cluster aus aufrufen. Das folgende Beispiel ist eine Platzhalter-Python-Funktion, die eine Begrüßung zurückgibt.

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

Derzeit wird JSON von Babelfish nicht unterstützt. Wenn Ihre Funktion JSON zurückgibt, verwenden Sie einen Wrapper, um den JSON-Code zu behandeln. Angenommen, die vorher gezeigte lambda_function.py ist in Lambda als my-function gespeichert.

1. Stellen Sie mit Hilfe des psql-Clients (oder des pgAdmin-Clients) eine Verbindung zu Ihrem Babelfish-DB-Cluster her. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit Ihrem psql.

2. Erstellen Sie den Wrapper. In diesem Beispiel wird die prozedurale Sprache von PostgreSQL für SQL verwendet, PL/pgSQL. Weitere Informationen hierzu finden Sie unter PL/pgSQL-SQL Procedural Language.

   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;
   $$;

   Die Funktion kann jetzt vom Babelfish-TDS-Port (1433) oder vom PostgreSQL-Port (5433) aus ausgeführt werden.

   1. So rufen Sie diese Funktion von Ihrem PostgreSQL-Port aus auf:

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

      Die Ausgabe sieht folgendermaßen oder ähnlich aus:

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

   2. Um diese Funktion vom TDS-Port aus aufzurufen, stellen Sie eine Verbindung mit dem Port über den sqlcmd-Befehlszeilen-Client von SQL Server her. Details hierzu finden Sie unter Verbinden mit Ihrem DB-Cluster mithilfe eines SQL Server-Clients. Wenn eine Verbindung hergestellt ist, führen Sie Folgendes aus:

      1> select lambda_wrapper();
      2> go
      

      Daraufhin erhalten Sie ein Ergebnis, das dem hier dargestellten entspricht:

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