Was ist das Einbetten für externe Benutzer?

Auf dieser Seite wird beschrieben, wie das Einbetten für externe Benutzer funktioniert, wie Sie Ihren Azure Databricks-Arbeitsbereich für die sichere Freigabe eingebetteter Dashboards konfigurieren und wie Sie Beispielanwendungen für die ersten Schritte verwenden. Das Einbetten für externe Benutzer verwendet einen Dienstprinzipal und bereichsbezogene Zugriffstoken, um den Zugriff auf eingebettete Dashboards zu authentifizieren und zu autorisieren. Mit diesem Ansatz können Sie Dashboards für Benutzer außerhalb Ihrer Organisation freigeben, z. B. Partner und Kunden, ohne Azure Databricks-Konten für diese Benutzer bereitzustellen.

Weitere Informationen zu anderen Einbettungsoptionen, einschließlich des Einbettens von Dashboards für Benutzer innerhalb Ihrer Organisation, finden Sie unter "Einbetten eines Dashboards".

Funktionsweise der Einbettung für externe Benutzer

Das Diagramm und die nummerierten Schritte, die folgen, erläutern, wie Benutzer authentifiziert werden und Dashboards mit benutzerbezogenen Ergebnissen aufgefüllt werden, wenn Sie ein Dashboard für externe Benutzer einbetten.

1. Benutzerauthentifizierung und Anforderung: Der Benutzer meldet sich bei Ihrer Anwendung an. Das Frontend Ihrer Anwendung sendet eine authentifizierte Anforderung an Ihren Server für ein Dashboardzugriffstoken.
2. Dienstprinzipalauthentifizierung: Ihr Server verwendet den Dienstprinzipalschlüssel, um ein OAuth-Token vom Databricks-Server anzufordern und zu empfangen. Dies ist ein breit angelegtes Token, das alle Dashboard-APIs aufrufen kann, auf die Azure Databricks im Auftrag des Dienstprinzipals zugreifen kann. Ihr Server ruft den /tokeninfo Endpunkt mithilfe dieses Tokens auf und übergibt grundlegende Benutzerinformationen, z external_viewer_id . B. und external_value. Sehen Sie sich "Sicheres Präsentieren von Dashboards" an einzelne Benutzer an.
3. Generierung von Token mit Benutzerbereich: Mithilfe der Antwort des /tokeninfo Endpunkts und des Databricks OpenID Connect (OIDC)-Endpunkts generiert Ihr Server ein neues streng bereichsbezogenes Token, das die von Ihnen übergebenen Benutzerinformationen codiert.
4. Dashboardrendering und Datenfilterung: Die Anwendungsseite instanziiert DatabricksDashboard@databricks/aibi-client und übergibt das token mit Benutzerbereich während der Erstellung. Das Dashboard wird mit dem Kontext des Benutzers gerendert. Dieses Token autorisiert den Zugriff, unterstützt die Überwachung mit external_viewer_idund führt external_value zur Datenfilterung. Abfragen in Dashboard-Datasets können referenziert __aibi_external_value werden, um Benutzerfilter anzuwenden, um sicherzustellen, dass jeder Viewer nur Daten sieht, die sie anzeigen dürfen.

Sicheres Präsentieren von Dashboards für einzelne Benutzer

Konfigurieren Sie Ihren Anwendungsserver so, dass ein eindeutiges benutzerbezogenes Token für jeden Benutzer basierend auf seiner external_viewer_id. Auf diese Weise können Sie Dashboardansichten und -nutzung über Überwachungsprotokolle nachverfolgen. Dies external_viewer_id wird mit einer external_value, die als globale Variable fungiert, die in SQL-Abfragen eingefügt werden kann, die in Dashboard-Datasets verwendet werden. Auf diese Weise können Sie die im Dashboard angezeigten Daten für jeden Benutzer filtern.

external_viewer_id wird an Ihre Dashboardüberwachungsprotokolle übergeben und dürfen keine personenbezogenen Informationen enthalten. Dieser Wert sollte auch pro Benutzer eindeutig sein.

external_value wird bei der Abfrageverarbeitung verwendet und kann personenbezogene Informationen enthalten.

Im folgenden Beispiel wird die Verwendung des externen Werts als Filter in Datasetabfragen veranschaulicht:

SELECT *
FROM sales
WHERE region = __aibi_external_value

Übersicht über das Setup

Dieser Abschnitt enthält eine allgemeine konzeptionelle Übersicht über die Schritte, die Sie ausführen müssen, um ein Dashboard an einem externen Speicherort einzubetten.

Um ein Dashboard in eine externe Anwendung einzubetten, erstellen Sie zuerst einen Dienstprinzipal in Azure Databricks und generieren einen geheimen Schlüssel. Dem Dienstprinzipal muss Lesezugriff auf das Dashboard und die zugrunde liegenden Daten gewährt werden. Ihr Server verwendet den Dienstprinzipalschlüssel, um ein Token abzurufen, das im Auftrag des Dienstprinzipals auf Dashboard-APIs zugreifen kann. Mit diesem Token ruft der Server den /tokeninfo API-Endpunkt auf, einen OpenID Connect (OIDC)-Endpunkt, der grundlegende Benutzerprofilinformationen einschließlich der external_value Werte external_viewer_id zurückgibt. Mit diesen Werten können Sie Anforderungen einzelnen Benutzern zuordnen.

Mithilfe des vom Dienstprinzipal abgerufenen Tokens generiert Ihr Server ein neues Token, das auf den spezifischen Benutzer, der auf das Dashboard zugreift, festgelegt ist. Dieses Benutzerbereichstoken wird an die Anwendungsseite übergeben, auf der die Anwendung das DatabricksDashboard Objekt aus der @databricks/aibi-client Bibliothek instanziiert. Das Token enthält benutzerspezifische Informationen, die die Überwachung unterstützen und Filter erzwingen, sodass jeder Benutzer nur die Daten sieht, auf die er zugreifen darf. Aus Sicht des Benutzers ermöglicht die Anmeldung bei der Anwendung automatisch den Zugriff auf das eingebettete Dashboard mit der richtigen Datensicht.

Leistungsbeschränkungen und Leistungsüberlegungen

Das externe Einbetten hat eine Rate von 20 Dashboardladevorgängen pro Sekunde. Sie können mehr als 20 Dashboards gleichzeitig öffnen, aber nicht mehr als 20 können gleichzeitig mit dem Laden beginnen.

Voraussetzungen

Um externe Einbettungen zu implementieren, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:

• Sie müssen über mindestens CAN MANAGE-Berechtigungen für ein veröffentlichtes Dashboard verfügen. Siehe Lernprogramm: Verwenden von Beispieldashboards , um bei Bedarf schnell ein Beispieldashboard zu erstellen und zu veröffentlichen.
• Sie müssen Databricks CLI Version 0.205 oder höher installiert haben. Anweisungen finden Sie unter Installieren oder Aktualisieren der Databricks CLI . Informationen zum Konfigurieren und Verwenden der OAuth-Authentifizierung finden Sie unter OAuth-Benutzer-zu-Computer-Authentifizierung (U2M).
• Ein Arbeitsbereichsadministrator muss eine Liste genehmigter Domänen definieren, die das eingebettete Dashboard hosten können. Anweisungen finden Sie unter Verwalten der Dashboardeinbettung .
• Eine externe Anwendung zum Hosten Ihres eingebetteten Dashboards. Sie können Ihre eigene Anwendung verwenden oder die bereitgestellten Beispielanwendungen verwenden.

Schritt 1: Erstellen eines Dienstprinzipals

Erstellen Sie einen Dienstprinzipal, der als Identität für Ihre externe Anwendung in Azure Databricks fungiert. Dieser Dienstprinzipal authentifiziert Anforderungen im Auftrag Ihrer Anwendung.

So erstellen Sie einen Dienstprinzipal:

1. Melden Sie sich als Arbeitsbereichsadministrator beim Azure Databricks-Arbeitsbereich an.
2. Klicken Sie in der oberen Leiste des Azure Databricks-Arbeitsbereichs auf Ihren Benutzernamen, und wählen Sie "Einstellungen" aus.
3. Klicken Sie im linken Bereich auf "Identität" und auf "Zugriff ".
4. Klicken Sie neben Dienstprinzipale auf Verwalten.
5. Klicken Sie auf Dienstprinzipal hinzufügen.
6. Klicken Sie auf Neues hinzufügen.
7. Geben Sie einen beschreibenden Namen für den Dienstprinzipal ein.
8. Klicken Sie auf Hinzufügen.
9. Öffnen Sie den soeben erstellten Dienstprinzipal auf der Eintragsseite "Dienstprinzipale ". Verwenden Sie bei Bedarf das Feld "Texteingabe filtern", um nach dem Namen zu suchen.
10. Notieren Sie sich auf der Seite "Dienstprinzipaldetails" die Anwendungs-ID. Stellen Sie sicher, dass die Sql-Zugriffs- und Arbeitsbereichszugriffskontrollkästchen für Databricks aktiviert sind.

Schritt 2: Erstellen eines OAuth-Schlüssels

Generieren Sie einen geheimen Schlüssel für den Dienstprinzipal, und sammeln Sie die folgenden Konfigurationswerte, die Sie für Ihre externe Anwendung benötigen:

• Dienstprinzipal-ID (Client)
• Geheimer Clientschlüssel

Der Dienstprinzipal verwendet einen OAuth-Geheimschlüssel, um seine Identität zu überprüfen, wenn ein Zugriffstoken von Ihrer externen Anwendung angefordert wird.

So generieren Sie einen geheimen Schlüssel:

1. Klicken Sie auf der Seite "Dienstprinzipaldetails" auf "Geheime Schlüssel".
2. Klicken Sie auf "Geheimen Schlüssel generieren".
3. Geben Sie einen Lebensdauerwert für den neuen geheimen Schlüssel in Tagen ein (z. B. zwischen 1 und 730 Tagen).
4. Kopieren Sie den geheimen Schlüssel sofort. Sie können diesen Geheimschlüssel nicht mehr anzeigen, nachdem Sie diesen Bildschirm verlassen haben.

Schritt 3: Zuweisen von Berechtigungen zu Ihrem Dienstprinzipal

Der von Ihnen erstellte Dienstprinzipal fungiert als Identität, die den Dashboardzugriff über Ihre Anwendung ermöglicht. Die Berechtigungen gelten nur, wenn das Dashboard nicht mit freigegebenen Datenberechtigungen veröffentlicht wird. Wenn freigegebene Datenberechtigungen verwendet werden, greifen die Berechtigungsnachweise des Herausgebers auf die Daten zu. Weitere Details und Empfehlungen finden Sie unter Einbettung von Authentifizierungsansätzen.

1. Klicken Sie auf Dashboards in der Arbeitsbereich-Randleiste, um die Dashboardeintragsseite zu öffnen.
2. Klicken Sie auf den Namen des Dashboards, das Sie einbetten möchten. Das veröffentlichte Dashboard wird geöffnet.
3. Klicken Sie auf Freigeben.
4. Verwenden Sie das Textfeld "Texteingabe" im Dialogfeld " Freigabe ", um ihren Dienstprinzipal zu finden und dann darauf zu klicken. Legen Sie die Berechtigungsstufe auf CAN RUN fest. Klicken Sie dann auf "Hinzufügen".
5. Notieren Sie die Dashboard-ID. Sie finden die Dashboard-ID in der URL des Dashboards (z. B. https://<your-workspace-url>/dashboards/<dashboard-id>). Details zum Databricks-Arbeitsbereich.

Schritt 4: Verwenden der Beispiel-App zum Authentifizieren und Generieren von Token

Verwenden Sie eine Beispielanwendung, um das Externe Einbetten Ihres Dashboards zu üben. Die Anwendungen enthalten Anweisungen und Code, der den erforderlichen Tokenaustausch initiiert, um bereichsbezogene Token zu generieren. Die folgenden Codeblöcke weisen keine Abhängigkeiten auf. Kopieren und speichern Sie eine der folgenden Anwendungen.

Python

Kopieren Und speichern Sie dies in einer Datei mit dem Namen example.py.

#!/usr/bin/env python3

import os
import sys
import json
import base64
import urllib.request
import urllib.parse
from http.server import HTTPServer, BaseHTTPRequestHandler

# -----------------------------------------------------------------------------
# Config
# -----------------------------------------------------------------------------
CONFIG = {
    "instance_url": os.environ.get("INSTANCE_URL"),
    "dashboard_id": os.environ.get("DASHBOARD_ID"),
    "service_principal_id": os.environ.get("SERVICE_PRINCIPAL_ID"),
    "service_principal_secret": os.environ.get("SERVICE_PRINCIPAL_SECRET"),
    "external_viewer_id": os.environ.get("EXTERNAL_VIEWER_ID"),
    "external_value": os.environ.get("EXTERNAL_VALUE"),
    "workspace_id": os.environ.get("WORKSPACE_ID"),
    "port": int(os.environ.get("PORT", 3000)),
}

basic_auth = base64.b64encode(
    f"{CONFIG['service_principal_id']}:{CONFIG['service_principal_secret']}".encode()
).decode()

# -----------------------------------------------------------------------------
# HTTP Request Helper
# -----------------------------------------------------------------------------
def http_request(url, method="GET", headers=None, body=None):
    headers = headers or {}
    if body is not None and not isinstance(body, (bytes, str)):
        raise ValueError("Body must be bytes or str")

    req = urllib.request.Request(url, method=method, headers=headers)
    if body is not None:
        if isinstance(body, str):
            body = body.encode()
        req.data = body

    try:
        with urllib.request.urlopen(req) as resp:
            data = resp.read().decode()
            try:
                return {"data": json.loads(data)}
            except json.JSONDecodeError:
                return {"data": data}
    except urllib.error.HTTPError as e:
        raise RuntimeError(f"HTTP {e.code}: {e.read().decode()}") from None

# -----------------------------------------------------------------------------
# Token logic
# -----------------------------------------------------------------------------
def get_scoped_token():
    # 1. Get all-api token
    oidc_res = http_request(
        f"{CONFIG['instance_url']}/oidc/v1/token",
        method="POST",
        headers={
            "Content-Type": "application/x-www-form-urlencoded",
            "Authorization": f"Basic {basic_auth}",
        },
        body=urllib.parse.urlencode({
            "grant_type": "client_credentials",
            "scope": "all-apis"
        })
    )
    oidc_token = oidc_res["data"]["access_token"]

    # 2. Get token info
    token_info_url = (
        f"{CONFIG['instance_url']}/api/2.0/lakeview/dashboards/"
        f"{CONFIG['dashboard_id']}/published/tokeninfo"
        f"?external_viewer_id={urllib.parse.quote(CONFIG['external_viewer_id'])}"
        f"&external_value={urllib.parse.quote(CONFIG['external_value'])}"
    )
    token_info = http_request(
        token_info_url,
        headers={"Authorization": f"Bearer {oidc_token}"}
    )["data"]

    # 3. Generate scoped token
    params = token_info.copy()
    authorization_details = params.pop("authorization_details", None)
    params.update({
        "grant_type": "client_credentials",
        "authorization_details": json.dumps(authorization_details)
    })

    scoped_res = http_request(
        f"{CONFIG['instance_url']}/oidc/v1/token",
        method="POST",
        headers={
            "Content-Type": "application/x-www-form-urlencoded",
            "Authorization": f"Basic {basic_auth}",
        },
        body=urllib.parse.urlencode(params)
    )
    return scoped_res["data"]["access_token"]

# -----------------------------------------------------------------------------
# HTML generator
# -----------------------------------------------------------------------------
def generate_html(token):
    return f"""<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dashboard Demo</title>
    <style>
        body {{ font-family: system-ui; margin: 0; padding: 20px; background: #f5f5f5; }}
        .container {{ max-width: 1200px; margin: 0 auto; height:calc(100vh - 40px) }}
    </style>
</head>
<body>
    <div id="dashboard-content" class="container"></div>
    <script type="module">
        import {{ DatabricksDashboard }} from "https://cdn.jsdelivr.net/npm/@databricks/aibi-client@0.0.0-alpha.7/+esm";
        const dashboard = new DatabricksDashboard({{
            instanceUrl: "{CONFIG['instance_url']}",
            workspaceId: "{CONFIG['workspace_id']}",
            dashboardId: "{CONFIG['dashboard_id']}",
            token: "{token}",
            container: document.getElementById("dashboard-content")
        }});
        dashboard.initialize();
    </script>
</body>
</html>"""

# -----------------------------------------------------------------------------
# HTTP server
# -----------------------------------------------------------------------------
class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/":
            self.send_response(404)
            self.send_header("Content-Type", "text/plain")
            self.end_headers()
            self.wfile.write(b"Not Found")
            return

        try:
            token = get_scoped_token()
            html = generate_html(token)
            status = 200
        except Exception as e:
            html = f"<h1>Error</h1><p>{e}</p>"
            status = 500

        self.send_response(status)
        self.send_header("Content-Type", "text/html")
        self.end_headers()
        self.wfile.write(html.encode())

def start_server():
    missing = [k for k, v in CONFIG.items() if not v]
    if missing:
        print(f"Missing: {', '.join(missing)}", file=sys.stderr)
        sys.exit(1)

    server = HTTPServer(("localhost", CONFIG["port"]), RequestHandler)
    print(f":rocket: Server running on http://localhost:{CONFIG['port']}")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        sys.exit(0)

if __name__ == "__main__":
    start_server()

JavaScript

Kopieren Und speichern Sie dies in einer Datei mit dem Namen example.js.

#!/usr/bin/env node

const http = require('http');
const https = require('https');
const { URL, URLSearchParams } = require('url');

// This constant is just a mapping of environment variables to their respective
// values.
const CONFIG = {
  instanceUrl: process.env.INSTANCE_URL,
  dashboardId: process.env.DASHBOARD_ID,
  servicePrincipalId: process.env.SERVICE_PRINCIPAL_ID,
  servicePrincipalSecret: process.env.SERVICE_PRINCIPAL_SECRET,
  externalViewerId: process.env.EXTERNAL_VIEWER_ID,
  externalValue: process.env.EXTERNAL_VALUE,
  workspaceId: process.env.WORKSPACE_ID,
  port: process.env.PORT || 3000,
};

const basicAuth = Buffer.from(`${CONFIG.servicePrincipalId}:${CONFIG.servicePrincipalSecret}`).toString('base64');

// ------------------------------------------------------------------------------------------------
// Main
// ------------------------------------------------------------------------------------------------

function startServer() {
  const missing = Object.keys(CONFIG).filter((key) => !CONFIG[key]);
  if (missing.length > 0) throw new Error(`Missing: ${missing.join(', ')}`);

  const server = http.createServer(async (req, res) => {
    // This is a demo server, we only support GET requests to the root URL.
    if (req.method !== 'GET' || req.url !== '/') {
      res.writeHead(404, { 'Content-Type': 'text/plain' });
      res.end('Not Found');
      return;
    }

    let html = '';
    let status = 200;

    try {
      const token = await getScopedToken();
      html = generateHTML(token);
    } catch (error) {
      html = `<h1>Error</h1><p>${error.message}</p>`;
      status = 500;
    } finally {
      res.writeHead(status, { 'Content-Type': 'text/html' });
      res.end(html);
    }
  });

  server.listen(CONFIG.port, () => {
    console.log(`🚀 Server running on http://localhost:${CONFIG.port}`);
  });

  process.on('SIGINT', () => process.exit(0));
  process.on('SIGTERM', () => process.exit(0));
}

async function getScopedToken() {
  // 1. Get all-api token. This will allow you to access the /tokeninfo
  // endpoint, which contains the information required to generate a scoped token
  const {
    data: { access_token: oidcToken },
  } = await httpRequest(`${CONFIG.instanceUrl}/oidc/v1/token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      Authorization: `Basic ${basicAuth}`,
    },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      scope: 'all-apis',
    }),
  });

  // 2. Get token info. This information is **required** for generating a token that is correctly downscoped.
  // A correctly downscoped token will only have access to a handful of APIs, and within those APIs, only
  // a the specific resources required to render the dashboard.
  //
  // This is essential to prevent leaking a privileged token.
  //
  // At the time of writing, OAuth tokens in Databricks are valid for 1 hour.
  const tokenInfoUrl = new URL(
    `${CONFIG.instanceUrl}/api/2.0/lakeview/dashboards/${CONFIG.dashboardId}/published/tokeninfo`,
  );
  tokenInfoUrl.searchParams.set('external_viewer_id', CONFIG.externalViewerId);
  tokenInfoUrl.searchParams.set('external_value', CONFIG.externalValue);

  const { data: tokenInfo } = await httpRequest(tokenInfoUrl.toString(), {
    headers: { Authorization: `Bearer ${oidcToken}` },
  });

  // 3. Generate scoped token. This call is very similar to what was issued before, but now we are providing the scoping to make the generated token
  // safe to pass to a browser.
  const { authorization_details, ...params } = tokenInfo;
  const {
    data: { access_token },
  } = await httpRequest(`${CONFIG.instanceUrl}/oidc/v1/token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      Authorization: `Basic ${basicAuth}`,
    },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      ...params,
      authorization_details: JSON.stringify(authorization_details),
    }),
  });

  return access_token;
}

startServer();

// ------------------------------------------------------------------------------------------------
// Helper functions
// ------------------------------------------------------------------------------------------------

/**
 * Helper function to create HTTP requests.
 * @param {string} url - The URL to make the request to.
 * @param {Object} options - The options for the request.
 * @param {string} options.method - The HTTP method to use.
 * @param {Object} options.headers - The headers to include in the request.
 * @param {Object} options.body - The body to include in the request.
 * @returns {Promise<Object>} A promise that resolves to the response data.
 */
function httpRequest(url, { method = 'GET', headers = {}, body } = {}) {
  return new Promise((resolve, reject) => {
    const isHttps = url.startsWith('https://');
    const lib = isHttps ? https : http;
    const options = new URL(url);
    options.method = method;
    options.headers = headers;

    const req = lib.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => (data += chunk));
      res.on('end', () => {
        if (res.statusCode >= 200 && res.statusCode < 300) {
          try {
            resolve({ data: JSON.parse(data) });
          } catch {
            resolve({ data });
          }
        } else {
          reject(new Error(`HTTP ${res.statusCode}: ${data}`));
        }
      });
    });

    req.on('error', reject);

    if (body) {
      if (typeof body === 'string' || Buffer.isBuffer(body)) {
        req.write(body);
      } else if (body instanceof URLSearchParams) {
        req.write(body.toString());
      } else {
        req.write(JSON.stringify(body));
      }
    }
    req.end();
  });
}

function generateHTML(token) {
  return `<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dashboard Demo</title>
    <style>
        body { font-family: system-ui; margin: 0; padding: 20px; background: #f5f5f5; }
        .container { max-width: 1200px; margin: 0 auto; height:calc(100vh - 40px) }
    </style>
</head>
<body>
    <div id="dashboard-content" class="container"></div>
    <script type="module">
        /**
         * We recommend bundling the dependency instead of using a CDN. However, for demonstration purposes,
         * we are just using a CDN.
         * 
         * We do not recommend one CDN over another and encourage decoupling the dependency from third-party code.
         */
        import { DatabricksDashboard } from "https://cdn.jsdelivr.net/npm/@databricks/aibi-client@0.0.0-alpha.7/+esm";
    
        const dashboard = new DatabricksDashboard({
            instanceUrl: "${CONFIG.instanceUrl}",
            workspaceId: "${CONFIG.workspaceId}",
            dashboardId: "${CONFIG.dashboardId}",
            token: "${token}",
            container: document.getElementById("dashboard-content")
        });
        
        dashboard.initialize();
    </script>
</body>
</html>`;
}

Schritt 5: Ausführen der Beispielanwendung

Ersetzen Sie die folgenden Werte, und führen Sie dann den Codeblock aus Ihrem Terminal aus. Ihre Werte sollten nicht von winkeln Klammern umgeben sein (< >):

• Verwenden Sie die Arbeitsbereichs-URL , um die folgenden Werte zu suchen und zu ersetzen:
  • <your-instance>
  • <workspace_id>
  • <dashboard_id>
• Ersetzen Sie die folgenden Werte durch die Werte, die Sie beim Erstellen des Dienstprinzipals erstellt haben (Schritt 2):
  • <service_principal_id>
  • <service_principal_secret> (geheimer Clientschlüssel)
• Ersetzen Sie die folgenden Werte durch Bezeichner, die Benutzern der externen Anwendung zugeordnet sind:
  • <some-external-viewer>
  • <some-external-value>
• Ersetzen Sie </path/to/example> den Pfad zu der Datei, .py die .js Sie im vorherigen Schritt erstellt haben. Fügen Sie die Dateierweiterung hinzu.

INSTANCE_URL='https://<your-instance>.databricks.com' \
WORKSPACE_ID='<workspace_id>' \
DASHBOARD_ID='<dashboard_id>' \
SERVICE_PRINCIPAL_ID='<service-principal-id>' \
SERVICE_PRINCIPAL_SECRET='<service-principal_secret>' \
EXTERNAL_VIEWER_ID='<some-external-viewer>' \
EXTERNAL_VALUE='<some-external-value>' \
~</path/to/example>

# Terminal will output: :rocket: Server running on http://localhost:3000