Authentifier l'identité de l'utilisateur et se connecter à une source de données

Cette page explique comment s'authentifier auprès de l'API Conversational Analytics. Il explique également comment configurer des connexions à vos données dans Looker, BigQuery, Data Studio et Cloud Databases (AlloyDB, GoogleSQL pour Spanner, Cloud SQL pour MySQL et Cloud SQL pour PostgreSQL) à l'aide de requêtes HTTP directes ou du SDK. L'API Conversational Analytics utilise des méthodes d'authentificationGoogle Cloud standards.

Avant de commencer

Avant de pouvoir vous authentifier auprès de l'API Conversational Analytics et configurer des connexions à vos données, vous devez remplir les conditions préalables et activer les API requises pour votre projet Google Cloud , comme décrit dans Activer l'API Conversational Analytics.

Si vous prévoyez d'utiliser des clés de chiffrement gérées par le client (CMEK) pour protéger vos ressources de l'API Conversational Analytics lorsque vous utilisez des sources de données Looker, vous devez autoriser le compte de service de l'API à utiliser votre clé Cloud Key Management Service. Pour en savoir plus, consultez la section Avant de commencer de la documentation CMEK.

S'authentifier auprès de l'API Conversational Analytics

Cette section explique comment s'authentifier auprès de l'API Conversational Analytics à l'aide des méthodes HTTP et Python pour obtenir les jetons d'autorisation nécessaires. Les exemples suivants utilisent une logique de point de terminaison régional basée sur l'emplacement de la ressource. Pour en savoir plus sur les points de terminaison régionaux, consultez Résidence des données.

HTTP curl

L'exemple de commande curl suivant envoie une requête à l'API Conversational Analytics en ciblant l'URL du point de terminaison appropriée pour votre emplacement :

curl  -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
https://ENDPOINT_URL/PATH

Remplacez les exemples de valeurs comme suit :

  • ENDPOINT_URL : point de terminaison de service correspondant à votre emplacement (par exemple, geminidataanalytics.googleapis.com pour global ou geminidataanalytics.us.rep.googleapis.com pour us).
  • PATH : chemin d'accès à la ressource appropriée, par exemple v1/projects/PROJECT_ID/locations/LOCATION/dataAgents.

HTTP avec Python

L'exemple de code Python suivant montre comment obtenir un jeton d'accès pour autoriser les requêtes HTTP à l'aide de la Google Cloud CLI et de Python. Le code crée dynamiquement l'URL du point de terminaison en fonction du type de lieu spécifié.

billing_project = 'PROJECT_ID'
location = 'LOCATION'
access_token = !gcloud auth application-default print-access-token

# Set the base URL based on location.
if not location or location == "global":
  base_url = "https://geminidataanalytics.googleapis.com"
elif "-" in location:
  # Regional endpoints
  base_url = f"https://geminidataanalytics-{location}.googleapis.com"
else:
  # Multi-regional endpoints
  base_url = f"https://geminidataanalytics.{location}.rep.googleapis.com"

url = f"{base_url}/v1/projects/{billing_project}/locations/{location}METHOD"
headers = {"Authorization": f'Bearer {access_token[0]}'}

Remplacez les exemples de valeurs comme suit :

  • PROJECT_ID : ID de votre projet de facturation pour lequel les API requises sont activées.
  • LOCATION : emplacement de stockage de vos ressources (par exemple, global ou us-east4).
  • METHOD : méthode ou chemin d'accès à la ressource du point de terminaison cible. Exemple :
    • Pour créer un agent de données, utilisez la méthode POST et le chemin d'accès /dataAgents.
    • Pour lister les agents de données existants, utilisez la méthode GET et le chemin d'accès /dataAgents.

SDK Python

L'exemple de code Python suivant montre comment authentifier votre compte Google pour accéder à l'API Conversational Analytics dans Colaboratory :

from google.colab import auth
auth.authenticate_user()

Se connecter à Looker avec l'API Conversational Analytics

Pour vous connecter à Looker avec l'API Conversational Analytics, vous devez fournir les informations suivantes :

Votre instance Looker doit également répondre à des exigences spécifiques :

De plus, l'utilisateur ou le compte de service qui s'authentifie doit disposer des autorisations Looker requises.

Choisir la méthode de connexion appropriée

Vous pouvez ensuite choisir d'autoriser les requêtes à l'aide de clés API Looker (ID client et code secret du client) ou d'un jeton d'accès. Les clients qui utilisent Looker (Google Cloud Core) avec uniquement des connexions privées doivent se connecter à l'aide d'un jeton d'accès.

Utilisez le tableau suivant pour choisir comment autoriser les requêtes.

Type d'utilisateur Méthode d'autorisation Pour Looker (version initiale) Pour Looker (Google Cloud Core) Pour Looker (Google Cloud Core) qui n'utilise que des connexions privées Description
Intégrer des utilisateurs Jeton d'accès login_user login_user login_user Respecte les autorisations LookML au niveau des lignes et des colonnes (par exemple, access_filters, access_grants, sql_always_where) du access_token de l'utilisateur cible.
Utilisateurs standards Jeton d'accès

login_user

Ou

Client OAuth

 Client OAuth Client OAuth Respecte les autorisations LookML au niveau des lignes et des colonnes (par exemple, access_filters, access_grants, sql_always_where) du access_token de l'utilisateur cible.
Compte de service Looker réservé à l'API Clé API ID client et code secret ID client et code secret N/A Tous les utilisateurs partagent le même niveau d'accès à Looker.

Les clés API utilisent les autorisations et les niveaux d'accès de l'utilisateur. Les clés API peuvent être utiles si vous créez une application dans laquelle tous les utilisateurs partagent le même niveau d'accès.

Un jeton d'accès vous permet d'utiliser les autorisations LookML au niveau des lignes et des colonnes (par exemple,access_filters, access_grants, sql_always_where) du access_token de l'utilisateur cible. Un jeton d'accès est utile pour une application mutualisée.

Autorisations Looker requises

L'utilisateur ou le compte de service dont les identifiants sont utilisés pour l'authentification doit disposer d'un rôle Looker qui inclut les autorisations suivantes pour les modèles que vous souhaitez interroger :

Vous pouvez configurer ces autorisations dans la section Admin > Rôles de votre instance Looker.

Se connecter avec des clés API Looker

Cette section explique comment générer les clés API et configurer l'API Conversational Analytics pour vous connecter à Looker à l'aide de requêtes HTTP directes ou du SDK.

Pour établir une connexion avec une instance Looker, vous avez besoin de clés API Looker valides, lesquelles sont créées par Looker et se composent d'un ID client et d'un code secret du client. Looker utilise ces clés pour authentifier les utilisateurs auprès de l'API Looker.

Pour en savoir plus sur la génération de clés API Looker, consultez Paramètres d'administration – Utilisateurs. Pour en savoir plus sur les méthodes d'authentification et la gestion des clés API Looker, consultez Authentification de l'API Looker.

HTTP avec Python

Une fois que vous avez généré les clés API (ID client et secret), vous pouvez configurer l'API Conversational Analytics pour qu'elle se connecte à Looker en effectuant des requêtes HTTP directes. L'exemple de code suivant montre comment spécifier les détails de votre source de données Looker et vos clés API dans le corps de votre requête HTTP.


looker_credentials = {
  "oauth": {
      "secret": {
        "client_id": "CLIENT_ID",
        "client_secret": "CLIENT_SECRET",
      }
  }
}

looker_data_source = {
  "looker": {
    "explore_references": {
        "looker_instance_uri": "INSTANCE_URI",
        "lookml_model": "MODEL",
        "explore": "EXPLORE",
    }
  }
}

Remplacez les exemples de valeurs comme suit :

  • CLIENT_ID : ID client de la clé API Looker générée.
  • CLIENT_SECRET : code secret du client pour la clé API Looker générée.
  • INSTANCE_URI : URL complète de votre instance Looker (par exemple, https://mycompany.looker.com)
  • MODEL : nom du modèle LookML que vous souhaitez utiliser.
  • EXPLORE : nom de l'exploration dans le modèle spécifié que vous souhaitez utiliser.

SDK Python

Une fois que vous avez généré les clés API (ID client et secret), vous pouvez configurer l'API Conversational Analytics pour qu'elle se connecte à Looker à l'aide de Python. L'exemple de code Python suivant montre comment spécifier les détails de votre source de données Looker et vos clés API pour l'API Conversational Analytics.

looker_client_id = "CLIENT_ID" # @param {type:"string"}
looker_client_secret = "CLIENT_SECRET" # @param {type:"string"}
looker_instance_uri = "INSTANCE_URI" # @param {type:"string"}
lookml_model = "MODEL" # @param {type:"string"}
explore = "EXPLORE" # @param {type:"string"}

# Looker data source
looker_explore_reference = geminidataanalytics.LookerExploreReference()
looker_explore_reference.looker_instance_uri = looker_instance_uri
looker_explore_reference.lookml_model = lookml_model
looker_explore_reference.explore = explore

credentials = geminidataanalytics.Credentials()
credentials.oauth.secret.client_id = looker_client_id
credentials.oauth.secret.client_secret = looker_client_secret

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.looker.explore_references = [looker_explore_reference]

Remplacez les exemples de valeurs comme suit :

  • CLIENT_ID : ID client de la clé API Looker générée.
  • CLIENT_SECRET : code secret du client pour la clé API Looker générée.
  • INSTANCE_URI : URL complète de votre instance Looker (par exemple, https://mycompany.looker.com)
  • MODEL : nom du modèle Looker que vous souhaitez utiliser.
  • EXPLORE : nom de l'exploration Looker que vous souhaitez utiliser.

Se connecter avec un jeton d'accès

Cette section explique comment configurer l'API Conversational Analytics pour qu'elle se connecte à Looker à l'aide d'un jeton d'accès.

Pour établir une connexion avec une instance Looker, vous avez besoin d'une valeur access_token OAuth2 valide, qui est créée par une requête au point de terminaison de l'API Looker login ayant abouti.

Pour en savoir plus sur la génération d'un jeton d'accès, consultez Authentification de l'API Looker et découvrez comment présenter des identifiants client pour obtenir un jeton d'accès.

HTTP avec Python

L'exemple de code suivant montre comment spécifier les détails de votre source de données Looker et votre jeton d'accès dans le corps de votre requête HTTP.

Pour renforcer la sécurité, nous vous recommandons de stocker le jeton d'accès Looker (access_token) en tant que variable d'environnement.

looker_credentials = {
  "oauth": {
    "token": {
      "access_token": "ACCESS_TOKEN",
    }
  }
}

looker_data_source = {
  "looker": {
    "explore_references": {
        "looker_instance_uri": "INSTANCE_URI",
        "lookml_model": "MODEL",
        "explore": "EXPLORE",
    }
  }
}

Remplacez les exemples de valeurs comme suit :

  • ACCESS_TOKEN : valeur access_token que vous générez pour autoriser les requêtes à Looker.
  • INSTANCE_URI : URL complète de votre instance Looker (par exemple, https://mycompany.looker.com)
  • MODEL : nom du modèle LookML que vous souhaitez utiliser.
  • EXPLORE : nom de l'exploration dans le modèle spécifié que vous souhaitez utiliser.

SDK Python

L'exemple de code Python suivant montre comment définir les détails de votre source de données Looker et votre jeton d'accès pour autoriser les requêtes à l'aide du SDK Python.

Pour renforcer la sécurité, nous vous recommandons de stocker le jeton d'accès Looker (access_token) en tant que variable d'environnement.

looker_access_token = "ACCESS_TOKEN"
looker_instance_uri = "INSTANCE_URI"
lookml_model = "MODEL"
explore = "EXPLORE"

# Looker data source
looker_explore_reference = geminidataanalytics.LookerExploreReference()
looker_explore_reference.looker_instance_uri = looker_instance_uri
looker_explore_reference.lookml_model = lookml_model
looker_explore_reference.explore = explore

credentials = geminidataanalytics.Credentials()
credentials.oauth.token.access_token = looker_access_token

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.looker.explore_references = [looker_explore_reference]

Remplacez les exemples de valeurs comme suit :

  • ACCESS_TOKEN : valeur access_token que vous utilisez pour autoriser les requêtes à Looker.
  • INSTANCE_URI : URL complète de votre instance Looker (par exemple, https://mycompany.looker.com)
  • MODEL : nom du modèle Looker que vous souhaitez utiliser.
  • EXPLORE : nom de l'exploration Looker que vous souhaitez utiliser.

Se connecter à BigQuery avec l'API Conversational Analytics

Cette section explique comment configurer l'API Conversational Analytics pour qu'elle se connecte à BigQuery à l'aide de requêtes HTTP directes ou d'un SDK. L'API Conversational Analytics est compatible avec les connexions aux tables BigQuery et à BigQuery Graph (en preview).

L'API Conversational Analytics ne limite pas le nombre de tables BigQuery auxquelles vous pouvez vous connecter. Toutefois, la connexion à un grand nombre de tables peut réduire la précision ou vous faire dépasser la limite de jetons d'entrée de Gemini. Les requêtes qui nécessitent des jointures complexes sur plusieurs tables peuvent également générer des réponses moins précises.

Se connecter à des tables

Pour vous connecter à une ou plusieurs tables BigQuery, indiquez l'ID du projet, l'ID de l'ensemble de données et l'ID de la table pour chaque table.

Les exemples suivants montrent comment se connecter à une ou plusieurs tables BigQuery à l'aide de requêtes HTTP ou du SDK Python.

HTTP avec Python

L'exemple de code suivant définit une connexion à plusieurs tables BigQuery :

bigquery_data_sources = {
    "bq": {
      "tableReferences": [
        {
          "projectId": "PROJECT_ID",
          "datasetId": "DATASET_ID",
          "tableId": "TABLE_ID"
        },
        {
          "projectId": "PROJECT_ID_2",
          "datasetId": "DATASET_ID_2",
          "tableId": "TABLE_ID_2"
        },
        {
          "projectId": "PROJECT_ID_3",
          "datasetId": "DATASET_ID_3",
          "tableId": "TABLE_ID_3"
        },
      ]
    }
}

Remplacez les exemples de valeurs comme suit :

  • PROJECT_ID, PROJECT_ID_2, PROJECT_ID_3 : ID du projet Google Cloud contenant l'ensemble de données et la table BigQuery auxquels vous souhaitez vous connecter. Pour vous connecter à un ensemble de données public, spécifiez bigquery-public-data.
  • DATASET_ID, DATASET_ID_2, DATASET_ID_3 : ID de l'ensemble de données BigQuery (ou catalog.namespace pour les tables de catalogue du runtime Lakehouse).
  • TABLE_ID, TABLE_ID_2, TABLE_ID_3 : ID de la table BigQuery (ou nom de la table pour les tables du catalogue du runtime Lakehouse).

SDK Python

Vous pouvez utiliser le SDK auth de Colaboratory pour vous authentifier à l'aide des identifiants de votre compte Google et autoriser le client Colab à accéder à BigQuery à l'aide de vos identifiants.

L'exemple de code Python suivant définit une connexion à plusieurs tables BigQuery et montre comment s'authentifier à l'aide des identifiants de votre compte Google dans Colaboratory pour autoriser les requêtes.

from google.colab import auth
auth.authenticate_user()

# BigQuery data source
bigquery_table_reference = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference.project_id = "PROJECT_ID"
bigquery_table_reference.dataset_id = "DATASET_ID"
bigquery_table_reference.table_id = "TABLE_ID"

bigquery_table_reference_2 = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference_2.project_id = "PROJECT_ID_2"
bigquery_table_reference_2.dataset_id = "DATASET_ID_2"
bigquery_table_reference_2.table_id = "TABLE_ID_2"

bigquery_table_reference_3 = geminidataanalytics.BigQueryTableReference()
bigquery_table_reference_3.project_id = "PROJECT_ID_3"
bigquery_table_reference_3.dataset_id = "DATASET_ID_3"
bigquery_table_reference_3.table_id = "TABLE_ID_3"

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.bq.table_references = [bigquery_table_reference, bigquery_table_reference_2, bigquery_table_reference_3]

Remplacez les exemples de valeurs comme suit :

  • PROJECT_ID, PROJECT_ID_2, PROJECT_ID_3 : ID du projet Google Cloud contenant l'ensemble de données et la table BigQuery auxquels vous souhaitez vous connecter. Pour vous connecter à un ensemble de données public, spécifiez bigquery-public-data.
  • DATASET_ID, DATASET_ID_2, DATASET_ID_3 : ID de l'ensemble de données BigQuery (ou catalog.namespace pour les tables de catalogue du runtime Lakehouse). Par exemple, san_francisco.
  • TABLE_ID, TABLE_ID_2, TABLE_ID_3 : ID de la table BigQuery (ou nom de la table pour les tables du catalogue du runtime Lakehouse). Par exemple, street_trees.

Se connecter à un graphique

Les exemples suivants montrent comment se connecter à un graphique BigQuery à l'aide de requêtes HTTP ou du SDK Python. Vous ne pouvez vous connecter qu'à un seul graphique par agent ou conversation.

HTTP avec Python

L'exemple de code suivant définit une connexion à un graphique BigQuery :

bigquery_data_sources = {
    "bq": {
      "propertyGraphReferences": [
        {
          "projectId": "GRAPH_PROJECT_ID",
          "datasetId": "GRAPH_DATASET_ID",
          "propertyGraphId": "GRAPH_ID"
        }
      ]
    }
}

Remplacez les exemples de valeurs comme suit :

  • GRAPH_PROJECT_ID : ID du projet Google Cloud contenant le graphique BigQuery.
  • GRAPH_DATASET_ID : ID de l'ensemble de données BigQuery contenant le graphique.
  • GRAPH_ID : ID du graphique BigQuery.

SDK Python

Vous pouvez utiliser le SDK auth de Colaboratory pour vous authentifier auprès de BigQuery à l'aide des identifiants de votre utilisateur authentifié auprès de Colaboratory.

L'exemple de code Python suivant définit une connexion à un graphique BigQuery :

from google.colab import auth
auth.authenticate_user()

# BigQuery graph reference
bigquery_pg_reference = geminidataanalytics.BigQueryPropertyGraphReference()
bigquery_pg_reference.project_id = "GRAPH_PROJECT_ID"
bigquery_pg_reference.dataset_id = "GRAPH_DATASET_ID"
bigquery_pg_reference.property_graph_id = "GRAPH_ID"

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.bq.property_graph_references = [bigquery_pg_reference]

Remplacez les exemples de valeurs comme suit :

  • GRAPH_PROJECT_ID : ID du projet Google Cloud contenant le graphique BigQuery.
  • GRAPH_DATASET_ID : ID de l'ensemble de données BigQuery contenant le graphique.
  • GRAPH_ID : ID du graphique BigQuery.

Se connecter à Data Studio avec l'API Conversational Analytics

Pour vous connecter à Data Studio avec l'API Conversational Analytics, vous devez d'abord activer l'API Data Studio. Cette section explique comment configurer l'API Conversational Analytics pour qu'elle se connecte à Data Studio à l'aide de requêtes HTTP directes ou d'un SDK.

Pour utiliser l'API Conversational Analytics avec Data Studio Pro, votre abonnement Pro doit se trouver en dehors d'un périmètre VPC-SC.

Activer l'API Data Studio

Pour activer l'API Data Studio, suivez les instructions de Activer l'API.

S'authentifier auprès de Data Studio

Pour vous connecter à Data Studio avec l'API Conversational Analytics, vous devez vous assurer que l'utilisateur ou le compte de service authentifié est autorisé à accéder à la source de données Data Studio, puis fournir l'ID de la source de données.

HTTP avec Python

Une fois l'API Data Studio activée, vous pouvez vous connecter à Data Studio en envoyant des requêtes HTTP curl avec Python. L'exemple de code suivant montre comment spécifier les détails de votre source de données Data Studio dans le corps de votre requête HTTP.

Vous pouvez vous connecter à Data Studio en envoyant des requêtes HTTP directes. Un exemple d'appel HTTP est présenté dans le bloc de code qui suit.

looker_studio_data_source = {
    "studio":{
        "studio_references":
        [
            {
              "datasource_id": "DATASOURCE_ID"
            }
        ]
    }
}

Remplacez your_studio_datasource_id par l'ID de source de données Data Studio que vous souhaitez utiliser.

SDK Python

Une fois l'API Data Studio activée, vous pouvez vous connecter à Data Studio à l'aide d'un SDK. L'exemple de code Python suivant montre comment spécifier les détails de votre source de données Data Studio.


datasource_id = "DATASOURCE_ID"

# Looker Studio
studio_references = geminidataanalytics.StudioDatasourceReference()
studio_references.datasource_id = studio_datasource_id

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.studio.studio_references = [studio_references]

Remplacez STUDIO-DATASOURCE-ID par l'ID de source de données Data Studio que vous souhaitez utiliser.

Se connecter à des bases de données avec l'API Conversational Analytics

Pour vous connecter à des bases de données avec l'API Conversational Analytics, vous devez disposer des autorisations IAM nécessaires pour votre instance de base de données.

Se connecter à AlloyDB pour PostgreSQL

L'utilisateur ou le compte de service doit disposer du rôle alloydb.databaseUser. Pour en savoir plus, consultez AlloyDB, authentification IAM pour les bases de données.

HTTP avec Python

L'exemple de code suivant montre comment spécifier les détails de votre source de données AlloyDB dans le corps de votre requête HTTP au point de terminaison queryData.

alloydb_data_sources = {
  "alloydb": {
      "database_reference": {
          "project_id": alloydb_project_id,
          "region": location,
          "cluster_id": alloydb_cluster_id,
          "instance_id": alloydb_instance_id,
          "database_id": alloydb_database_id,
          "table_ids":["table1", "table2", "table3"]
      },
      # Optional: Include this if you have pre-authored context for the agent
      # "agent_context_reference": {
      #     "context_set_id": f"projects/alloydb_project_id/locations/{location}/contextSets/your_context_set_id"
      # }
  }
}

Remplacez les exemples de valeurs comme suit :

  • your_table_id : liste d'ID de tables séparés par une virgule. Si ce paramètre n'est pas défini, toutes les tables de la base de données sont prises en compte.
  • your_context_set_id : (facultatif) ID complet de l'ensemble de contextes à récupérer. Pour savoir comment trouver l'ID de l'ensemble de contexte, consultez Trouver l'ID de contexte de l'agent dans AlloyDB.

SDK Python

L'exemple de code Python suivant montre comment définir les détails de votre source de données AlloyDB à l'aide du SDK Python.

# AlloyDB data source
alloydb_table_ids = ["your_table_id_1", "your_table_id_2"]
alloydb_context_set_id = "your_context_set_id"

alloydb_reference = geminidataanalytics.AlloyDbReference()
alloydb_reference.database_reference.table_id = alloydb_table_ids
alloydb_reference_database_reference.project_id = billing_project
alloydb_reference_database_reference.region = "us-central1" # Example region
alloydb_reference_database_reference.cluster_id = alloydb_cluster_id
alloydb_reference_database_reference.instance_id = alloydb_instance_id
alloydb_reference_database_reference.database_id = alloydb_database_id
# optional set agent context reference
# alloydb_ref_1.agent_context_reference.context_set_id = f"projects/{billing_project}/locations/{location}/contextSets/your_context_set_id"

alloydb_reference.agent_context_reference.context_set_id = alloydb_context_set_id

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.alloydb.alloydb_reference = alloydb_reference

Remplacez les exemples de valeurs comme suit :

  • your_table_id_1 : ID de la première table de votre instance AlloyDB.
  • your_table_id_2 : ID de la deuxième table de votre instance AlloyDB.
  • your_context_set_id : ID complet de l'ensemble de contexte à récupérer. Pour savoir comment trouver l'ID de l'ensemble de contexte, consultez Trouver l'ID de contexte de l'agent dans AlloyDB.

Se connecter à GoogleSQL pour Spanner

L'utilisateur ou le compte de service doit disposer du rôle spanner.databaseReader. Pour en savoir plus, consultez Appliquer des rôles IAM.

HTTP avec Python

L'exemple de code suivant montre comment spécifier les détails de votre source de données GoogleSQL pour Spanner dans le corps de votre requête HTTP au point de terminaison queryData.

spanner_data_sources = {
    "spanner_reference": {
        "database_reference": {
            "project_id": spanner_project_id,
            "region": location,
            "engine": engine,
            "instance_id": spanner_instance_id,
            "database_id": spanner_database_id,
        },
        # Optional: Include this if you have pre-authored context for the agent
        # "agent_context_reference": {
        #     "context_set_id": f"projects/{billing_project}/locations/{location}/contextSets/your_context_set_id"
        # }
    }
}

Remplacez les exemples de valeurs comme suit :

  • your_table_id_1 : ID de la première table de votre instance GoogleSQL pour Spanner.
  • your_table_id_2 : ID de la deuxième table de votre instance GoogleSQL pour Spanner.
  • your_context_set_id : ID complet de l'ensemble de contexte à récupérer. Pour savoir comment trouver l'ID de l'ensemble de contexte, consultez Trouver l'ID du contexte de l'agent dans GoogleSQL pour Spanner.

SDK Python

L'exemple de code Python suivant montre comment définir les détails de votre source de données GoogleSQL pour Spanner à l'aide du SDK Python.

# Spanner data source
spanner_table_ids = ["your_table_id_1", "your_table_id_2"]
spanner_context_set_id = "your_context_set_id"

spanner_reference = geminidataanalytics.SpannerReference()
spanner_reference.database_reference.table_id = spanner_table_ids
spanner_reference.agent_context_reference.context_set_id = spanner_context_set_id

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.spanner.spanner_reference = spanner_reference

Remplacez les exemples de valeurs comme suit :

  • your_table_id_1 : ID de la première table de votre instance GoogleSQL pour Spanner.
  • your_table_id_2 : ID de la deuxième table de votre instance GoogleSQL pour Spanner.
  • your_context_set_id : ID complet de l'ensemble de contexte à récupérer. Pour savoir comment trouver l'ID de l'ensemble de contexte, consultez Trouver l'ID du contexte de l'agent dans GoogleSQL pour Spanner.

Se connecter à Cloud SQL pour MySQL et Cloud SQL pour PostgreSQL

Les sections suivantes fournissent des instructions pour se connecter à Cloud SQL pour MySQL et à Cloud SQL pour PostgreSQL. L'utilisateur ou le compte de service doit disposer des rôles cloudsql.studioUser et cloudsql.instanceUser. Pour en savoir plus, consultez Gérer les utilisateurs avec l'authentification IAM pour les bases de données Cloud SQL pour MySQL et Gérer les utilisateurs avec l'authentification IAM pour les bases de données Cloud SQL pour PostgreSQL.

HTTP avec Python

L'exemple de code suivant montre comment spécifier les détails de votre source de données Cloud SQL pour MySQL et Cloud SQL pour PostgreSQL dans le corps de votre requête HTTP envoyée au point de terminaison queryData.

cloudsql_data_source = {
    "cloudSqlReference": {
        "databaseReference": {
            "engine": MYSQL,
            "project_id": cloud-db-nl2sql,
            "region": us-central1,
            "instance_id": nl2sql-birdsql-mysql,
            "database_id": financial
        },
        # Optional: Include this if you have pre-authored context for the agent
        # "agent_context_reference": {
        #     "context_set_id": f"projects/cloud-db-nl2sql/locations/us-central1/contextSets/bdf_pg_all_templates\"
        # }
    }
}

Remplacez les exemples de valeurs comme suit :

SDK Python

L'exemple de code Python suivant montre comment définir les détails de votre source de données Cloud SQL pour MySQL et Cloud SQL pour PostgreSQL à l'aide du SDK Python.

# Cloud SQL data source
cloudsql_table_ids = ["your_table_id_1", "your_table_id_2"]
cloudsql_context_set_id = "your_context_set_id"

cloudsql_reference = geminidataanalytics.CloudSqlReference()
cloudsql_reference.database_reference.table_id = cloudsql_table_ids
cloudsql_reference.agent_context_reference.context_set_id = cloudsql_context_set_id

# Connect to your data source
datasource_references = geminidataanalytics.DatasourceReferences()
datasource_references.cloudsql.cloudsql_reference = cloudsql_reference

Remplacez les exemples de valeurs comme suit :