Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Utilisation des extensions Aurora PostgreSQL avec Babelfish Aurora PostgreSQL fournit des extensions permettant de travailler avec d'autres services. AWS Il s’agit d’extensions facultatives qui prennent en charge divers cas d’utilisation, tels que l’utilisation d’Amazon S3 avec votre cluster de bases de données pour importer ou exporter des données. + Pour importer des données d’un compartiment Amazon S3 vers votre cluster de bases de données Babelfish, vous devez configurer l’extension `aws_s3` Aurora PostgreSQL. Cette extension vous permet également d’exporter des données de votre cluster de bases de données Aurora PostgreSQL vers un compartiment Amazon S3. + AWS Lambda est un service de calcul qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Vous pouvez par exemple utiliser des fonctions Lambda pour traiter les notifications d’événements à partir de votre instance de base de données. Pour en savoir plus sur Lambda, consultez [Qu’est-ce qu’ AWS  Lambda ?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) dans le *Guide du développeur AWS Lambda *. Pour appeler des fonctions Lambda à partir de votre cluster de bases de données Babelfish, vous devez configurer l’extension `aws_lambda` Aurora PostgreSQL. Pour configurer ces extensions pour votre cluster Babelfish, vous devez d’abord accorder à l’utilisateur Babelfish interne l’autorisation de charger les extensions. Après avoir accordé l’autorisation, vous pouvez charger les extensions Aurora PostgreSQL. ## Activation des extensions Aurora PostgreSQL dans votre cluster de bases de données Babelfish Avant de pouvoir charger les extensions `aws_s3` ou `aws_lambda`, vous accordez les privilèges nécessaires à votre cluster de bases de données Babelfish. La procédure suivante utilise l’outil de ligne de commande `psql` PostgreSQL pour se connecter au cluster de bases de données. Pour plus d’informations, consultez [Utilisation de psql pour se connecter au cluster de bases de données](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). Vous pouvez également utiliser pgAdmin. Pour en savoir plus, consultez [Utilisation de pgAdmin pour se connecter au cluster de bases de données](babelfish-connect-PostgreSQL.md#babelfish-connect-pgadmin). Cette procédure charge les extensions `aws_s3` et `aws_lambda` l’une après l’autre. Si vous ne comptez utiliser que l’une de ces extensions, vous n’avez pas besoin de les charger toutes les deux. L’extension `aws_commons` est requise par chacune, et elle est chargée par défaut, comme indiqué dans la sortie. **Pour configurer votre cluster de bases de données Babelfish avec des privilèges pour les extensions Aurora PostgreSQL** 1. Connectez-vous à votre cluster de bases 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 bases de données Babelfish. La valeur par défaut (`postgres`) est illustrée dans les exemples. Pour Linux, macOS ou Unix : ``` psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com \ -U postgres \ -d babelfish_db \ -p 5432 ``` Pour 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 bases 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=> ``` 1. 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 ``` 1. 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 ``` 1. Créez et chargez l’extension `aws_lambda`. ``` babelfish_db=> create extension aws_lambda cascade; CREATE EXTENSION babelfish_db=> ``` ## Utilisation de Babelfish avec Amazon S3 Si vous ne disposez pas d’un compartiment Amazon S3 à utiliser avec votre cluster de bases de données Babelfish, vous pouvez en créer un. Vous devez accorder l’accès pour tout compartiment Amazon S3 que vous souhaitez utiliser. Avant d’essayer d’importer ou d’exporter des données à l’aide d’un compartiment Amazon S3, suivez les étapes uniques suivantes. **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 [Création d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.htmlurl-s3-user;GetStartedWithS3.html#creating-bucket) dans le *Guide de l’utilisateur Amazon Simple Storage Service*. 1. Chargez les fichiers dans votre compartiment Amazon S3. Pour ce faire, suivez les étapes de la section [Ajout d’un objet dans un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.htmlurl-s3-user;GetStartedWithS3.html#uploading-an-object-bucket) dans le *Guide de l’utilisateur Amazon Simple Storage Service*. 1. Configurez les autorisations nécessaires : + Pour importer des données à partir d’Amazon S3, le cluster de bases de données Babelfish doit être autorisé à accéder au compartiment. Nous vous recommandons d'utiliser un rôle Gestion des identités et des accès AWS (IAM) et d'associer une politique IAM à ce rôle pour votre cluster. Pour ce faire, suivez les étapes de [Utilisation d’un rôle IAM pour accéder à un compartiment Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md#USER_PostgreSQL.S3Import.ARNRole). + Pour exporter des données à partir de votre cluster de bases de données Babelfish, votre cluster doit avoir accès au compartiment Amazon S3. Comme pour l’importation, nous recommandons d’utiliser une politique et un rôle IAM. Pour ce faire, suivez les étapes de [Configuration de l’accès à un compartiment Amazon S3](postgresql-s3-export-access-bucket.md). Vous pouvez désormais utiliser Amazon S3 avec l’extension `aws_s3` et votre cluster de bases de données Babelfish. **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 bases de données Babelfish. Dans ce cas, veillez à référencer les tables telles qu’elles existent dans le cadre 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 fonction`aws_s3` : + Pour obtenir un exemple d’utilisation de fonction `aws_s3` pour importer des données, consultez [Importation de données depuis Amazon S3 vers votre instance de base de données Aurora PostgreSQL pour PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md). + Pour obtenir des exemples d’utilisation de fonctions `aws_s3` pour exporter des données, consultez [Exportation de données de requête à l’aide de la fonction aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md). 1. Veillez à référencer les tables Babelfish à l’aide de la dénomination PostgreSQL lorsque vous utilisez l’extension `aws_s3` et Amazon S3, comme indiqué dans la table suivante. | Table Babelfish | Table Aurora PostgreSQL | | --- | --- | | `database.schema.table` | `database_schema_table` | Pour en savoir plus sur l’utilisation d’Amazon S3 avec Aurora PostgreSQL, consultez les sections [Importation de données Amazon S3 dans une d'un cluster de base de données Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) et [Exportation de données à partir d’un cluster de bases de données Aurora PostgreSQL vers Amazon S3](postgresql-s3-export.md). ## Utiliser Babelfish avec AWS Lambda Après le chargement de l’extension `aws_lambda` dans votre cluster de bases de données Babelfish, mais avant l’appel des fonctions Lambda, accordez à Lambda l’accès à votre cluster de bases de données en suivant cette procédure. **Pour configurer l’accès à votre cluster de bases de données Babelfish afin qu’il fonctionne avec Lambda** Cette procédure utilise le AWS CLI pour créer la politique et le rôle IAM, et les associer au cluster de base de données Babelfish. 1. Créez une politique IAM qui autorise l’accès à Lambda à partir de votre cluster de bases 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" } ] }' ``` 1. Créez un rôle IAM que la politique peut endosser 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" } ] }' ``` 1. 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 ``` 1. Attacher le rôle à votre cluster de bases 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 ``` Une fois ces tâches terminées, vous pouvez appeler vos fonctions Lambda. Pour plus d'informations et des exemples de configuration d'un cluster AWS Lambda AWS Lambda de base de données Aurora PostgreSQL avec, consultez. [Étape 2 : configurer IAM pour votre instance de base de données Aurora PostgreSQL pour PostgreSQL et AWS Lambda](PostgreSQL-Lambda.md#PostgreSQL-Lambda-access) **Pour appeler une fonction Lambda à partir de votre cluster de bases 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 bases 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!') ``` Actuellement, Babelfish ne prend pas en charge JSON. Si votre fonction renvoie JSON, utilisez un encapsuleur pour gérer le JSON. 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 bases de données Babelfish à l’aide du client `psql` (ou du client pgAdmin). Pour plus d’informations, consultez [Utilisation de psql pour se connecter au cluster de bases de données](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). 1. Créez l’encapsuleur. Cet exemple utilise le langage procédural de PostgreSQL pour SQL, `PL/pgSQL`. Pour en savoir plus, consultez [PL/pgSQL–SQL Procedural Language](https://www.postgresql.org/docs/13/plpgsql.html). ``` 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 à partir du port TDS Babelfish (1433) ou du port PostgreSQL (5433). 1. Pour appeler cette fonction depuis votre port PostgreSQL : ``` 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) ``` 1. Pour appeler cette fonction à partir du port TDS, connectez-vous au port à l’aide du client de ligne de commande `sqlcmd` de SQL Server. Pour en savoir plus, consultez [Utilisation d’un client SQL Server pour se connecter au cluster de bases de données](babelfish-connect-sqlserver.md). 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!\""} ``` Pour en savoir plus sur l’utilisation de Lambda avec Aurora PostgreSQL, consultez [Invocation d'une AWS Lambda fonction depuis une instance de base de données Aurora PostgreSQL pour PostgreSQL](PostgreSQL-Lambda.md). Pour plus d’informations sur l’utilisation des fonctions Lambda, consultez [Mise en route avec Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) dans le *Guide du développeur AWS Lambda *. ## Utilisation de pg\$1stat\$1statements dans Babelfish Babelfish pour Aurora PostgreSQL prend en charge l’extension `pg_stat_statements` à partir de la version 3.3.0. Pour plus d’informations, consultez [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html). Pour plus d’informations sur la version de cette extension prise en charge par Aurora PostgreSQL, consultez [Extension versions](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html). ### Création de l’extension pg\$1stat\$1statements Pour l’activer sur `pg_stat_statements`, vous devez activer le calcul de l’identifiant de la requête. Il s’active automatiquement si `compute_query_id` est défini sur `on` ou `auto` dans le groupe de paramètres. La valeur par défaut du paramètre `compute_query_id` est `auto`. Vous devez également créer cette extension pour activer cette fonctionnalité. Utilisez la commande suivante pour installer l’extension à partir du point de terminaison T-SQL : ``` 1>EXEC sp_execute_postgresql 'CREATE EXTENSION pg_stat_statements WITH SCHEMA sys'; ``` Vous pouvez accéder aux statistiques des requêtes à l’aide de la requête suivante : ``` postgres=>select * from pg_stat_statements; ``` **Note** Pendant l’installation, si vous ne fournissez pas le nom du schéma de l’extension, celle-ci sera créée par défaut dans le schéma public. Pour y accéder, vous devez utiliser des crochets avec un qualificateur de schéma, comme indiqué ci-dessous : ``` postgres=>select * from [public].pg_stat_statements; ``` Vous pouvez également créer l’extension à partir du point de terminaison PSQL. ### Autorisation de l’extension Par défaut, vous pouvez consulter les statistiques des requêtes effectuées dans votre base de données T-SQL sans avoir besoin d’autorisation. Pour accéder aux statistiques des requêtes créées par d’autres utilisateurs, vous devez disposer du rôle `pg_read_all_stats` PostgreSQL. Suivez les étapes mentionnées ci-dessous pour créer la commande GRANT pg\$1read\$1all\$1stats. 1. Dans T-SQL, utilisez la requête suivante qui renvoie le nom du rôle PG interne. ``` SELECT rolname FROM pg_roles WHERE oid = USER_ID(); ``` 1. Connectez-vous à la base de données Babelfish pour Aurora PostgreSQL avec le privilège rds\$1superuser et utilisez la commande suivante : ``` GRANT pg_read_all_stats TO ``` **Exemple** À partir du point de terminaison T-SQL : ``` 1>SELECT rolname FROM pg_roles WHERE oid = USER_ID(); 2>go ``` ``` rolname ------- master_dbo (1 rows affected) ``` À partir du point de terminaison PSQL : ``` babelfish_db=# grant pg_read_all_stats to master_dbo; ``` ``` GRANT ROLE ``` Vous pouvez accéder aux statistiques des requêtes à l’aide de la vue pg\$1stat\$1statements : ``` 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 37503 34582 5615368793313871642 SET TEXTSIZE 4096 37503 34582 639400815330803392 create table t1(cola int) (6 rows affected) ``` ### Réinitialisation des statistiques des requêtes Vous pouvez utiliser `pg_stat_statements_reset()` pour réinitialiser les statistiques recueillies jusqu’à présent par pg\$1stat\$1statements. Pour plus d’informations, consultez [pg\$1stat\$1statements]( https://www.postgresql.org/docs/current/pgstatstatements.html). Elle est actuellement prise en charge uniquement via le point de terminaison PSQL. Connectez-vous à Babelfish pour Aurora PostgreSQL avec le privilège `rds_superuser` et utilisez la commande suivante : ``` SELECT pg_stat_statements_reset(); ``` ### Limitations + Actuellement, `pg_stat_statements()` n’est pas pris en charge via le point de terminaison T-SQL. La vue `pg_stat_statements` est la méthode recommandée pour recueillir les statistiques. + Certaines requêtes peuvent être réécrites par l’analyseur T-SQL implémenté par le moteur Aurora PostgreSQL. La vue `pg_stat_statements` affichera la requête réécrite, et non la requête d’origine. Exemple ``` select next value for [dbo].[newCounter]; ``` La requête ci-dessus est réécrite comme suit dans la vue pg\$1stat\$1statements. ``` select nextval($1); ``` + Selon le flux d’exécution des instructions, certaines requêtes peuvent ne pas être suivies par pg\$1stat\$1statements et ne seront pas visibles dans la vue. Elle comprend les instructions suivantes : `use dbname`, `goto`, `print`, `raise error`, `set`, `throw`, `declare cursor`. + Pour les instructions CREATE LOGIN et ALTER LOGIN, query et queryid ne s’afficheront pas. Elle indiquera que les privilèges sont insuffisants. + La vue `pg_stat_statements` contient toujours les deux entrées ci-dessous, car elles sont exécutées en interne par le client `sqlcmd`. + SET QUOTED\$1IDENTIFIER OFF + SET TEXTSIZE 4096 ## Utilisation de pgvector dans Babelfish pgvector est une extension open source qui vous permet de rechercher des données similaires directement dans votre base de données Postgres. Babelfish prend désormais en charge cette extension à partir des versions 15.6 et 16.2. Pour plus d’informations, consultez la [documentation open source de pgvector](https://github.com/pgvector/pgvector). ### Conditions préalables Pour activer la fonctionnalité pgvector, installez l’extension dans le schéma sys en utilisant l’une des méthodes suivantes : + Exécutez la commande suivante dans le client sqlcmd : ``` exec sys.sp_execute_postgresql 'CREATE EXTENSION vector WITH SCHEMA sys'; ``` + Connectez-vous à `babelfish_db` et exécutez la commande suivante dans le client psql : ``` CREATE EXTENSION vector WITH SCHEMA sys; ``` **Note** Après avoir installé l’extension pgvector, le type de données vectorielles ne sera disponible que dans les nouvelles connexions à la base de données que vous établirez. Les connexions existantes ne reconnaîtront pas ce nouveau type de données. ### Fonctionnalités prises en charge Babelfish étend les fonctionnalités T-SQL pour prendre en charge les éléments suivants : + **Stockage** Babelfish prend désormais en charge la syntaxe compatible avec les types de données vectoriels, améliorant ainsi sa compatibilité T-SQL. Pour en savoir plus sur le stockage de données avec pgvector, consultez [Stockage](https://github.com/pgvector/pgvector?tab=readme-ov-file#storing). + **Interrogation** Babelfish étend la prise en charge des expressions T-SQL pour inclure les opérateurs de similarité vectorielle. Cependant, pour toutes les autres requêtes, la syntaxe T-SQL standard est toujours requise. **Note** T-SQL ne prend pas en charge le type Array, et les pilotes de base de données ne disposent d’aucune interface pour les gérer. Pour contourner le problème, Babelfish utilise des chaînes de texte (varchar/nvarchar) pour stocker les données vectorielles. Par exemple, lorsque vous demandez une valeur vectorielle [1,2,3], Babelfish renvoie une chaîne ’[1,2,3]’ comme réponse. Vous pouvez analyser et diviser cette chaîne au niveau de l’application selon vos besoins. Pour en savoir plus sur l’interrogation des données avec pgvector, consultez [Interrogation](https://github.com/pgvector/pgvector?tab=readme-ov-file#querying). + **Indexation** La fonction `Create Index` de T-SQL prend désormais en charge la syntaxe `USING INDEX_METHOD`. Vous pouvez désormais définir l’opérateur de recherche de similarité à utiliser sur une colonne spécifique lors de la création d’un index. La grammaire est également étendue pour prendre en charge les opérations de similarité vectorielle sur la colonne requise (vérifier la grammaire column\$1name\$1list\$1with\$1order\$1for\$1vector). ``` CREATE [UNIQUE] [clustered] [COLUMNSTORE] INDEX ON [USING vector_index_method] () Where column_name_list_with_order_for_vector is: [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]) ``` Pour en savoir plus sur l’indexation des données avec pgvector, consultez [Indexation](https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing). + **Performances** + Utilisez `SET BABELFISH_STATISTICS PROFILE ON` pour déboguer les plans de requête du point de terminaison T-SQL. + Augmentez `max_parallel_workers_get_gather` à l’aide de la fonction `set_config` prise en charge dans T-SQL. + Utilisez `IVFFlat` pour les recherches approximatives. Pour de plus amples informations, veuillez consulter [IVFFlat](https://github.com/pgvector/pgvector?tab=readme-ov-file#ivfflat). Pour améliorer les performances avec pgvector, consultez [Performances](https://github.com/pgvector/pgvector?tab=readme-ov-file#performance). ### Limitations + Babelfish ne prend pas en charge la recherche en texte intégral pour la recherche hybride. Pour plus d’informations, consultez [Recherche hybride](https://github.com/pgvector/pgvector?tab=readme-ov-file#hybrid-search). + Babelfish ne prend actuellement pas en charge la fonctionnalité de réindexation. Cependant, vous pouvez toujours utiliser le point de terminaison PostgreSQL pour procéder à la réindexation. Pour plus d’informations, consultez [Exécution de l’opération VACUUM](https://github.com/pgvector/pgvector?tab=readme-ov-file#vacuuming). ## Utilisation du machine learning Amazon Aurora avec Babelfish Vous pouvez étendre les fonctionnalités de votre cluster de bases de données Babelfish pour Aurora PostgreSQL en l’intégrant au machine learning Amazon Aurora. Cette intégration fluide vous donne accès à une gamme de services puissants tels qu'Amazon Comprehend, Amazon SageMaker AI ou Amazon Bedrock, chacun étant conçu pour répondre à des besoins d'apprentissage automatique distincts. En tant qu’utilisateur de Babelfish, vous pouvez utiliser les connaissances existantes en matière de syntaxe et de sémantique T-SQL lorsque vous travaillez avec le machine learning Aurora. Suivez les instructions fournies dans la AWS documentation d'Aurora PostgreSQL. Pour de plus amples informations, veuillez consulter [Utilisation du machine learning Amazon Aurora avec Aurora PostgreSQL](postgresql-ml.md). ### Conditions préalables + Avant d’essayer de configurer votre cluster de bases de données Babelfish pour Aurora PostgreSQL pour utiliser le machine learning Aurora, vous devez comprendre les exigences et prérequis suivants. Pour plus d’informations, consultez [Exigences pour l’utilisation du machine learning Aurora avec Aurora PostgreSQL](postgresql-ml.md#postgresql-ml-prereqs). + Assurez-vous d’installer l’extension `aws_ml` à l’aide du point de terminaison Postgres ou de la procédure de stockage `sp_execute_postgresql`. ``` exec sys.sp_execute_postgresql 'Create Extension aws_ml' ``` **Note** Actuellement, Babelfish ne prend pas en charge les opérations en cascade avec `sp_execute_postgresql` dans Babelfish. Comme `aws_ml` repose sur `aws_commons`, vous devrez l’installer séparément à l’aide du point de terminaison Postgres. ``` create extension aws_common; ``` ### Gestion de la syntaxe et de la sémantique T-SQL avec des fonctions `aws_ml` Les exemples suivants expliquent comment la syntaxe et la sémantique T-SQL sont appliquées aux services Amazon ML : **Example : aws\$1bedrock.invoke\$1model — requête simple utilisant les fonctions Amazon Bedrock** ``` aws_bedrock.invoke_model( model_id varchar, content_type text, accept_type text, model_input text) Returns Varchar(MAX) ``` L’exemple suivant montre comment invoquer un modèle Anthropic Claude 2 pour Bedrock en utilisant invoke\$1model. ``` 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 ); ``` **Example : aws\$1comprehend.detect\$1sentiment — requête simple utilisant les fonctions Amazon Comprehend** ``` aws_comprehend.detect_sentiment( input_text varchar, language_code varchar, max_rows_per_batch int) Returns table (sentiment varchar, confidence real) ``` L’exemple suivant montre comment invoquer le service Amazon Comprehend. ``` select sentiment from aws_comprehend.detect_sentiment('This is great', 'en'); ``` **Example : aws\$1sagemaker.invoke\$1endpoint — Une requête simple utilisant les fonctions 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) ``` Comme model\$1input est marqué comme VARIADIC et comme il est de type « any », les utilisateurs peuvent transmettre une liste de n’importe quelle longueur et de n’importe quel type de données à la fonction qui servira d’entrée au modèle. L'exemple suivant montre comment appeler le SageMaker service 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 ``` Pour plus d’informations sur l’utilisation du machine learning Aurora avec Aurora PostgreSQL, consultez [Utilisation du machine learning Amazon Aurora avec Aurora PostgreSQL](postgresql-ml.md). ### Limitations + Bien que Babelfish n’autorise pas la création de tableaux, il peut tout de même gérer les données représentant des tableaux. Lorsque vous utilisez des fonctions comme `aws_bedrock.invoke_model_get_embeddings` qui renvoient des tableaux, les résultats sont fournis sous forme de chaîne contenant les éléments du tableau.