Konfigurera auktorisering i en Databricks-app

Databricks Apps stöder säker programutveckling i Azure Databricks. När appar får åtkomst till data och tjänster på en arbetsyta måste de använda autentiserings- och auktoriseringsmekanismer som framtvingar dataåtkomstkontroller och respekterar användarbehörigheter. Databricks Apps-auktoriseringsmodellen baseras på OAuth 2.0 och kombinerar de behörigheter som tilldelats appen med behörigheterna för användaren som kommer åt den.

För att stödja det här ramverket använder Databricks Apps två kompletterande identitetsmodeller:

• Appauktorisering ger appen en egen identitet med en konsekvent uppsättning behörigheter.
• Med användarauktorisering kan appen använda identiteten och behörigheterna för användaren som interagerar med den.

Dessa modeller ger utvecklare detaljerad kontroll över vad appen kan komma åt och vars behörigheter den använder. En app kan till exempel använda appauktorisering för att skriva loggar eller läsa delad konfiguration. Den kan sedan använda användarauktorisering för att fråga efter data med användarens behörigheter, vilket Unity Catalog tillämpar via principer som filtrering på radnivå eller kolumnnivå.

Appauktorisering

Varje Azure Databricks-app har ett dedikerat huvudnamn för tjänsten som fungerar som identitet när den får åtkomst till Azure Databricks-resurser. Tjänstens huvudnamn är unikt för appinstansen och kan inte återanvändas mellan appar. Azure Databricks använder den här identiteten för att utvärdera appens behörigheter oberoende av alla användare, vilket säkerställer att appen endast kan komma åt resurser som uttryckligen beviljas den, även utanför kontexten för användarinteraktion.

Den här separationen hjälper till att framtvinga säkerhetsgränser, vilket möjliggör granskning av appaktivitet och stöder scenarier som bakgrundsbearbetning eller automatiserade uppgifter.

Tjänsthuvudmannen representeras av ett unikt ID. Du kan kopiera den från appens auktoriseringsflik :

När du skapar en app skapar Azure Databricks automatiskt ett dedikerat huvudnamn för tjänsten och tilldelar det till appen. Använd tjänstens huvudnamn för åtgärder som appen utför på egen hand, utan att kräva kontexten för en enskild användare. Vanliga användningsfall är:

• Köra bakgrundsaktiviteter
• Läsa eller skriva delad konfiguration eller metadata
• Loggningsaktivitet eller användningsstatistik
• Anropa externa tjänster via säkra slutpunkter

Alla åtgärder som initieras av appen använder tjänstens huvudnamns behörigheter. Du kan ge tjänstens huvudkonto åtkomst till specifika resurser med hjälp av standardbehörighetstilldelningar. Den stöder dock inte åtkomstkontroll på användarnivå. Alla användare som interagerar med appen har samma behörigheter som definierats för tjänstens huvudnamn, vilket hindrar appen från att tillämpa detaljerade principer baserat på enskilda användaridentiteter.

I följande exempel visas hur en app använder tjänstens huvudnamn för att fråga efter data i Unity Catalog:

I det här fallet behöver tjänstens huvudkonto explicit åtkomst till både SQL-lagret och Unity Catalog-tabellen som den gör en förfrågan på.

Den här modellen fungerar bra när du vill att alla användare av appen ska se samma data eller när appen utför delade åtgärder som inte är knutna till användarspecifika åtkomstkontroller.

Användarauktorisering

Viktigt!

Användarauktorisering finns i offentlig förhandsversion.

Med användarauktorisering, som ibland kallas auktorisering för användarens räkning, kan en Databricks Apps-app agera med appanvändarens identitet. Azure Databricks vidarebefordrar användarens åtkomsttoken till appen, som använder token för att komma åt resurser för användarens räkning. Azure Databricks tillämpar alla behörigheter baserat på användarens befintliga Unity Catalog-principer .

För att hantera säkerhetsriskerna för appar som agerar för en användares räkning använder Databricks omfång för att begränsa vilka åtgärder en app kan utföra via användarauktorisering.

Använd användarauktorisering när appen behöver respektera enskilda användarbehörigheter. Vanliga användningsfall är:

• Ställa frågor till tabeller eller volymer
• Åtkomst till SQL-lager eller beräkning
• Köra jobb eller arbetsflöden som är knutna till användaråtgärder

Alla åtgärder använder användarens befintliga Behörigheter för Unity-katalogen:

Användarauktorisering möjliggör detaljerad åtkomstkontroll genom att använda Unity Catalog-funktioner som filter på radnivå och kolumnmasker för appaktivitet. Den här metoden håller åtkomstkontroll konsekvent med styrning av arbetsytor och undviker hårdkodning av behörighetslogik i appen.

Välj en auktoriseringsmodell

Databricks Apps kan använda app- och användarauktorisering oberoende eller tillsammans. Dessa modeller har olika syften och är utformade för att fungera parallellt.

Använd appauktorisering när appen utför åtgärder som inte är beroende av användarens identitet. Detta omfattar att skriva loggar, komma åt delad konfiguration eller anropa externa tjänster.

Använd användarauktorisering när appen behöver komma åt resurser i kontexten för användaren, till exempel genom att fråga efter data som styrs av Unity Catalog eller starta beräkning för användarens räkning.

Många appar kombinerar båda modellerna. En app kan till exempel använda tjänstens huvudnamn för att skriva användningsstatistik till en loggningstabell, samtidigt som användarens auktorisering används för att köra SQL-frågor som returnerar användarspecifika resultat baserat på åtkomstkontroller på radnivå.

Implementera auktorisering i appar

Om du vill använda app- eller användarauktorisering i Databricks-appar konfigurerar du rätt identitet och skickar rätt autentiseringsuppgifter när du gör begäranden till Azure Databricks-tjänster.

Hämta autentiseringsuppgifter för appauktorisering

För appauktorisering matar Azure Databricks automatiskt in autentiseringsuppgifter för tjänstens huvudnamn i appens miljö. Följande miljövariabler innehåller nödvändiga OAuth-klientvärden:

Variabel	Beskrivning
DATABRICKS_CLIENT_ID	OAuth-klient-ID för tjänstens huvudnamn
DATABRICKS_CLIENT_SECRET	OAuth-klienthemlighet för tjänstens huvudnamn

Azure Databricks anger miljövariablerna automatiskt i appkörningen. Appen använder dessa variabler när den autentiseras som sig själv.

python

import os

client_id = os.getenv('DATABRICKS_CLIENT_ID')
client_secret = os.getenv('DATABRICKS_CLIENT_SECRET')

JavaScript

const clientId = process.env.DATABRICKS_CLIENT_ID;
const clientSecret = process.env.DATABRICKS_CLIENT_SECRET;

Anmärkning

Om du använder Databricks SDK:er behöver du vanligtvis inte komma åt dessa miljövariabler manuellt. SDK:erna följer enhetlig autentisering och identifierar automatiskt autentiseringsuppgifter i miljön.

Exempel: Fråga med appauktorisering

python

I det här exemplet används SDK Config-objektet, som hämtar autentiseringsuppgifter för tjänstens huvudnamn från miljövariabler och utför OAuth-auktorisering.

from databricks import sql
from databricks.sdk.core import Config

cfg = Config()

conn = sql.connect(
    server_hostname=cfg.host,
    http_path="<your-warehouse-http-path>",
    credentials_provider=lambda: cfg.authenticate,
)

query = "SELECT * FROM main.sandbox.sales_customers LIMIT 1000"

with conn.cursor() as cursor:
    cursor.execute(query)
    df = cursor.fetchall_arrow().to_pandas()
    print(df.head())

conn.close()

JavaScript

I det här exemplet används miljövariabler för att autentisera med ett huvudnamn för tjänsten med OAuth och köra en fråga med Databricks SQL-drivrutinen för Node.js.

import { DBSQLClient } from '@databricks/sql';

const client = new DBSQLClient();

const connection = await client.connect({
  authType: 'databricks-oauth',
  host: process.env.DATABRICKS_SERVER_HOSTNAME,
  path: process.env.DATABRICKS_HTTP_PATH,
  oauthClientId: process.env.DATABRICKS_CLIENT_ID,
  oauthClientSecret: process.env.DATABRICKS_CLIENT_SECRET,
});

const query = 'SELECT * FROM main.sandbox.sales_customers LIMIT 1000';
const cursor = await connection.cursor(query);

const rows = [];
for await (const row of cursor) {
  rows.push(row);
}

console.log(rows.slice(0, 5)); // Like df.head()

await connection.close();

Hämta autentiseringsuppgifter för användarauktorisering

För användarauktorisering vidarebefordrar Azure Databricks användarens identitets- och åtkomsttoken till appen i HTTP-huvuden. Appen måste extrahera dessa rubriker för att fungera för användarens räkning.

Hur du hämtar dessa rubriker beror på vilket ramverk du använder.

Streamlit

import streamlit as st
user_access_token = st.context.headers.get('x-forwarded-access-token')

Gradio

import gradio as gr

def query_fn(message, history, request: gr.Request):
    access_token = request.headers.get("x-forwarded-access-token")
    ...

Gradio matar automatiskt in begärandeobjektet i appens funktion om du deklarerar det som en parameter. Du behöver inte konstruera eller hämta begäran manuellt.

Streck och Flask

from flask import request

headers = request.headers
user_token = headers.get('x-forwarded-access-token')

Skinande

user_token = session.http_conn.headers.get('x-forwarded-access-token')

Uttrycka

import express from 'express';

const userAccessToken = req.header('x-forwarded-access-token');

Exempel: Fråga med användarauktorisering

I det här fallet skickar appen användarens åtkomsttoken direkt till anslutningsappen och Azure Databricks tillämpar användarens behörigheter på frågan.

python

from databricks import sql
from databricks.sdk.core import Config
from flask import request

cfg = Config()
user_token = request.headers.get("x-forwarded-access-token")

conn = sql.connect(
    server_hostname=cfg.host,
    http_path="<your-warehouse-http-path>",
    access_token=user_token
)

query = "SELECT * FROM main.sandbox.sales_customers LIMIT 1000"

with conn.cursor() as cursor:
    cursor.execute(query)
    df = cursor.fetchall_arrow().to_pandas()
    print(df.head())

conn.close()

JavaScript

import { DBSQLClient } from '@databricks/sql';
import express from 'express';

const app = express();

app.get('/', async (req, res) => {
  const userToken = req.header('x-forwarded-access-token');

  const client = new DBSQLClient();
  const connection = await client.connect({
    authType: 'access-token',
    host: process.env.DATABRICKS_SERVER_HOSTNAME,
    path: process.env.DATABRICKS_HTTP_PATH,
    accessToken: userToken,
  });

  const query = 'SELECT * FROM main.sandbox.sales_customers LIMIT 1000';
  const cursor = await connection.cursor(query);

  const rows = [];
  for await (const row of cursor) {
    rows.push(row);
  }

  console.log(rows.slice(0, 5));
  await connection.close();

  res.send('Query complete');
});

app.listen(3000);

Detaljerade behörigheter med användarauktorisering

När du lägger till användarauktorisering i en app, efterlevs användarens befintliga Unity Catalog-behörigheter, inklusive:

• Filter på radnivå för att begränsa synliga rader
• Kolumnmasker för att redigera eller transformera känsliga data

Eftersom Azure Databricks utvärderar begäranden om användarauktorisering med användarens identitet tillämpas dessa principer automatiskt när appen kommer åt data. Om en tabell till exempel innehåller ett radfilter som begränsar synligheten efter region returnerar appen bara de rader som användaren får köra frågor mot. Ingen ytterligare filtreringslogik behövs i appen.

Den här metoden undviker duplicering av åtkomstkontrolllogik i programkod och säkerställer konsekvens med styrning på arbetsytenivå. När administratörer uppdaterar Unity Catalog-principer respekterar appen automatiskt dessa ändringar. Detta minskar risken för dataexponering från inaktuell eller feljusterad behörighetslogik.

Omfattningsbaserad säkerhets- och behörighetseskalering

Appar som använder användarauktorisering måste deklarera specifika auktoriseringsomfång för att styra vad appen kan göra för användarens räkning. Omfång begränsar åtkomsten till specifika API:er eller resurstyper, till exempel:

• sql för att köra frågor mot SQL-lager
• dashboards.genie för att hantera ditt Genie-utrymme
• files.files för att hantera filer och kataloger

Om du inte väljer några omfång tilldelar Azure Databricks en standarduppsättning som gör att appen kan hämta grundläggande användaridentitetsinformation:

• iam.access-control:read
• iam.current-user:read

Dessa standardvärden krävs för att stödja funktioner för användarauktorisering, men de tillåter inte åtkomst till data eller beräkningsresurser. Du kan lägga till ytterligare omfång när du skapar eller redigerar appen.

Omfång framtvingar principen om lägsta behörighet. Se till att konfigurera appen så att den endast begär de omfång som den behöver. Azure Databricks blockerar åtkomst till alla funktioner utanför de godkända omfången, även om användaren har behörighet. Om appen till exempel endast begär omfånget sql kan den inte komma åt modellbetjänande slutpunkter, även om användaren skulle kunna utanför appen.

När en användare först får åtkomst till en app uppmanar Azure Databricks dem att uttryckligen auktorisera appen att agera inom de begärda omfången. Administratörer kan också bevilja medgivande åt användare för att anpassa åtkomsten till organisationens principer.

Konfigurera användarauktorisering i din app

Viktigt!

Användarauktorisering finns i offentlig förhandsversion. Administratören för din arbetsyta måste aktivt möjliggöra det innan du kan lägga till behörigheter i din app.

Du kan konfigurera användarauktorisering när du skapar eller redigerar en app i Azure Databricks-användargränssnittet.

I steget Konfigurera klickar du på +Lägg till omfång och väljer de omfång som definierar vilka Azure Databricks-API:er eller resurser som appen kan komma åt för användarens räkning. Azure Databricks tillämpar dessa omfång vid körning och kräver användar- eller administratörsmedgivande innan åtkomst beviljas.

Ett fullständigt exempel finns i auktoriseringsdemon för Databricks Apps på GitHub. Exempelappen visar hur du använder både app- och användarauktoriseringsmodeller och innehåller installationsinstruktioner och exempelfrågor med användarauktorisering.