Beachten Sie, dass Sie sich gerade die Looker-Dokumentation ansehen. Die Looker Studio-Dokumentation finden Sie unter https://support.google.com/looker-studio.

Einbettung ohne Cookies

Wenn Looker mithilfe der Einmalanmeldung (SSO) in einen iFrame eingebettet ist, wird in einigen Browsern standardmäßig eine Cookierichtlinie verwendet, die Drittanbieter-Cookies blockiert. Cookies von Drittanbietern werden abgelehnt, wenn der eingebettete iFrame von einer Domain geladen wird, die sich von der Domain unterscheidet, mit der die eingebettete Anwendung geladen wird. Sie können diese Einschränkung im Allgemeinen umgehen, indem Sie eine Vanity-Domain anfordern und verwenden. Vanity-Domains können jedoch in einigen Szenarien nicht verwendet werden. In solchen Fällen können Looker-Einbettungen ohne Cookies verwendet werden.

Wie funktioniert die Einbettung ohne Cookies?

Wenn Drittanbieter-Cookies nicht blockiert werden, wird ein Sitzungs-Cookie erstellt, wenn sich ein Nutzer das erste Mal in Looker anmeldet. Dieses Cookie wird bei jeder Nutzeranfrage gesendet und wird vom Looker-Server verwendet, um die Identität des Nutzers zu ermitteln, der die Anfrage initiiert hat. Wenn Cookies blockiert werden, wird das Cookie nicht mit einer Anfrage gesendet, sodass der Looker-Server den mit der Anfrage verknüpften Nutzer nicht identifizieren kann.

Zur Lösung dieses Problems verknüpft Looker ohne Einbettung Tokens mit jeder Anfrage, mit der die Nutzersitzung auf dem Looker-Server neu erstellt werden kann. Die eingebettete Anwendung muss diese Tokens abrufen und der Looker-Instanz zur Verfügung stellen, die im eingebetteten iFrame ausgeführt wird. Das Abrufen und Bereitstellen dieser Tokens wird im Folgenden erläutert.

Wenn Sie eine der beiden APIs verwenden möchten, muss die eingebettete Anwendung bei der Looker API mit Administratorberechtigungen authentifiziert werden können. Die eingebettete Domain muss außerdem in der Zulassungsliste für die Domaineinbindung aufgeführt sein. Wenn Sie Looker 23.8 oder höher verwenden, kann die eingebettete Domain in die Sitzung ohne Cookies aufgenommen werden.

Einen eingebetteten Looker-iFrame erstellen

Das folgende Sequenzdiagramm veranschaulicht die Erstellung eines eingebetteten iFrames. Mehrere iFrames können entweder gleichzeitig oder zu einem späteren Zeitpunkt generiert werden. Bei korrekter Implementierung nimmt der iFrame automatisch an der Sitzung teil, die vom ersten iFrame erstellt wird. Das Looker Embed SDK vereinfacht diesen Vorgang, indem es automatisch der vorhandenen Sitzung beitritt.

Der Nutzer führt eine Aktion in der eingebetteten Anwendung aus, die zur Erstellung eines Looker-iFrames führt.
Der Client der eingebetteten Anwendung erhält eine Looker-Sitzung. Zum Initiieren dieser Sitzung kann das Looker Embed SDK verwendet werden, aber es muss eine Endpunkt-URL oder eine Callback-Funktion angegeben werden. Wenn eine Callback-Funktion verwendet wird, ruft sie den eingebetteten Anwendungsdatenserver auf, um die eingebettete Looker-Sitzung zu erhalten. Andernfalls ruft das Embed SDK die angegebene Endpunkt-URL auf.
Der einbettende Anwendungsserver verwendet die Looker API, um eine eingebettete Sitzung zu erfassen. Dieser API-Aufruf ähnelt dem Looker-SSO-Signaturvorgang, da er die Nutzerdefinition auf eingebettete Daten als Eingabe akzeptiert. Wenn für den aufrufenden Nutzer bereits eine Looker-Einbettungssitzung vorhanden ist, sollte das zugehörige Sitzungsreferenztoken in den Aufruf aufgenommen werden. Dies wird im Abschnitt Sitzung abrufen dieses Dokuments ausführlicher erläutert.
Die Verarbeitung der Endpunkte für die Einbettung von Sitzungssitzungen ähnelt dem Endpunkt mit SSO-signierter /login/embed/{signed url), da sie die Nutzerdefinition von Looker als Text der Anfrage und nicht in der URL erwartet. Durch den Prozess zum Einbetten von Sitzungssitzungen wird der Nutzer validiert und erstellt oder aktualisiert. Außerdem kann ein vorhandenes Sitzungs-Referenztoken akzeptiert werden. Das ist wichtig, weil so mehrere eingebettete Looker-iFrames dieselbe Sitzung verwenden können. Der eingebettete Nutzer wird nicht aktualisiert, wenn ein Sitzungreferenztoken angegeben wird und die Sitzung nicht abgelaufen ist. Dies unterstützt den Anwendungsfall, bei dem ein iFrame mit einer signierten SSO-URL und andere iFrames ohne signierte SSO-URL erstellt werden. In diesem Fall übernehmen die iFrames ohne signierte SSO-URLs das Cookie aus der ersten Sitzung.
Der Looker API-Aufruf gibt vier Tokens mit jeweils einer Gültigkeitsdauer (TTL) zurück:
- Autorisierungstoken (TTL = 30 Sekunden)
- Navigationstoken (TTL = 10 Minuten)
- API-Token (TTL = 10 Minuten)
- Sitzungsreferenztoken (TTL = verbleibende Lebensdauer der Sitzung)
Der Server für die Einbettung muss die Daten, die von den Looker-Daten zurückgegeben werden, verfolgen und sie sowohl dem aufrufenden Nutzer als auch dem User-Agent des Browsers des aufrufenden Nutzers zuordnen. Vorschläge dazu finden Sie im Abschnitt Tokens generieren in diesem Dokument. Dieser Aufruf gibt das Autorisierungstoken, ein Navigationstoken und ein API-Token sowie alle zugehörigen TTLs zurück. Das Token für die Sitzungsreferenz sollte gesichert und nicht im aufrufenden Browser offengelegt sein.
Nachdem die Tokens an den Browser zurückgegeben wurden, muss eine Looker-Anmelde-URL erstellt werden. Das Looker Embed SDK erstellt automatisch die Anmelde-URL. Beispiele für die Verwendung der windows.postMessage API zum Erstellen der eingebetteten Log-in-URL finden Sie im Abschnitt Looker windows.postMessage API verwenden in diesem Dokument.

Die Anmelde-URL enthält keine Details zum signierten eingebetteten Nutzer. Sie enthält den Ziel-URI, einschließlich des Navigationstokens, und des Autorisierungstokens als Abfrageparameter. Das Autorisierungstoken muss innerhalb von 30 Sekunden verwendet werden und kann nur einmal verwendet werden. Wenn zusätzliche iFrames erforderlich sind, muss die Einbettungssitzung noch einmal erworben werden. Wenn das Sitzungsreferenztoken angegeben wird, wird das Autorisierungstoken jedoch derselben Sitzung zugeordnet.
Der Looker-Log-in-Endpunkt für die Einbettung bestimmt, ob die Anmeldung für eine Einbettung ohne Cookies vorgesehen ist, die durch das Autorisierungstoken angegeben wird. Wenn das Autorisierungstoken gültig ist, wird Folgendes geprüft:
- Die verknüpfte Sitzung ist immer noch gültig.
- Der zugehörige eingebettete Nutzer ist weiterhin gültig.
- Der der Anfrage zugeordnete Browser-User-Agent entspricht dem Browser-Agent, der der Sitzung zugeordnet ist.
Wenn die Prüfungen aus dem vorherigen Schritt erfolgreich sind, wird die Anfrage mithilfe des Ziel-URI weitergeleitet, der in der URL enthalten ist. Das funktioniert genauso wie bei Looker Embed-SSO-Anmeldungen.
Diese Anfrage ist die Weiterleitung zum Starten des Looker-Dashboards. Diese Anfrage hat das Navigationstoken als Parameter.
Bevor der Endpunkt ausgeführt wird, sucht der Looker-Server in der Anfrage nach dem Navigationstoken. Wenn der Server das Token findet, prüft er Folgendes:
- Die verknüpfte Sitzung ist immer noch gültig.
- Der der Anfrage zugeordnete Browser-User-Agent entspricht dem Browser-Agent, der der Sitzung zugeordnet ist.
Wenn sie gültig ist, wird die Sitzung für die Anfrage wiederhergestellt und die Dashboard-Anfrage wird ausgeführt.
Der HTML-Code zum Laden des Dashboards wird an den iFrame zurückgegeben.
Die im iFrame ausgeführte Looker-Benutzeroberfläche bestimmt, dass der Dashboard-HTML eine Einbettungsantwort ohne Cookies ist. Dann sendet die Looker-UI eine Nachricht an die Einbettungsanwendung, in der die in Schritt 6 abgerufenen Tokens angefordert werden. Die UI wartet dann, bis sie die Tokens erhält. Wenn die Tokens nicht ankommen, wird eine Nachricht angezeigt.
Die eingebettete Anwendung sendet die Tokens an den eingebetteten Looker-iFrame.
Wenn die Tokens empfangen werden, startet die Looker-UI, die im iFrame ausgeführt wird, den Vorgang zum Rendern des Anfrageobjekts. Während dieses Vorgangs sendet die UI API-Aufrufe an den Looker-Server. Das in Schritt 15 empfangene API-Token wird automatisch als Header in alle API-Anfragen eingefügt.
Bevor ein Endpunkt ausgeführt wird, sucht der Looker-Server in der Anfrage nach dem API-Token. Wenn der Server das Token findet, prüft er Folgendes:
- Die verknüpfte Sitzung ist immer noch gültig.
- Der der Anfrage zugeordnete Browser-User-Agent entspricht dem Browser-Agent, der der Sitzung zugeordnet ist.
Wenn die Sitzung gültig ist, wird sie für die Anfrage wiederhergestellt und die API-Anfrage wird ausgeführt.
Dashboard-Daten werden zurückgegeben.
Das Dashboard wird gerendert.
Der Nutzer hat die Kontrolle über das Dashboard.

Neue Tokens generieren

Mit der in dem eingebetteten iFrame ausgeführten Looker-UI wird die TTL der eingebetteten Tokens überwacht.
Wenn die Tokens kurz bevorstehen, sendet die Looker-UI eine Aktualisierungstoken-Nachricht an den eingebetteten Anwendungs-Client.
Der Client der eingebetteten Anwendung fordert dann neue Tokens von einem Endpunkt an, der im Server der eingebetteten App implementiert ist. Das Looker Embed SDK fordert automatisch neue Tokens an, aber die Endpunkt-URL oder eine Callback-Funktion muss angegeben werden. Wenn die Callback-Funktion verwendet wird, ruft sie den eingebetteten Anwendungsserver auf, um neue Tokens zu generieren. Andernfalls ruft das Embed SDK die angegebene Endpunkt-URL auf.
Die Einbettungsanwendung sucht den session_reference_token, der der Einbettungssitzung zugeordnet ist. Im im Looker Embed SDK enthaltenen Git-Repository werden Sitzungscookies verwendet, aber auch ein verteilter serverseitiger Cache, z. B. Redis.
Der eingebettete Nameserver ruft den Looker-Server mit einer Anfrage zum Generieren von Tokens auf. Für diese Anfrage sind neben dem User-Agent des Browsers, der die Anfrage initiiert hat, auch aktuelle API- und Navigationstokens erforderlich.
Der Looker-Server validiert den User-Agent, das Sitzungsreferenztoken, das Navigationstoken und das API-Token. Wenn die Anfrage gültig ist, werden neue Tokens generiert.
Die Tokens werden an den aufrufenden Einbettungsanwendungsserver zurückgegeben.
Der Server für die eingebetteten Anwendungen entfernt das Sitzungsreferenz-Token aus der Antwort und gibt die verbleibende Antwort an den eingebetteten Anwendungs-Client zurück.
Der Client der eingebetteten Anwendung sendet die neu generierten Tokens an die Looker-UI. Mit dem Looker Embed SDK erfolgt das automatisch. Eingebettete Anwendungsclients, die die windows.postMessage API verwenden, sind für das Senden der Tokens verantwortlich. Sobald die Looker-UI die Tokens erhält, werden sie in nachfolgenden API-Aufrufen und Seitennavigationen verwendet.

Looker-Einbettung ohne Cookies implementieren

Für Looker-Einbettungen ohne Cookies können Sie entweder das Looker Embed SDK oder die windows.postMessage API verwenden. Die Methode, in der das Looker Embed SDK verwendet wird, ist einfacher. Es gibt jedoch auch ein Beispiel für die Verwendung der windows.postMessage API. Eine ausführliche Erläuterung beider Implementierungen finden Sie in der Looker-Readme-Datei des SDK zum Einbetten. Das git SDK-Repository zum Einbetten enthält auch funktionierende Implementierungen.

Looker-Instanz konfigurieren

Bei der Einbettung ohne Cookies hat die Looker-Einmalanmeldung (SSO) Vorrang. Für die Einbettung ohne Cookies muss die Einmalanmeldung (SSO) aktiviert sein. Anders als bei der Looker-SSO wird bei der Einbettung ohne Cookies nicht die Einstellung Secret einbetten verwendet. Für die Einbettung ohne Cookies wird ein JSON Web Token (JWT) in Form einer JWT-Einbettung verwendet, die auf der Seite Einbetten im Bereich Plattform des Menüs Verwaltung festgelegt oder zurückgesetzt werden kann.

Das JWT-Secret muss nicht festgelegt werden, da das JWT bereits beim ersten Versuch, eine Sitzung ohne Cookies zu erstellen, erstellt wird. Setzen Sie das Token nicht zurück, da dadurch alle aktiven eingebetteten Sitzungen ohne Cookies ungültig werden.

Im Gegensatz zum Einbettungs-Secret wird das eingebettete JWT-Secret nicht offengelegt, da es nur intern auf dem Looker-Server verwendet wird.

Implementierung des Anwendungsclients

Dieser Abschnitt enthält Beispiele für die Implementierung der Einbettung ohne Cookies im Anwendungs-Client und enthält die folgenden Unterabschnitte:

Looker Embed SDK installieren und aktualisieren
Looker Embed SDK verwenden
Looker windows.postMessage API verwenden

Looker Embed SDK installieren oder aktualisieren

Die folgenden Looker SDK-Versionen sind für die Einbettung ohne Cookies erforderlich:

@looker/embed-sdk >= 1.8
@looker/sdk >= 22.16.0

Looker Embed SDK verwenden

Dem Embed SDK wurde eine neue Initialisierungsmethode hinzugefügt, um eine Sitzung ohne Cookies zu starten. Bei dieser Methode können entweder zwei URL-Strings oder zwei Callback-Funktionen verwendet werden. Die URL-Strings sollten auf die Endpunkte auf dem eingebetteten Nameserver verweisen. Informationen zur Implementierung dieser Endpunkte auf dem Nameserver finden Sie in diesem Dokument im Abschnitt Anwendungsserverimplementierung.

LookerEmbedSDK.initCookieless(
  runtimeConfig.lookerHost,
  '/acquire-embed-session',
  '/generate-embed-tokens'
)

Das folgende Beispiel zeigt, wie Callbacks verwendet werden. Callbacks sollten nur verwendet werden, wenn es erforderlich ist, dass der eingebettete Client-Client den Status der Looker-Einbettungssitzung erkennt. Du kannst auch das session:status-Ereignis verwenden, sodass du Callbacks nicht mit dem Embed SDK verwendest.

const acquireEmbedSessionCallback =
  async (): Promise<LookerEmbedCookielessSessionData> => {
    const resp = await fetch('/acquire-embed-session')
    if (!resp.ok) {
      console.error('acquire-embed-session failed', { resp })
      throw new Error(
        `acquire-embed-session failed: ${resp.status} ${resp.statusText}`
      )
    }
    return (await resp.json()) as LookerEmbedCookielessSessionData
  }

const generateEmbedTokensCallback =
  async (): Promise<LookerEmbedCookielessSessionData> => {
    const { api_token, navigation_token } = getApplicationTokens() || {}
    const resp = await fetch('/generate-embed-tokens', {
      method: 'PUT',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ api_token, navigation_token }),
    })
    if (!resp.ok) {
      if (resp.status === 400) {
        return { session_reference_token_ttl: 0 }
      }
      console.error('generate-embed-tokens failed', { resp })
      throw new Error(
        `generate-embed-tokens failed: ${resp.status} ${resp.statusText}`
      )
    }
    return (await resp.json()) as LookerEmbedCookielessSessionData
  }

    LookerEmbedSDK.initCookieless(
      runtimeConfig.lookerHost,
      acquireEmbedSessionCallback,
      generateEmbedTokensCallback
    )

Looker `windows.postMessage` API verwenden

Ein detailliertes Beispiel für die Verwendung der windows.postMessage API finden Sie in den Dateien message_example.ts und message_utils.ts im Git-Repository „Embed SDK“. Highlights des Beispiels werden hier ausführlich beschrieben.

Das folgende Beispiel zeigt, wie die URL für den iFrame erstellt wird. Die Callback-Funktion ist mit dem zuvor genannten acquireEmbedSessionCallback-Beispiel identisch.

  private async getCookielessLoginUrl(): Promise<string> {
    const { authentication_token, navigation_token } =
      await this.embedEnvironment.acquireSession()
    const url = this.embedUrl.startsWith('/embed')
      ? this.embedUrl
      : `/embed${this.embedUrl}`
    const embedUrl = new URL(url, this.frameOrigin)
    if (!embedUrl.searchParams.has('embed_domain')) {
      embedUrl.searchParams.set('embed_domain', window.location.origin)
    }
    embedUrl.searchParams.set('embed_navigation_token', navigation_token)
    const targetUri = encodeURIComponent(
      `${embedUrl.pathname}${embedUrl.search}${embedUrl.hash}`
    )
    return `${embedUrl.origin}/login/embed/${targetUri}?embed_authentication_token=${authentication_token}`
  }

Das folgende Beispiel zeigt, wie Sie Tokenanfragen überwachen, neue Tokens generieren und an Looker senden. Die Callback-Funktion ist mit dem vorherigen generateEmbedTokensCallback-Beispiel identisch.

      this.on(
        'session:tokens:request',
        this.sessionTokensRequestHandler.bind(this)
      )

  private connected = false

  private async sessionTokensRequestHandler(_data: any) {
    const contentWindow = this.getContentWindow()
    if (contentWindow) {
      if (!this.connected) {
        // When not connected the newly acquired tokens can be used.
        const sessionTokens = this.embedEnvironment.applicationTokens
        if (sessionTokens) {
          this.connected = true
          this.send('session:tokens', this.embedEnvironment.applicationTokens)
        }
      } else {
        // If connected, the embedded Looker application has decided that
        // it needs new tokens. Generate new tokens.
        const sessionTokens = await this.embedEnvironment.generateTokens()
        this.send('session:tokens', sessionTokens)
      }
    }
  }

  send(messageType: string, data: any = {}) {
    const contentWindow = this.getContentWindow()
    if (contentWindow) {
      const message: any = {
        type: messageType,
        ...data,
      }
      contentWindow.postMessage(JSON.stringify(message), this.frameOrigin)
    }
    return this
  }

Nameserver-Implementierung

Dieser Abschnitt enthält Beispiele für die Implementierung von Einbettungen ohne Cookies im Anwendungsserver. Sie enthält die folgenden Unterabschnitte:

Grundlegende Implementierung
Sitzung erwerben
Tokens generieren
Hinweise zur Implementierung

Grundlegende Implementierung

Die eingebettete Anwendung muss zwei serverseitige Endpunkte implementieren, die Looker-Endpunkte aufrufen. So wird das Sitzungsreferenztoken sicher. Dies sind die Endpunkte:

Sitzung abrufen: Wenn ein Sitzungsreferenztoken bereits vorhanden und noch aktiv ist, werden Anfragen für eine Sitzung der vorhandenen Sitzung hinzugefügt. Die Akquisitionssitzung wird beim Erstellen eines iFrames aufgerufen.
Tokens generieren: Looker löst in regelmäßigen Abständen Aufrufe an diesen Endpunkt aus.

Akquisitionssitzung

In diesem Beispiel in TypeScript wird die Sitzung verwendet, um das Sitzungsreferenztoken zu speichern oder wiederherzustellen. Der Endpunkt muss nicht in TypeScript implementiert werden.

  app.get(
    '/acquire-embed-session',
    async function (req: Request, res: Response) {
      try {
        const current_session_reference_token =
          req.session && req.session.session_reference_token
        const response = await acquireEmbedSession(
          req.headers['user-agent']!,
          user,
          current_session_reference_token
        )
        const {
          authentication_token,
          authentication_token_ttl,
          navigation_token,
          navigation_token_ttl,
          session_reference_token,
          session_reference_token_ttl,
          api_token,
          api_token_ttl,
        } = response
        req.session!.session_reference_token = session_reference_token
        res.json({
          api_token,
          api_token_ttl,
          authentication_token,
          authentication_token_ttl,
          navigation_token,
          navigation_token_ttl,
          session_reference_token_ttl,
        })
      } catch (err: any) {
        res.status(400).send({ message: err.message })
      }
    }
  )

async function acquireEmbedSession(
  userAgent: string,
  user: LookerEmbedUser,
  session_reference_token: string
) {
  await acquireLookerSession()
    try {
    const request = {
      ...user,
      session_reference_token: session_reference_token,
    }
    const sdk = new Looker40SDK(lookerSession)
    const response = await sdk.ok(
      sdk.acquire_embed_cookieless_session(request, {
        headers: {
          'User-Agent': userAgent,
        },
      })
    )
    return response
  } catch (error) {
    console.error('embed session acquire failed', { error })
    throw error
  }
}

Ab Looker 23.8 kann die eingebettete Domain einbezogen werden, wenn die Sitzung ohne Cookies erfasst wird. Dies ist eine Alternative zum Hinzufügen der eingebetteten Domain über den Looker-Bereich Verwaltung > Einbetten. Looker speichert die eingebettete Domain in der internen Looker-Datenbank. Sie wird daher nicht im Bereich Admin > Einbetten angezeigt. Stattdessen wird die eingebettete Domain der Sitzung ohne Cookies zugeordnet und existiert nur für die Dauer der Sitzung. Lesen Sie die Best Practices zur Sicherheit, wenn Sie diese Funktion nutzen möchten.

Tokens generieren

In diesem Beispiel in TypeScript wird die Sitzung verwendet, um das Sitzungsreferenztoken zu speichern oder wiederherzustellen. Der Endpunkt muss nicht in TypeScript implementiert werden.

Sie müssen wissen, wie 400-Antworten verarbeitet werden, wenn Tokens ungültig sind. Das sollte nicht passieren. Falls dies aber der Fall ist, empfehlen wir, die Sitzung zu beenden.

  app.put(
    '/generate-embed-tokens',
    async function (req: Request, res: Response) {
      try {
        const session_reference_token = req.session!.session_reference_token
        const { api_token, navigation_token } = req.body as any
        const tokens = await generateEmbedTokens(
          req.headers['user-agent']!,
          session_reference_token,
          api_token,
          navigation_token
        )
        res.json(tokens)
      } catch (err: any) {
        res.status(400).send({ message: err.message })
      }
    }
  )
}
async function generateEmbedTokens(
  userAgent: string,
  session_reference_token: string,
  api_token: string,
  navigation_token: string
) {
  if (!session_reference_token) {
    console.error('embed session generate tokens failed')
    // missing session reference  treat as expired session
    return {
      session_reference_token_ttl: 0,
    }
  }
  await acquireLookerSession()
  try {
    const sdk = new Looker40SDK(lookerSession)
    const response = await sdk.ok(
      sdk.generate_tokens_for_cookieless_session(
        {
          api_token,
          navigation_token,
          session_reference_token: session_reference_token || '',
        },
        {
          headers: {
            'User-Agent': userAgent,
          },
        }
      )
    )
    return {
      api_token: response.api_token,
      api_token_ttl: response.api_token_ttl,
      navigation_token: response.navigation_token,
      navigation_token_ttl: response.navigation_token_ttl,
      session_reference_token_ttl: response.session_reference_token_ttl,
    }
  } catch (error: any) {
    if (error.message?.includes('Invalid input tokens provided')) {
      // Currently the Looker UI does not know how to handle bad
      // tokens. This should not happen but if it does expire the
      // session. If the token is bad there is not much that that
      // the Looker UI can do.
      return {
        session_reference_token_ttl: 0,
      }
    }
    console.error('embed session generate tokens failed', { error })
    throw error
  }

Hinweise zur Implementierung

Die eingebettete Anwendung muss das Sitzungsreferenz-Token verfolgen und schützen. Dieses Token sollte mit dem eingebetteten Anwendungsnutzer verknüpft sein. Das Token für die eingebettete Anwendung kann auf eine der folgenden Arten gespeichert werden:

In der Sitzung des eingebetteten Nutzers
In einem serverseitigen Cache, der in einer Clusterumgebung verfügbar ist
In einer Datenbanktabelle, die dem Nutzer zugeordnet ist

Wenn die Sitzung als Cookie gespeichert wird, muss das Cookie verschlüsselt werden. Im Beispiel im SDK für das eingebettete SDK wird ein Sitzungs-Cookie verwendet, um das Sitzungsreferenz-Token zu speichern.

Wenn die eingebettete Looker-Sitzung abläuft, wird ein Dialogfeld im eingebetteten iFrame angezeigt. An diesem Punkt kann der Nutzer nichts in der eingebetteten Instanz tun. In diesem Fall werden die session:status-Ereignisse generiert, sodass die eingebettete Anwendung den aktuellen Status der eingebetteten Looker-Anwendung erkennen und Aktionen ausführen kann.

Beispiel für das Einbetten von Looker-Cookies

Das Einbettungs-SDK-Repository enthält einen einfachen Knoten-Express-Server und -Client, der in TypeScript geschrieben ist und eine einfache Einbettungsanwendung implementiert. Die zuvor gezeigten Beispiele stammen aus dieser Implementierung. Im Folgenden wird davon ausgegangen, dass Ihre Looker-Instanz so konfiguriert wurde, dass die oben beschriebene Einbettung ohne Cookies verwendet wird.

Sie können den Server so ausführen:

Embed SDK-Repository klonen – git clone git@github.com:looker-open-source/embed-sdk.git
Verzeichnis ändern – cd embed-sdk
Installieren Sie die Abhängigkeiten: npm install
Konfigurieren Sie den Server, wie im Abschnitt Server konfigurieren dieses Dokuments beschrieben.
Server ausführen – npm run server

Server konfigurieren

Erstellen Sie im Stammverzeichnis des geklonten Repositorys eine .env-Datei. Diese ist in .gitignore enthalten.

Das Format dafür ist:

LOOKER_EMBED_HOST=your-looker-instance-url.com.
LOOKER_EMBED_API_URL=https://your-looker-instance-url.com
LOOKER_DEMO_HOST=localhost
LOOKER_DEMO_PORT=8080
LOOKER_EMBED_SECRET=embed-secret-from-embed-admin-page
LOOKER_CLIENT_ID=client-id-from-user-admin-page
LOOKER_CLIENT_SECRET=client-secret-from-user-admin-page
LOOKER_DASHBOARD_ID=id-of-dashboard
LOOKER_LOOK_ID=id-of-look
LOOKER_EXPLORE_ID=id-of-explore
LOOKER_EXTENSION_ID=id-of-extension
LOOKER_VERIFY_SSL=true