Co to jest osadzanie dla użytkowników zewnętrznych?

Ważne

Ta funkcja jest dostępna w publicznej wersji testowej.

Na tej stronie opisano, jak działa osadzanie dla użytkowników zewnętrznych, jak skonfigurować obszar roboczy usługi Azure Databricks pod kątem bezpiecznego udostępniania osadzonych pulpitów nawigacyjnych oraz jak rozpocząć korzystanie z przykładowych aplikacji. Osadzanie dla użytkowników zewnętrznych używa jednostki usługi i tokenów dostępu w zakresie do uwierzytelniania i autoryzacji dostępu do osadzonych pulpitów nawigacyjnych. Takie podejście umożliwia udostępnianie pulpitów nawigacyjnych osobom przeglądającym spoza organizacji, takim jak partnerzy i klienci, bez aprowizowania kont usługi Azure Databricks dla tych użytkowników.

Aby dowiedzieć się więcej na temat innych opcji osadzania, w tym osadzania pulpitów nawigacyjnych dla użytkowników w organizacji, zobacz Osadzanie pulpitu nawigacyjnego.

Jak działa osadzanie dla użytkowników zewnętrznych

Diagram i kroki numerowane, które wyjaśniają, jak użytkownicy są uwierzytelniani, a pulpity nawigacyjne są wypełniane wynikami o zakresie użytkownika podczas osadzania pulpitu nawigacyjnego dla użytkowników zewnętrznych.

1. Uwierzytelnianie i żądanie użytkownika: Użytkownik loguje się do aplikacji. Fronton aplikacji wysyła uwierzytelnione żądanie do serwera na potrzeby tokenu dostępu do pulpitu nawigacyjnego.
2. Uwierzytelnianie jednostki usługi: Serwer używa wpisu tajnego jednostki usługi do żądania i odbierania tokenu OAuth z serwera usługi Databricks. Jest to szeroko zakres tokenu, który może wywoływać wszystkie interfejsy API pulpitu nawigacyjnego, do których usługa Azure Databricks ma dostęp w imieniu jednostki usługi. Serwer wywołuje punkt końcowy przy użyciu tego tokenu /tokeninfo , przekazując podstawowe informacje o użytkowniku, takie jak external_viewer_id i external_value. Zobacz Bezpieczne prezentowanie pulpitów nawigacyjnych poszczególnym użytkownikom.
3. Generowanie tokenu o zakresie użytkownika: Korzystając z odpowiedzi z punktu końcowego /tokeninfo i punktu końcowego usługi Databricks OpenID Connect (OIDC), serwer generuje nowy token o ściśle określonym zakresie, który koduje przekazane informacje o użytkowniku.
4. Renderowanie pulpitu nawigacyjnego i filtrowanie danych: Strona aplikacji tworzy wystąpienie DatabricksDashboard tokenu o @databricks/aibi-client zakresie użytkownika i przekazuje go podczas budowy. Pulpit nawigacyjny jest renderowany z kontekstem użytkownika. Ten token autoryzuje dostęp, obsługuje inspekcję za pomocą external_viewer_idmetody i prowadzi external_value do filtrowania danych. Zapytania w zestawach danych pulpitu nawigacyjnego mogą odwoływać __aibi_external_value się do stosowania filtrów dla poszczególnych użytkowników, dzięki czemu każda osoba przeglądająca będzie widzieć tylko dane, które mogą wyświetlać.

Bezpieczne prezentowanie pulpitów nawigacyjnych poszczególnym użytkownikom

Skonfiguruj serwer aplikacji, aby wygenerować unikatowy token o zakresie użytkownika dla każdego użytkownika na podstawie ich external_viewer_id. Umożliwia to śledzenie widoków pulpitu nawigacyjnego i użycia za pośrednictwem dzienników inspekcji. Element external_viewer_id jest sparowany z elementem external_value, który działa jako zmienna globalna, którą można wstawić do zapytań SQL używanych w zestawach danych pulpitu nawigacyjnego. Dzięki temu można filtrować dane wyświetlane na pulpicie nawigacyjnym dla każdego użytkownika.

external_viewer_id jest przekazywany do dzienników inspekcji pulpitu nawigacyjnego i nie może zawierać danych osobowych. Ta wartość powinna być również unikatowa dla każdego użytkownika.

external_value jest używany w przetwarzaniu zapytań i może zawierać dane osobowe.

W poniższym przykładzie pokazano, jak używać wartości zewnętrznej jako filtru w zapytaniach zestawu danych:

SELECT *
FROM sales
WHERE region = __aibi_external_value

Omówienie instalacji

Ta sekcja zawiera ogólne omówienie koncepcyjne kroków, które należy wykonać, aby skonfigurować osadzanie pulpitu nawigacyjnego w lokalizacji zewnętrznej.

Aby osadzić pulpit nawigacyjny w aplikacji zewnętrznej, należy najpierw utworzyć jednostkę usługi w usłudze Azure Databricks i wygenerować wpis tajny. Jednostka usługi musi mieć dostęp do odczytu do pulpitu nawigacyjnego i jego danych bazowych. Serwer używa wpisu tajnego jednostki usługi do pobierania tokenu, który może uzyskiwać dostęp do interfejsów API pulpitu nawigacyjnego w imieniu jednostki usługi. W przypadku tego tokenu serwer wywołuje punkt końcowy interfejsu /tokeninfo API, punkt końcowy OpenID Connect (OIDC), który zwraca podstawowe informacje o profilu użytkownika, w tym external_value wartości i external_viewer_id . Te wartości umożliwiają skojarzenie żądań z poszczególnymi użytkownikami.

Przy użyciu tokenu uzyskanego z jednostki usługi serwer generuje nowy token o określonym zakresie dla określonego użytkownika, który uzyskuje dostęp do pulpitu nawigacyjnego. Ten token o zakresie użytkownika jest przekazywany do strony aplikacji, na której aplikacja tworzy wystąpienie DatabricksDashboard obiektu z @databricks/aibi-client biblioteki. Token zawiera informacje specyficzne dla użytkownika, które obsługują inspekcję i wymusza filtrowanie, dzięki czemu każdy użytkownik widzi tylko dane, do których mają uprawnienia dostępu. Z perspektywy użytkownika logowanie się do aplikacji automatycznie zapewnia dostęp do osadzonego pulpitu nawigacyjnego z prawidłową widocznością danych.

Zagadnienia dotyczące limitów szybkości i wydajności

Osadzanie zewnętrzne ma limit szybkości wynoszący 20 obciążeń pulpitu nawigacyjnego na sekundę. Jednocześnie można otworzyć więcej niż 20 pulpitów nawigacyjnych, ale nie więcej niż 20 może jednocześnie rozpocząć ładowanie.

Wymagania wstępne

Aby zaimplementować osadzanie zewnętrzne, upewnij się, że spełnisz następujące wymagania wstępne:

• Musisz mieć co najmniej uprawnienia CAN MANAGE na opublikowanym pulpicie nawigacyjnym. Zobacz Samouczek: używanie przykładowych pulpitów nawigacyjnych do szybkiego tworzenia i publikowania przykładowego pulpitu nawigacyjnego w razie potrzeby.
• Musisz mieć zainstalowany interfejs wiersza polecenia usługi Databricks w wersji 0.205 lub nowszej. Aby uzyskać instrukcje, zobacz Instalowanie lub aktualizowanie interfejsu wiersza polecenia usługi Databricks . Aby skonfigurować uwierzytelnianie OAuth i korzystać z niego, zobacz Uwierzytelnianie użytkownika-komputer (U2M) protokołu OAuth.
• Administrator obszaru roboczego musi zdefiniować listę zatwierdzonych domen, które mogą hostować osadzony pulpit nawigacyjny. Aby uzyskać instrukcje, zobacz Zarządzanie osadzaniem pulpitu nawigacyjnego .
• Zewnętrzna aplikacja do hostowania osadzonego pulpitu nawigacyjnego. Możesz użyć własnej aplikacji lub użyć dostarczonych przykładowych aplikacji.

Krok 1. Tworzenie jednostki usługi

Utwórz jednostkę usługi, która będzie pełnić rolę tożsamości dla aplikacji zewnętrznej w usłudze Azure Databricks. Ta jednostka usługi uwierzytelnia żądania w imieniu aplikacji.

Aby utworzyć jednostkę usługi:

1. Jako administrator obszaru roboczego zaloguj się do obszaru roboczego usługi Azure Databricks.
2. Kliknij swoją nazwę użytkownika na górnym pasku obszaru roboczego usługi Azure Databricks i wybierz pozycję Ustawienia.
3. Kliknij pozycję Tożsamość i dostęp w okienku po lewej stronie.
4. Obok Service principals, kliknij Zarządzaj.
5. Kliknij pozycję Dodaj jednostkę usługi.
6. Kliknij pozycję Dodaj nowy.
7. Wprowadź opisową nazwę jednostki usługi.
8. Kliknij przycisk Dodaj.
9. Otwórz jednostkę usługi utworzoną na stronie listy Jednostki usługi . W razie potrzeby użyj pola Filtruj wpis tekstowy, aby wyszukać go według nazwy.
10. Na stronie Szczegóły jednostki usługi zapisz identyfikator aplikacji. Sprawdź, czy zaznaczono pola wyboru Dostęp do usługi SQL usługi Databricks i Dostęp do obszaru roboczego .

Krok 2. Tworzenie wpisu tajnego OAuth

Wygeneruj wpis tajny dla jednostki usługi i zbierz następujące wartości konfiguracji, które będą potrzebne dla aplikacji zewnętrznej:

• Identyfikator jednostki usługi (klienta)
• Tajemnica klienta

Jednostka usługi używa wpisu tajnego OAuth, aby zweryfikować jego tożsamość podczas żądania tokenu dostępu z aplikacji zewnętrznej.

Aby wygenerować wpis tajny:

1. Kliknij pozycję Wpisy tajne na stronie Szczegóły jednostki usługi .
2. Kliknij pozycję Generuj wpis tajny.
3. Wprowadź wartość okresu istnienia nowego wpisu tajnego w dniach (np. od 1 do 730 dni).
4. Skopiuj wpis tajny natychmiast. Nie można ponownie wyświetlić tego wpisu tajnego po opuszczeniu tego ekranu.

Krok 3. Przypisywanie uprawnień do jednostki usługi

Utworzona jednostka usługi działa jako tożsamość, która zapewnia dostęp do pulpitu nawigacyjnego za pośrednictwem aplikacji. Jego uprawnienia mają zastosowanie tylko wtedy, gdy pulpit nawigacyjny nie jest publikowany z uprawnieniami do udostępnionych danych. Jeśli są używane uprawnienia do danych udostępnionych, dane są dostępne dzięki poświadczeniom wydawcy. Aby uzyskać więcej informacji i zaleceń, zobacz Metody osadzania uwierzytelniania.

1. Kliknij pozycję Pulpity nawigacyjne na pasku bocznym obszaru roboczego, aby otworzyć stronę listy pulpitu nawigacyjnego.
2. Kliknij nazwę pulpitu nawigacyjnego, który chcesz osadzić. Zostanie otwarty opublikowany pulpit nawigacyjny.
3. Kliknij pozycję Share (Udostępnij).
4. Użyj pola wprowadzania tekstu w oknie dialogowym Udostępnianie , aby znaleźć jednostkę usługi, a następnie kliknij ją. Ustaw poziom uprawnień na WARTOŚĆ CAN RUN. Następnie kliknij przycisk Dodaj.
5. Zarejestruj identyfikator pulpitu nawigacyjnego. Identyfikator pulpitu nawigacyjnego można znaleźć w adresie URL pulpitu nawigacyjnego (np. https://<your-workspace-url>/dashboards/<dashboard-id>). Zobacz Szczegóły obszaru roboczego usługi Databricks.

Uwaga / Notatka

Jeśli publikujesz panel z indywidualnymi uprawnieniami do danych, musisz przyznać głównej jednostce usługi dostęp do danych używanych na panelu. Dostęp obliczeniowy zawsze używa poświadczeń wydawcy, więc nie trzeba udzielać uprawnień obliczeniowych jednostce usługi.

Aby odczytywać i wyświetlać dane, jednostka usługi musi mieć co najmniej SELECT uprawnienia do tabel i widoków, do których odwołuje się pulpit nawigacyjny. Zobacz Kto może zarządzać uprawnieniami?.

Krok 4. Używanie przykładowej aplikacji do uwierzytelniania i generowania tokenów

Użyj przykładowej aplikacji, aby przećwiczyć osadzanie zewnętrzne pulpitu nawigacyjnego. Aplikacje zawierają instrukcje i kod, który inicjuje niezbędną wymianę tokenów w celu wygenerowania tokenów o określonym zakresie. Następujące bloki kodu nie mają zależności. Skopiuj i zapisz jedną z następujących aplikacji.

Python

Skopiuj i zapisz go w pliku o nazwie 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

Skopiuj i zapisz go w pliku o nazwie 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>`;
}

Krok 5. Uruchamianie przykładowej aplikacji

Zastąp następujące wartości, a następnie uruchom blok kodu z terminalu. Wartości nie powinny być ujęte w nawiasy kątowe (< >):

• Użyj adresu URL obszaru roboczego , aby znaleźć i zastąpić następujące wartości:
  • <your-instance>
  • <workspace_id>
  • <dashboard_id>
• Zastąp następujące wartości wartościami utworzonymi podczas tworzenia jednostki usługi (krok 2):
  • <service_principal_id>
  • <service_principal_secret> (klucz tajny klienta)
• Zastąp następujące wartości identyfikatorami skojarzonymi z użytkownikami aplikacji zewnętrznej:
  • <some-external-viewer>
  • <some-external-value>
• Zastąp </path/to/example> ciąg ścieżką do .py pliku lub .js utworzonego w poprzednim kroku. Dołącz rozszerzenie pliku.

Uwaga / Notatka

Nie należy uwzględniać żadnych danych osobowych (PII) w EXTERNAL_VIEWER_ID wartości.

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