Utilizzo delle estensioni Aurora SQL Postgre con Babelfish - Amazon Aurora

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilizzo delle estensioni Aurora SQL Postgre con Babelfish

Aurora Postgre SQL fornisce estensioni per lavorare con altri servizi. AWS Si tratta di estensioni opzionali che supportano diversi casi d'uso, ad esempio l'utilizzo di Amazon S3 con il cluster database per l'importazione o l'esportazione di dati.

  • Per importare dati da un bucket Amazon S3 al tuo cluster Babelfish DB, devi configurare l'estensione Aurora Postgre. aws_s3 SQL Questa estensione consente inoltre di esportare i dati dal cluster Aurora Postgre SQL DB in un bucket Amazon S3.

  • AWS Lambda è un servizio di elaborazione che consente di eseguire codice senza fornire o gestire server. È possibile utilizzare le funzioni Lambda per elaborare le notifiche di eventi da un'istanza database. Per ulteriori informazioni su Lambda, consulta Che cos'è AWS Lambda? nella Guida per gli sviluppatori di AWS Lambda . Per richiamare le funzioni Lambda dal tuo cluster Babelfish DB, devi configurare l'aws_lambdaestensione Aurora Postgre. SQL

Per configurare queste estensioni per il cluster Babelfish, devi prima concedere l'autorizzazione all'utente Babelfish interno per caricare le estensioni. Dopo aver concesso l'autorizzazione, puoi caricare le estensioni SQL Aurora Postgre.

Abilitazione delle SQL estensioni Aurora Postgre nel cluster DB Babelfish

Per poter caricare le estensioni aws_s3 o aws_lambda, concedere i privilegi necessari al cluster database Babelfish.

La procedura seguente utilizza lo strumento da riga di SQL comando psql Postgre per connettersi al cluster DB. Per ulteriori informazioni, consulta Usare psql per connettersi al cluster di database. È possibile utilizzare anche pgAdmin. Per informazioni dettagliate, consultare Uso di pgAdmin per connettersi al cluster di database.

Questa procedura carica aws_s3 e aws_lambda, uno dopo l'altro. Se si desidera utilizzare solo una di queste estensioni, non è necessario caricarle entrambe. L'estensione aws_commons è richiesta da ciascuno e viene caricata per impostazione predefinita come mostrato nell'output.

Per configurare il cluster Babelfish DB con i privilegi per le estensioni Aurora Postgre SQL
  1. Connettiti al cluster database Babelfish. Utilizza il nome per l'utente "master" (-U) specificato al momento della creazione del cluster database Babelfish. Il valore predefinito (postgres) viene visualizzato negli esempi.

    In Linux, macOS, oppure Unix:

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

    In Windows:

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

    Il comando risponde con un prompt per inserire la password per il nome utente (-U).

    Password:

    Inserisci la password del nome utente (-U) per il cluster database. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente.

    psql (13.4) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off) Type "help" for help. postgres=>
  2. Concedi i privilegi all'utente Babelfish interno per creare e caricare le estensioni.

    babelfish_db=> GRANT rds_superuser TO master_dbo; GRANT ROLE
  3. Crea e carica l'estensione aws_s3. L'estensione aws_commons è obbligatoria e viene installata automaticamente quando viene installato aws_s3.

    babelfish_db=> create extension aws_s3 cascade; NOTICE: installing required extension "aws_commons" CREATE EXTENSION
  4. Crea e carica l'estensione aws_lambda.

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

Utilizzo di Babelfish con Simple Storage Service (Amazon S3)

Se non hai già un bucket Simple Storage Service (Amazon S3) da utilizzare con il cluster database Babelfish, puoi creane uno. Fornisci l'accesso per qualsiasi bucket Simple Storage Service (Amazon S3) che desideri utilizzare.

Prima di provare a importare o esportare dati utilizzando un bucket Simple Storage Service (Amazon S3), completa i seguenti passaggi una tantum.

Per configurare l'accesso per la tua istanza database Babelfish al bucket Simple Storage Service (Amazon S3)
  1. Se necessario, crea un bucket Simple Storage Service (Amazon S3) per la tua istanza Babelfish. Per farlo, segui le istruzioni riportate in Create a bucket (Creazione di un bucket) nella Guida per l'utente di Amazon Simple Storage Service.

  2. Carica i file nel tuo bucket Simple Storage Service (Amazon S3). A tale scopo, attieniti alla procedura descritta in Add an object to a bucket (Aggiunta di un oggetto a un bucket) nella Guida per l'utente di Amazon Simple Storage Service.

  3. Imposta le autorizzazioni come necessario:

Ora puoi utilizzare Amazon S3 con l'estensione aws_s3 con il cluster database Babelfish.

Per importare dati da Simple Storage Service (Amazon S3) in Babelfish ed esportare dati Babelfish in Simple Storage Service (Amazon S3)
  1. Utilizzo dell'estensione aws_s3 con il cluster database Babelfish.

    Quando lo fai, assicurati di fare riferimento alle tabelle così come esistono nel contesto di SQL Postgre. Vale a dire, se vuoi importare in una tabella Babelfish denominata [database].[schema].[tableA], fai riferimento a quella tabella come database_schema_tableA nella funzione aws_s3:

  2. Assicurati di fare riferimento alle tabelle Babelfish usando la SQL denominazione Postgre quando usi l'estensione e aws_s3 Amazon S3, come mostrato nella tabella seguente.

Tabella Babelfish

Tavolo Aurora Postger SQL

database.schema.table

database_schema_table

Per ulteriori informazioni sull'uso di Amazon S3 con Aurora SQL Postgre, consulta e. Esportazione di dati da un

Usare Babelfish con AWS Lambda

Dopo aver caricato l'estensione aws_lambda nel cluster database Babelfish ma prima di richiamare le funzioni Lambda, puoi fornire l'accesso a Lambda al cluster database seguendo questa procedura.

Per configurare l'accesso per il cluster database Babelfish per il funzionamento con Lambda

Questa procedura utilizza AWS CLI per creare la IAM politica e il ruolo e associarli al cluster Babelfish DB.

  1. Crea una IAM policy che consenta l'accesso a Lambda dal tuo cluster Babelfish DB.

    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. Crea un IAM ruolo che la policy possa assumere in fase di esecuzione.

    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. Collegare la policy al ruolo.

    aws iam attach-role-policy \ --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \ --role-name rds-lambda-role --region aws-region
  4. Associa il ruolo al tuo cluster database 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

Dopo aver completato queste attività, è possibile richiamare le funzioni Lambda. Per ulteriori informazioni ed esempi di configurazione AWS Lambda per il cluster Aurora Postgre SQL DB con, vedere. AWS LambdaAWS Lambda

Per richiamare una funzione Lambda dal cluster database Babelfish

AWS Lambda supporta funzioni scritte in Java, Node.js, Python, Ruby e altri linguaggi. Se la funzione restituisce un testo quando viene richiamata, è possibile richiamarla dal cluster database Babelfish. L'esempio seguente è una funzione python segnaposto che restituisce un saluto.

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

Attualmente, Babelfish non supporta. JSON Se la tua funzione ritornaJSON, usi un wrapper per gestire il. JSON Ad esempio, diciamo che la funzione lambda_function.py mostrata in precedenza è memorizzata in Lambda come my-function.

  1. Connect al cluster Babelfish DB utilizzando il psql client (o il pgAdmin client). Per ulteriori informazioni, consulta Usare psql per connettersi al cluster di database.

  2. Crea il wrapper. Questo esempio utilizza il linguaggio procedurale di Postgres SQL per,. SQL PL/pgSQL Per saperne di più, vedi SQLPL/pg — Procedural Language. 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; $$;

    La funzione può ora essere eseguita dalla porta Babelfish (1433) o dalla TDS porta Postgre (5433). SQL

    1. Per richiamare (chiamare) questa funzione dalla porta Postgre: SQL

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

      L'output è simile a quello riportato di seguito:

      status_code | payload | executed_version | log_result -------------+-------------------------------------------------------+------------------+------------ 200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST | (1 row)
    2. Per richiamare (chiamare) questa funzione dalla TDS porta, connettiti alla porta usando il client a riga di comando SQL Serversqlcmd. Per informazioni dettagliate, consultare Utilizzo di un client SQL Server per la connessione al cluster database. Una volta connesso, esegui quanto segue:

      1> select lambda_wrapper(); 2> go

      Il comando restituisce un output simile al seguente:

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

Per ulteriori informazioni sull'utilizzo di Lambda con Aurora Postgre, consulta. SQL Invocare un AWS Lambda Per ulteriori informazioni sull'utilizzo delle funzioni Lambda, consulta Nozioni di base su Lambda nella Guida per gli sviluppatori di AWS Lambda .

Utilizzo di pg_stat_statements in Babelfish

Babelfish for Aurora SQL Postgre supporta l'estensione dalla versione 3.3.0. pg_stat_statements Per maggiori informazioni, consulta pg_stat_statements.

Per i dettagli sulla versione di questa estensione supportata da Aurora PostgreSQL, consulta Versioni di estensione.

Creazione dell'estensione pg_stat_statements

Per attivare pg_stat_statements, è necessario attivare il calcolo dell'identificatore di query. Questa operazione viene eseguita automaticamente se compute_query_id è impostato su on o auto nel gruppo di parametri. Il valore predefinito del parametro compute_query_id è auto. È inoltre necessario creare questa estensione per attivare questa funzionalità. Usa il seguente comando per installare l'estensione dall'endpoint T-: SQL

1>EXEC sp_execute_postgresql 'CREATE EXTENSION pg_stat_statements WITH SCHEMA sys';

È possibile accedere alle statistiche delle query utilizzando la seguente query:

postgres=>select * from pg_stat_statements;
Nota

Se durante l'installazione non fornisci il nome dello schema per l'estensione, per impostazione predefinita l'estensione verrà creata in uno schema pubblico. Per accedervi, è necessario scrivere il qualificatore dello schema tra parentesi quadre, come mostrato di seguito:

postgres=>select * from [public].pg_stat_statements;

Puoi anche creare l'estensione dall'PSQLendpoint.

Autorizzazione dell'estensione

Per impostazione predefinita, è possibile visualizzare le statistiche per le query eseguite all'interno del SQL database T- senza la necessità di alcuna autorizzazione.

Per accedere alle statistiche delle query create da altri, è necessario disporre del ruolo pg_read_all_stats SQL Postgre. Segui i passaggi indicati di seguito per costruire GRANT il comando pg_read_all_stats.

  1. In T-SQL, usa la seguente query che restituisce il nome del ruolo PG interno.

    SELECT rolname FROM pg_roles WHERE oid = USER_ID();
  2. Connettiti al SQL database Babelfish for Aurora Postgre con il privilegio rds_superuser e usa il seguente comando:

    GRANT pg_read_all_stats TO <rolname_from_above_query>
Esempio

Dall'SQLendpoint T-:

1>SELECT rolname FROM pg_roles WHERE oid = USER_ID(); 2>go
rolname ------- master_dbo (1 rows affected)

Dall'PSQLendpoint:

babelfish_db=# grant pg_read_all_stats to master_dbo;
GRANT ROLE

Puoi accedere alle statistiche delle query utilizzando la vista pg_stat_statements:

1>create table t1(cola int); 2>go 1>insert into t1 values (1),(2),(3); 2>go
(3 rows affected)
1>select userid, dbid, queryid, query from pg_stat_statements; 2>go
userid dbid queryid query ------ ---- ------- ----- 37503 34582 6487973085327558478 select * from t1 37503 34582 6284378402749466286 SET QUOTED_IDENTIFIER OFF 37503 34582 2864302298511657420 insert into t1 values ($1),($2),($3) 10 34582 NULL <insufficient privilege> 37503 34582 5615368793313871642 SET TEXTSIZE 4096 37503 34582 639400815330803392 create table t1(cola int) (6 rows affected)

Reimpostazione delle statistiche delle query

Puoi usare pg_stat_statements_reset() per eseguire il ripristino delle statistiche raccolte finora da pg_stat_statements. Per maggiori informazioni, consulta pg_stat_statements. Attualmente è supportato solo tramite PSQL endpoint. Connect a Babelfish for Aurora Postgre SQL con rds_superuser privilegi, usa il seguente comando:

SELECT pg_stat_statements_reset();

Limitazioni

  • Attualmente, non pg_stat_statements() è supportato tramite T-endpoint. SQL pg_stat_statementsview è il metodo consigliato per raccogliere le statistiche.

  • Alcune delle query potrebbero essere riscritte dal SQL parser T implementato dal SQL motore Aurora Postgre, la pg_stat_statements visualizzazione mostrerà la query riscritta e non la query originale.

    Esempio

    select next value for [dbo].[newCounter];

    La query precedente viene riscritta come segue nella vista pg_stat_statements.

    select nextval($1);
  • In base al flusso di esecuzione delle istruzioni, alcune query potrebbero non essere tracciate da pg_stat_statements e non essere visibili nella vista. Ciò include le seguenti istruzioni: use dbname, goto, print, raise error, set, throw, declare cursor.

  • Per le ALTER LOGIN istruzioni CREATE LOGIN e, query e queryid non verranno visualizzati. Verrà visualizzato un avviso di privilegi insufficienti.

  • La vista pg_stat_statements contiene sempre le due voci seguenti, poiché vengono eseguite internamente dal client sqlcmd.

    • SET QUOTED_IDENTIFIER OFF

    • SETTEXTSIZE4096

Usare pgvector in Babelfish

pgvector, un'estensione open source, consente di cercare dati simili direttamente all'interno del database Postgres. Babelfish ora supporta questa estensione a partire dalle versioni 15.6 e 16.2. Per ulteriori informazioni, pgvector Open source Documentation.

Prerequisiti

Per abilitare la funzionalità pgvector, installa l'estensione nello schema sys utilizzando uno dei seguenti metodi:

  • Esegui il seguente comando nel client sqlcmd:

    exec sys.sp_execute_postgresql 'CREATE EXTENSION vector WITH SCHEMA sys';
  • Connettiti babelfish_db ed esegui il seguente comando nel client psql:

    CREATE EXTENSION vector WITH SCHEMA sys;
Nota

Dopo aver installato l'estensione pgvector, il tipo di dati vettoriali sarà disponibile solo nelle nuove connessioni al database stabilite. Le connessioni esistenti non riconosceranno il nuovo tipo di dati.

Funzionalità supportate

Babelfish estende la SQL funzionalità T- per supportare quanto segue:

  • Archiviazione

    Babelfish ora supporta la sintassi compatibile con i tipi di dati vettoriali, migliorando la sua compatibilità con T. SQL Per saperne di più sulla memorizzazione dei dati con pgvector, vedi Archiviazione.

  • Interrogazione

    Babelfish espande il supporto per le SQL espressioni T per includere operatori di somiglianza vettoriale. Tuttavia, per tutte le altre interrogazioni, è ancora richiesta la sintassi T- standard. SQL

    Nota

    T- SQL non supporta il tipo Array e i driver del database non dispongono di alcuna interfaccia per gestirli. Come soluzione alternativa, Babelfish utilizza stringhe di testo (varchar/nvarchar) per memorizzare dati vettoriali. Ad esempio, quando richiedi un valore vettoriale [1,2,3], Babelfish restituirà una stringa '[1,2,3]' come risposta. Puoi analizzare e dividere questa stringa a livello di applicazione secondo le tue esigenze.

    Per ulteriori informazioni sull'interrogazione dei dati con pgvector, vedi Interrogazione.

  • Indicizzazione

    T- ora supporta la sintassi. SQL Create Index USING INDEX_METHOD È ora possibile definire l'operatore di ricerca per similarità da utilizzare su una colonna specifica durante la creazione di un indice.

    La grammatica viene inoltre estesa per supportare le operazioni di similarità vettoriale sulla colonna richiesta (Check column_name_list_with_order_for_vector grammar).

    CREATE [UNIQUE] [clustered] [COLUMNSTORE] INDEX <index_name> ON <table_name> [USING vector_index_method] (<column_name_list_with_order_for_vector>) Where column_name_list_with_order_for_vector is: <column_name> [ASC | DESC] [VECTOR_COSINE_OPS | VECTOR_IP_OPS | VECTOR_L2_OPS] (COMMA simple_column_name [ASC | DESC] [VECTOR_COSINE_OPS | VECTOR_IP_OPS | VECTOR_L2_OPS])

    Per ulteriori informazioni sull'indicizzazione dei dati con pgvector, vedi Indexing.

  • Prestazioni

    • Utilizzare per eseguire il debug dei SET BABELFISH_STATISTICS PROFILE ON piani di interrogazione dall'endpoint T. SQL

    • Aumenta max_parallel_workers_get_gather utilizzando la set_config funzione supportata in T-. SQL

    • Utilizzare IVFFlat per ricerche approssimative. Per ulteriori informazioni, consulta IVFFlat.

    Per migliorare le prestazioni con pgvector, vedi Prestazioni.

Limitazioni

  • Babelfish non supporta la ricerca a testo completo per la ricerca ibrida. Per ulteriori informazioni, consulta Hybrid Search.

  • Babelfish attualmente non supporta la funzionalità di reindicizzazione. Tuttavia, puoi comunque utilizzare l'endpoint Postgre per reindicizzare. SQL Per ulteriori informazioni, consulta Aspirazione.

Utilizzo dell'apprendimento automatico di Amazon Aurora con Babelfish

Puoi estendere le funzionalità del tuo cluster Babelfish for Aurora Postgre SQL DB integrandolo con l'apprendimento automatico di Amazon Aurora. Questa perfetta integrazione ti consente di accedere a una gamma di potenti servizi come Amazon Comprehend o Amazon AI o SageMaker Amazon Bedrock, ciascuno personalizzato per soddisfare esigenze di machine learning distinte.

Come utente Babelfish, puoi utilizzare le conoscenze esistenti della SQL sintassi e della semantica T quando lavori con l'apprendimento automatico di Aurora. Segui le istruzioni fornite nella AWS documentazione di Aurora Postgre. SQL Per ulteriori informazioni, consulta Utilizzo dell'apprendimento automatico di Amazon Aurora con Aurora Postgre SQL.

Prerequisiti

  • Prima di provare a configurare il SQL cluster Babelfish for Aurora Postgre DB per utilizzare l'apprendimento automatico di Aurora, è necessario comprendere i relativi requisiti e prerequisiti. Per ulteriori informazioni, consulta Requisiti per l'utilizzo dell'apprendimento automatico di Aurora con Aurora Postgre SQL.

  • Assicurati di installare l'aws_mlestensione utilizzando l'endpoint Postgres o la procedura store. sp_execute_postgresql

    exec sys.sp_execute_postgresql 'Create Extension aws_ml'
    Nota

    Attualmente Babelfish non supporta le operazioni a cascata in Babelfish. sp_execute_postgresql Poiché aws_ml si basa suaws_commons, dovrai installarlo separatamente utilizzando l'endpoint Postgres.

    create extension aws_common;

Gestione della SQL sintassi e della semantica T con le funzioni aws_ml

Gli esempi seguenti spiegano come la SQL sintassi e la semantica T vengono applicate ai servizi Amazon ML:

Esempio : aws_bedrock.invoke_model — Una semplice query che utilizza le funzioni di Amazon Bedrock
aws_bedrock.invoke_model( model_id varchar, content_type text, accept_type text, model_input text) Returns Varchar(MAX)

L'esempio seguente mostra come richiamare un modello Anthropic Claude 2 per Bedrock utilizzando invoke_model.

SELECT aws_bedrock.invoke_model ( 'anthropic.claude-v2', -- model_id 'application/json', -- content_type 'application/json', -- accept_type '{"prompt": "\n\nHuman: You are a helpful assistant that answers questions directly and only using the information provided in the context below. \nDescribe the answerin detail.\n\nContext: %s \n\nQuestion: %s \n\nAssistant:","max_tokens_to_sample":4096,"temperature" :0.5,"top_k":250,"top_p":0.5,"stop_sequences":[]}' -- model_input );
Esempio : aws_comprehend.detect_sentiment — Una semplice query che utilizza le funzioni Amazon Comprehend
aws_comprehend.detect_sentiment( input_text varchar, language_code varchar, max_rows_per_batch int) Returns table (sentiment varchar, confidence real)

L'esempio seguente mostra come richiamare il servizio Amazon Comprehend.

select sentiment from aws_comprehend.detect_sentiment('This is great', 'en');
Esempio : aws_sagemaker.invoke_endpoint — Una semplice query che utilizza le funzioni di Amazon SageMaker
aws_sagemaker.invoke_endpoint( endpoint_name varchar, max_rows_per_batch int, VARIADIC model_input "any") -- Babelfish inherits PG's variadic parameter type Rerurns Varchar(MAX)

Poiché model_input è contrassegnato come VARIADIC e di tipo «any», gli utenti possono passare un elenco di qualsiasi lunghezza e qualsiasi tipo di dati alla funzione che fungerà da input (input) per il modello. L'esempio seguente mostra come richiamare il SageMaker servizio Amazon.

SELECT CAST (aws_sagemaker.invoke_endpoint( 'sagemaker_model_endpoint_name', NULL, arg1, arg2 -- model inputs are separate arguments ) AS INT) -- cast the output to INT

Per informazioni più dettagliate sull'uso dell'apprendimento automatico di Aurora con Aurora Postgre, consulta. SQL Utilizzo dell'apprendimento automatico di Amazon Aurora con Aurora Postgre SQL

Limitazioni

  • Sebbene Babelfish non consenta la creazione di array, può comunque gestire i dati che rappresentano gli array. Quando si utilizzano funzioni come quelle aws_bedrock.invoke_model_get_embeddings che restituiscono gli array, i risultati vengono forniti come una stringa contenente gli elementi dell'array.