Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Authentification de l'API Looker à l'aide d'OAuth

Looker utilise OAuth pour permettre aux applications clientes OAuth de s'authentifier auprès de l'API Looker sans exposer les ID client et les codes secrets du client au navigateur qui exécute l'application cliente OAuth.

Les applications Web utilisant OAuth doivent répondre aux exigences suivantes :

L'authentification à l'aide d'OAuth n'est disponible qu'avec l'API Looker 4.0.
Les applications clientes OAuth doivent d'abord être enregistrées auprès de Looker à l'aide de l'API avant que les utilisateurs de l'application puissent s'authentifier dans Looker.
Les applications clientes doivent utiliser HTTPS pour toutes les requêtes envoyées à l'API Looker. Les applications clientes qui souhaitent utiliser les API SubtleCrypto fournies par le navigateur doivent être hébergées en HTTPS.

Compatibilité de l'API Looker avec CORS

L'API Looker peut être appelée dans un navigateur et entre différentes origines à l'aide du protocole CORS (Cross-Origin Resource Sharing). La prise en charge du CORS par Looker est soumise aux exigences suivantes :

Seules les origines listées dans la liste d'autorisation des domaines intégrés peuvent appeler l'API à l'aide de CORS.

Important : La règle d'accès au réseau privé (PNA) du navigateur Google Chrome peut bloquer les requêtes de contenu intégré, car elle peut traiter la requête intégrée comme une connexion à un réseau non approuvé. Pour résoudre ce problème, vous pouvez fournir une solution de contournement locale temporaire pour les tests Chrome en désactivant l'indicateur de navigateur "Local Network Access Check".
Seuls les jetons d'accès obtenus à partir d'OAuth ou en appelant le point de terminaison de l'API /login peuvent être utilisés pour effectuer des appels à l'API Looker à l'aide de CORS.

Remarque : Le point de terminaison de l'API /login ne peut pas être appelé à l'aide de requêtes CORS. Les applications clientes qui doivent appeler l'API Looker à l'aide de requêtes CORS doivent utiliser le processus de connexion OAuth décrit dans Se connecter à l'aide d'OAuth ou récupérer un jeton à partir de votre serveur d'applications ou d'appels d'API non CORS.

Présentation de l'authentification OAuth

Voici un aperçu du processus d'authentification OAuth :

Enregistrez l'application cliente OAuth auprès de votre instance Looker.
Ajoutez l'origine de votre application cliente OAuth à votre liste d'autorisation de domaines intégrés pour l'appel d'API d'échange de code et tous les appels d'API CORS ultérieurs.

Important : N'incluez pas de barre oblique finale (/) dans l'URL du domaine.
Redirigez l'URL du navigateur vers le point de terminaison /auth sur le nom d'hôte de l'UI Looker (et non sur le nom d'hôte de l'API Looker) lorsque l'application cliente OAuth tente d'authentifier un utilisateur. Exemple :https://instance_name.looker.com
Si l'utilisateur est authentifié et connecté à Looker, Looker renvoie immédiatement une redirection OAuth à l'application cliente OAuth. Si l'utilisateur n'est pas déjà connecté à Looker sur l'appareil et le navigateur, l'écran de connexion Looker s'affiche et l'utilisateur est invité à se connecter à son compte utilisateur Looker à l'aide de son protocole d'authentification habituel.
À l'aide du code d'autorisation renvoyé dans la redirection OAuth, votre application cliente OAuth doit ensuite appeler le point de terminaison /token sur le nom d'hôte de l'API Looker, par exemple https://instance_name.looker.com:19999. Le nom d'hôte de l'API peut être identique ou différent de celui de l'UI Looker. Le point de terminaison /token n'existe que sur l'hôte de l'API Looker, et le point de terminaison /auth n'existe que sur l'hôte de l'UI Looker.
Si le code d'autorisation transmis au point de terminaison /token est valide, Looker renvoie un access_token d'API activé pour les requêtes API CORS provenant du domaine de l'application cliente OAuth.

Enregistrer une application cliente OAuth

Toute application cliente OAuth qui tente de s'authentifier auprès de l'API Looker à l'aide d'OAuth doit d'abord être enregistrée auprès de l'instance Looker avant que Looker n'autorise l'accès.

Les administrateurs Looker peuvent enregistrer et gérer des applications clientes OAuth personnalisées directement dans le panneau Admin de Looker, sur la page Gérer les clients OAuth (Admin > Authentification > Gérer les clients OAuth). Cette interface permet aux administrateurs d'effectuer les tâches suivantes :

Configurez un ou plusieurs URI de redirection autorisés pour que l'application soit compatible avec plusieurs environnements et ports.
Limiter l'accès d'autorisation aux membres d'un groupe d'utilisateurs Looker spécifique (Limiter à l'ID de groupe).
Afficher, modifier, activer, désactiver ou supprimer des applications personnalisées enregistrées.

Pour obtenir des instructions détaillées sur l'enregistrement de clients personnalisés dans le panneau Admin, consultez la page de documentation Paramètres d'administration : gérer les clients OAuth.

Enregistrement automatisé à l'aide de l'API

Les administrateurs peuvent également enregistrer une application cliente OAuth de manière programmatique en appelant directement le point de terminaison Register OAuth App ou en l'exécutant dans l'explorateur d'API Looker. Les paramètres sont les suivants :

client_guid : ID de chaîne unique pour l'application (ne peut pas commencer par com.looker.).
redirect_uris : tableau d'URI de rappel autorisés où l'application recevra la redirection OAuth et le code d'autorisation.
display_name : nom de l'application affiché aux utilisateurs.
description : description de l'application cliente OAuth.
group_id (facultatif) : ID numérique d'un groupe Looker auquel l'accès doit être limité.

Se connecter à l'aide d'OAuth

Dirigez l'utilisateur vers le point de terminaison /auth sur l'hôte de l'interface utilisateur. Exemple :

async function oauth_login() {
  const code_verifier = secure_random(32)
  const code_challenge = await sha256_hash(code_verifier)
  const params = {
    response_type: 'code',
    client_id: '123456',
    redirect_uri: 'https://mywebapp.com:3000/authenticated',
    scope: 'cors_api',
    state: '1235813',
    code_challenge_method: 'S256',
    code_challenge: code_challenge,
  }
  const url = `${base_url}?${new URLSearchParams(params).toString()}` // Replace base_url with your full Looker instance's UI host URL, plus the `/auth` endpoint.
  log(url)

  // Stash the code verifier we created in sessionStorage, which
  // will survive page loads caused by login redirects
  // The code verifier value is needed after the login redirect
  // to redeem the auth_code received for an access_token
  //
  sessionStorage.setItem('code_verifier', code_verifier)

  document.location = url
}

function array_to_hex(array) {
  return Array.from(array).map(b => b.toString(16).padStart(2,'0')).join('')
}

function secure_random(byte_count) {
  const array = new Uint8Array(byte_count);
  crypto.getRandomValues(array);
  return array_to_hex(array)
}

async function sha256_hash(message) {
  const msgUint8 = new TextEncoder().encode(message)
  const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8)
  return base64.urlEncode(hashBuffer))  // Refers to the implementation of base64.encode stored at https://gist.github.com/jhurliman/1250118
}

Looker tentera d'authentifier l'utilisateur à l'aide du système d'authentification pour lequel l'instance Looker est configurée.

Si l'utilisateur est déjà connecté à Looker dans le navigateur actuel (ce qui signifie qu'un cookie de connexion est actif), il n'est pas invité à saisir ses identifiants de connexion.
S'il s'agit de la première connexion de cet utilisateur à l'aide de cette application cliente OAuth, Looker affiche une page de divulgation et de confirmation que l'utilisateur doit lire et accepter. Le texte du paramètre description utilisé lors de l'enregistrement de l'application s'affiche. La description doit indiquer ce que l'application prévoit de faire avec le compte Looker de l'utilisateur. Lorsque l'utilisateur clique sur Accepter, la page est redirigée vers l'application redirect_uri.
Si l'utilisateur est déjà connecté à Looker dans le navigateur actuel et a déjà accepté la page de divulgation, la connexion OAuth est instantanée, sans interruption visuelle.

L'API Looker renvoie une redirection OAuth vers l'application cliente OAuth. Enregistrez le code d'autorisation indiqué dans le paramètre d'URI. Voici un exemple d'URI de redirection OAuth :
```
https://mywebapp.com:3000/authenticated?&code=asdfasdfassdf&state=...
```
Le code d'autorisation s'affiche après &code= dans l'URI. Dans cet exemple, le code d'autorisation est asdfasdfassdf.

Envoyez une requête Web au point de terminaison /token de l'API Looker, en transmettant le code d'autorisation et les informations de votre application. Exemple :

async function redeem_auth_code(response_str) {
  const params = new URLSearchParams(response_str)
  const auth_code = params.get('code')

  if (!auth_code) {
    log('ERROR: No authorization code in response')
    return
  }
  log(`auth code received: ${auth_code}`)
  log(`state: ${params.get('state')}`)

  const code_verifier = sessionStorage.getItem('code_verifier')
  if (!code_verifier) {
    log('ERROR: Missing code_verifier in session storage')
    return
  }
  sessionStorage.removeItem('code_verifier')
  const response = await
  fetch('https://mycompany.looker.com:19999/api/token', {  // This is the URL of your Looker instance's API web service
    method: 'POST',
    mode: 'cors',    // This line is required so that the browser will attempt a CORS request.
    body: stringify({
      grant_type: 'authorization_code',
      client_id: '123456',
      redirect_uri: 'https://mywebapp.com:3000/authenticated',
      code: auth_code,
      code_verifier: code_verifier,
    }),
    headers: {
      'x-looker-appid': 'Web App Auth & CORS API Demo', // This header is optional.
      'Content-Type': 'application/json;charset=UTF-8'  // This header is required.
    },
  }).catch((error) => {
    log(`Error: ${error.message}`)
  })

  const info = await response.json()
  log(`/api/token response: ${stringify(info)}`)

  // Store the access_token and other info,
  // which in this example is done in sessionStorage

  const expires_at = new Date(Date.now() + (info.expires_in * 1000))
  info.expires_at = expires_at
  log(`Access token expires at ${expires_at.toLocaleTimeString()} local time.`)
  sessionStorage.setItem('access_info', stringify(info))
  access_info = info
}

Une réponse réussie fournit à l'application cliente OAuth un access_token d'API. La réponse contiendra également un refresh_token, que vous pourrez utiliser ultérieurement pour obtenir un nouveau access_token sans interaction de l'utilisateur. Un refresh_token a une durée de vie d'un mois. Stockez le refresh_token de manière sécurisée.

L'administrateur Looker peut révoquer tous les jetons de ce système à tout moment.