S'authentifier avec un compte utilisateur dans les applications installées

Ce guide explique comment exploiter l'authentification à l'aide de comptes utilisateur pour accéder à l'API BigQuery lorsque votre application est installée sur les ordinateurs des utilisateurs.

Afin de garantir que l'application accède uniquement aux tables BigQuery disponibles pour l'utilisateur final, faites appel aux identifiants utilisateur pour assurer l'authentification. L'identifiant d'un utilisateur final ne peut exécuter de requêtes que sur le projet Google Cloud de cet utilisateur, et non sur le projet de l'application. En conséquence, c'est l'utilisateur qui est facturé pour les requêtes, et non l'application.

Avant de commencer

  1. Créez un projet Google Cloud qui représente votre application installée.
  2. Installez les bibliothèques clientes BigQuery.
  3. Installez les bibliothèques requises.

    Python

    Installez la bibliothèque d'intégration oauthlib pour Google Auth.
    pip install --upgrade google-auth-oauthlib

    Node.js

    Installez la bibliothèque d'intégration oauthlib pour Google Auth.
    npm install google-auth-library
    npm install readline-promise

Configurer les identifiants client

Utilisez le bouton suivant pour sélectionner un projet et créer les identifiants requis.

Obtenir des identifiants

Créer des identifiants manuellement

  1. Accédez à la page des identifiants d'API dans Google Cloud Console.
  2. Remplissez les champs obligatoires sur l'écran d'autorisation OAuth.
  3. Sur la page Identifiants, cliquez sur le bouton Créer des identifiants.

    Sélectionnez ID client OAuth.

  4. Comme type d'application, choisissez Bureau, puis cliquez sur Créer.
  5. Pour télécharger les identifiants, cliquez sur le bouton Download JSON (Télécharger JSON).

    Télécharger JSON

    Enregistrez le fichier d'identifiants sous le nom client_secrets.json. Ce fichier doit être distribué avec votre application.

S'authentifier et appeler l'API

  1. Utilisez les identifiants client pour lancer le flux OAuth 2.0.

    Python

    from google_auth_oauthlib import flow
    
    # TODO: Uncomment the line below to set the `launch_browser` variable.
    # launch_browser = True
    #
    # The `launch_browser` boolean variable indicates if a local server is used
    # as the callback URL in the auth flow. A value of `True` is recommended,
    # but a local server does not work if accessing the application remotely,
    # such as over SSH or from a remote Jupyter notebook.
    
    appflow = flow.InstalledAppFlow.from_client_secrets_file(
        'client_secrets.json',
        scopes=['https://www.googleapis.com/auth/bigquery'])
    
    if launch_browser:
        appflow.run_local_server()
    else:
        appflow.run_console()
    
    credentials = appflow.credentials

    Node.js

    const {OAuth2Client} = require('google-auth-library');
    const readline = require('readline-promise').default;
    
    function startRl() {
      const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
      });
    
      return rl;
    }
    
    /**
     * Download your OAuth2 configuration from the Google
     * Developers Console API Credentials page.
     * https://console.cloud.google.com/apis/credentials
     */
    const keys = require('./oauth2.keys.json');
    
    /**
     * Create a new OAuth2Client, and go through the OAuth2 content
     * workflow. Return the full client to the callback.
     */
    async function getRedirectUrl() {
      const rl = main.startRl();
      // Create an oAuth client to authorize the API call.  Secrets are kept in a `keys.json` file,
      // which should be downloaded from the Google Developers Console.
      const oAuth2Client = new OAuth2Client(
        keys.installed.client_id,
        keys.installed.client_secret,
        keys.installed.redirect_uris[0]
      );
    
      // Generate the url that will be used for the consent dialog.
      const authorizeUrl = oAuth2Client.generateAuthUrl({
        access_type: 'offline',
        scope: 'https://www.googleapis.com/auth/bigquery',
        prompt: 'consent',
      });
    
      console.info(
        `Please visit this URL to authorize this application: ${authorizeUrl}`
      );
    
      const code = await rl.questionAsync('Enter the authorization code: ');
      const tokens = await main.exchangeCode(code);
      rl.close();
    
      return tokens;
    }
    
    // Exchange an authorization code for an access token
    async function exchangeCode(code) {
      const oAuth2Client = new OAuth2Client(
        keys.installed.client_id,
        keys.installed.client_secret,
        keys.installed.redirect_uris[0]
      );
    
      const r = await oAuth2Client.getToken(code);
      console.info(r.tokens);
      return r.tokens;
    }
    
    async function authFlow(projectId = 'project_id') {
      /**
       * TODO(developer):
       * Save Project ID as environment variable PROJECT_ID="project_id"
       * Uncomment the following line before running the sample.
       */
      // projectId = process.env.PROJECT_ID;
    
      const tokens = await main.getRedirectUrl();
    
      const credentials = {
        type: 'authorized_user',
        client_id: keys.installed.client_id,
        client_secret: keys.installed.client_secret,
        refresh_token: tokens.refresh_token,
      };
    
      return {
        projectId,
        credentials,
      };
    }
  2. Utilisez les identifiants authentifiés pour vous connecter à l'API BigQuery.

    Python

    from google.cloud import bigquery
    
    # TODO: Uncomment the line below to set the `project` variable.
    # project = 'user-project-id'
    #
    # The `project` variable defines the project to be billed for query
    # processing. The user must have the bigquery.jobs.create permission on
    # this project to run a query. See:
    # https://cloud.google.com/bigquery/docs/access-control#permissions
    
    client = bigquery.Client(project=project, credentials=credentials)
    
    query_string = """SELECT name, SUM(number) as total
    FROM `bigquery-public-data.usa_names.usa_1910_current`
    WHERE name = 'William'
    GROUP BY name;
    """
    query_job = client.query(query_string)
    
    # Print the results.
    for row in query_job.result():  # Wait for the job to complete.
        print("{}: {}".format(row['name'], row['total']))

    Node.js

    async function query() {
      const {BigQuery} = require('@google-cloud/bigquery');
    
      const credentials = await main.authFlow();
      const bigquery = new BigQuery(credentials);
    
      // Queries the U.S. given names dataset for the state of Texas.
      const query = `SELECT name, SUM(number) as total
      FROM \`bigquery-public-data.usa_names.usa_1910_current\`
      WHERE name = 'William'
      GROUP BY name;`;
    
      // For all options, see https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/query
      const options = {
        query: query,
      };
    
      // Run the query as a job
      const [job] = await bigquery.createQueryJob(options);
      console.log(`Job ${job.id} started.`);
    
      // Wait for the query to finish
      const [rows] = await job.getQueryResults();
    
      // Print the results
      console.log('Rows:');
      rows.forEach(row => console.log(row));
    
      return rows;
    }
    
    const main = {
      query,
      authFlow,
      exchangeCode,
      getRedirectUrl,
      startRl,
    };
    module.exports = {
      main,
    };
    
    if (module === require.main) {
      query().catch(console.error);
    }

Lorsque vous exécutez l'exemple de code, celui-ci lance un navigateur qui demande l'accès au projet associé aux codes secrets du client. Vous pouvez utiliser les identifiants résultants pour accéder aux ressources BigQuery de l'utilisateur : en effet, l'exemple a demandé le champ d'application BigQuery.

Étapes suivantes

  1. Découvrez d'autres moyens d'authentifier votre application pour accéder à l'API BigQuery.
  2. Découvrez l'authentification au moyen des identifiants de l'utilisateur final dans toutes les API Google Cloud.