Verwenden von Aurora SQL Postgre-Erweiterungen mit Babelfish

So richten Sie Ihren Babelfish-DB-Cluster mit Rechten für die Aurora Postgre-Erweiterungen ein SQL

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.

   Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Linux, macOS, oder Unix:

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

   Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. 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 eine IAM Richtlinie für Ihren Cluster 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 einer 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.

   Achten Sie dabei darauf, auf die Tabellen zu verweisen, so wie sie im Kontext von Postgre SQL 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. Achten Sie darauf, Babelfish-Tabellen mithilfe der SQL Postgre-Benennung zu referenzieren, wenn Sie die aws_s3 Erweiterung und Amazon S3 verwenden, wie in der folgenden Tabelle dargestellt.

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 ermöglicht.

   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 übernehmen 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 unterstützt Babelfish nicht. JSON Wenn Ihre Funktion zurückkehrtJSON, verwenden Sie einen Wrapper, um das zu behandeln. JSON Angenommen, die vorher gezeigte lambda_function.py ist in Lambda als my-function gespeichert.

1. Stellen Sie über den psql Client (oder den Client) eine Verbindung zu Ihrem Babelfish-DB-Cluster her. pgAdmin Weitere Informationen finden Sie unter Herstellen einer Verbindung mit Ihrem psql.

2. Erstellen Sie den Wrapper. In diesem Beispiel wird die prozedurale Sprache SQL von Postgre für, verwendet. SQL PL/pgSQL Weitere Informationen finden Sie unter PL/PG SQL — SQL Prozedurale Sprache.

   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 TDS Babelfish-Port (1433) oder vom SQL Postgre-Port (5433) aus ausgeführt werden.

   1. Um diese Funktion von Ihrem Postgre-Port aus aufzurufen (aufzurufen): SQL

      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 (aufzurufen), stellen Sie mit dem SQL sqlcmd Server-Befehlszeilenclient eine Verbindung zum Port 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!\""}