Megosztás:

Engedélyezés konfigurálása Databricks-alkalmazásokban

A Databricks Apps támogatja a biztonságos alkalmazásfejlesztést az Azure Databricksben. Mivel az alkalmazások hozzáférnek a munkaterületen belüli adatokhoz és szolgáltatásokhoz, olyan hitelesítési és engedélyezési mechanizmusokat kell használniuk, amelyek kényszerítik az adathozzáférési vezérlőket, és tiszteletben tartják a felhasználói engedélyeket. A Databricks Apps engedélyezési modellje az OAuth 2.0-n alapul, és egyesíti az alkalmazáshoz rendelt engedélyeket a hozzá hozzáférő felhasználók engedélyeivel.

A keretrendszer támogatásához a Databricks Apps két kiegészítő identitásmodellt használ:

Alkalmazás-engedélyezés

Minden Azure Databricks-alkalmazás rendelkezik egy dedikált szolgáltatásnévvel , amely identitásként működik az Azure Databricks-erőforrások elérésekor. Ez a szolgáltatásnév egyedi az alkalmazáspéldány számára, és nem használható újra az alkalmazások között. Az alkalmazás létrehozásakor nem módosíthatja az alkalmazáshoz rendelt szolgáltatásnevet, és nem adhat meg meglévő szolgáltatásnevet. Az Azure Databricks ezzel az identitással értékeli ki az alkalmazás engedélyeit a felhasználóktól függetlenül, ami biztosítja, hogy az alkalmazás csak a kifejezetten neki biztosított erőforrásokhoz férhessen hozzá, még a felhasználói interakciók környezetén kívül is.

Ez az elkülönítés segít kikényszeríteni a biztonsági határokat, ami lehetővé teszi az alkalmazástevékenységek naplózását, és támogatja az olyan forgatókönyveket, mint a háttérfeldolgozás vagy az automatizált feladatok.

A szolgáltatási főképviselőt egyedi azonosító jelöli. Másolja ki az alkalmazás Engedélyezési lapjáról:

Szolgáltatási fiók megtekintése egy Databricks alkalmazásban

Alkalmazás létrehozásakor az Azure Databricks automatikusan kiépít egy dedikált szolgáltatásnevet az alkalmazáshoz. A szolgáltatásnév az alkalmazás összes központi telepítése esetén ugyanaz marad. Az alkalmazás törlésekor az Azure Databricks törli a szolgáltatásnevet.

Használja a szolgáltatásnevet olyan műveletekhez, amelyeket az alkalmazás önállóan hajt végre anélkül, hogy egy adott felhasználó kontextusát kellene megkövetelnie. Gyakori használati esetek a következők:

  • Háttérfeladatok futtatása
  • Megosztott konfiguráció vagy metaadatok olvasása vagy írása
  • Naplózási tevékenység vagy használati metrikák
  • Külső szolgáltatások meghívása biztonságos végpontokon keresztül

Az alkalmazás által kezdeményezett műveletek a szolgáltatási jogosultságkezelő engedélyeit használják. Adjon hozzáférést a szolgáltatásnévnek adott erőforrásokhoz standard engedélyhozzárendelések használatával. Azonban nem támogatja a felhasználói szintű hozzáférés-vezérlést. Minden felhasználó, aki az alkalmazást használja, ugyanazokkal az engedélyekkel rendelkezik, amelyek a szolgáltatásnévhez vannak definiálva, ami megakadályozza, hogy az alkalmazás az egyéni felhasználói identitáson alapuló részletes szabályzatokat kényszerítsen ki.

Az alábbi példa bemutatja, hogyan kérdezi le az adatokat egy alkalmazás a szolgáltatás megbízott segítségével a Unity Catalogban.

Nézze meg, hogyan hitelesít egy szolgáltatásnévobjektum egy alkalmazásban

Ebben az esetben a szolgáltatási principalnak explicit hozzáférésre van szüksége mind az SQL adattárházhoz, mind a lekérdezéshez szükséges Unity Catalog táblához.

Ez a modell akkor működik jól, ha azt szeretné, hogy az alkalmazás minden felhasználója ugyanazokat az adatokat lássa, vagy ha az alkalmazás olyan megosztott műveleteket hajt végre, amelyek nem kapcsolódnak a felhasználóspecifikus hozzáférés-vezérlőkhöz.

Alkalmazásengedélyezési hitelesítő adatok lekérése

Az alkalmazások engedélyezéséhez az Azure Databricks automatikusan injektálja a szolgáltatásnév hitelesítő adatait az alkalmazás környezetébe. A következő környezeti változók rendelkeznek a szükséges OAuth-ügyfélértékekkel:

Variable Description
DATABRICKS_CLIENT_ID Szolgáltatási főösszetevő OAuth-ügyfélazonosítója
DATABRICKS_CLIENT_SECRET Szolgáltatási főazonosító OAuth ügyfél titka

Az Azure Databricks automatikusan beállítja a környezeti változókat az alkalmazás futtatókörnyezetében. Az alkalmazás ezeket a változókat használja, amikor saját maga hitelesíti magát.

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;

Note

A Databricks SDK-k használata esetén általában nem kell manuálisan hozzáférnie ezekhez a környezeti változókhoz. Az SDK-k egységes hitelesítést követnek, és automatikusan észlelik a hitelesítő adatokat a környezetben.

Példa: Lekérdezés alkalmazás-engedélyezéssel

Python

Ez a példa az SDK Config objektumot használja, amely lekéri a szolgáltatásnév hitelesítő adatait a környezeti változókból, és OAuth-hitelesítést hajt végre.

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

Ez a példa környezeti változókat használ a szolgáltatási főpéldány hitelesítésére az OAuth segítségével, és lekérdezést futtat a Databricks SQL-illesztőprogrammal 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();

Felhasználói engedélyezés

Important

A felhasználói engedélyezés nyilvános előzetes verzióban érhető el.

A felhasználói engedélyezés, más néven a felhasználó nevében történő engedélyezés lehetővé teszi, hogy a Databricks Apps-alkalmazások az alkalmazás felhasználójának identitásával működjenek. Az Azure Databricks továbbítja a felhasználó hozzáférési jogkivonatát az alkalmazásnak, amely a jogkivonat használatával fér hozzá a felhasználó nevében lévő erőforrásokhoz. Az Azure Databricks a felhasználó meglévő Unity Catalog-szabályzatai alapján kikényszeríti az összes engedélyt.

A felhasználó nevében eljáró alkalmazások biztonsági kockázatainak kezelése érdekében az Azure Databricks hatókörökkel korlátozza, hogy az alkalmazás milyen műveleteket hajthat végre a felhasználói engedélyezéssel.

Felhasználói engedélyezés alkalmazása, ha az alkalmazásnak tiszteletben kell tartania az egyes felhasználói engedélyeket. A tipikus használati esetek a következők:

  • Táblák vagy kötetek lekérdezése
  • SQL-raktárak vagy számítási feladatok elérése
  • Felhasználói műveletekhez kapcsolódó feladatok vagy munkafolyamatok futtatása

Minden művelet a felhasználó meglévő Unity Catalog-engedélyeit használja:

Annak megtekintése, hogy egy felhasználó hogyan hitelesít egy alkalmazásban

A felhasználói engedélyezés lehetővé teszi a részletes hozzáférés-vezérlést a Unity Catalog olyan funkcióival, mint a sorszintű szűrők és az oszlopmaszkok alkalmazása az alkalmazástevékenységekre. Ez a megközelítés összhangban tartja a hozzáférés-vezérlést a munkaterület szabályozásával, és elkerüli az engedélylogika korlátozását az alkalmazásba.

Részletes engedélyek felhasználói jogosultsággal

Amikor felhasználói engedélyt ad hozzá egy alkalmazáshoz, az kikényszeríti a felhasználó meglévő Unity Catalog-engedélyeit, többek között a következőket:

  • Sorszintű szűrők a látható sorok korlátozásához
  • Oszlopmaszkok a bizalmas adatok kitakarásához vagy átalakításához

Mivel az Azure Databricks a felhasználó identitásával értékeli ki a felhasználói engedélyezési kérelmeket, ezek a szabályzatok automatikusan érvényesek, amikor az alkalmazás hozzáfér az adatokhoz. Ha például egy tábla olyan sorszűrőt tartalmaz, amely régiónként korlátozza a láthatóságot, az alkalmazás csak azokat a sorokat adja vissza, amelyeket a felhasználó lekérdezhet. Az alkalmazásban nincs szükség további szűrési logikára.

Ez a megközelítés elkerüli a hozzáférés-vezérlési logika duplikálását az alkalmazáskódban, és biztosítja a munkaterületszintű szabályozással való konzisztenciát. Amikor a rendszergazdák frissítik a Unity Catalog szabályzatait, az alkalmazás automatikusan tiszteletben tartja ezeket a módosításokat.

Hatóköralapú biztonság és jogosultságok eszkalálása

A felhasználói hitelesítést használó alkalmazásoknak meghatározott engedélyezési hatóköröket kell deklarálniuk, hogy korlátozzák az alkalmazás által a felhasználó nevében elvégezhető műveleteket. A hatókörök bizonyos API-khoz vagy erőforrástípusokhoz, például a következőkhöz korlátozzák a hozzáférést:

  • sql SQL-raktárak lekérdezéséhez
  • dashboards.genie a Genie-tér kezeléséhez
  • files.files fájlok és könyvtárak kezeléséhez

Ha nem választ ki hatóköröket, az Azure Databricks egy alapértelmezett készletet rendel hozzá, amely lehetővé teszi az alkalmazás számára az alapvető felhasználói identitásadatok lekérését:

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

Ezek az alapértelmezett értékek a felhasználói engedélyezési funkciók támogatásához szükségesek, de nem teszik lehetővé az adatokhoz vagy számítási erőforrásokhoz való hozzáférést. További hatókörök hozzáadása az alkalmazás létrehozásakor vagy szerkesztésekor.

A hatókörök a minimális jogosultság elvét érvényesítik. Mindenképpen konfigurálja úgy az alkalmazást, hogy csak azokat a hatóköröket kérje le, amelyekre szüksége van. Az Azure Databricks letiltja a jóváhagyott hatókörön kívüli funkciókhoz való hozzáférést, még akkor is, ha a felhasználó rendelkezik engedéllyel. Ha például az alkalmazás csak a sql hatókört kéri le, akkor sem fér hozzá a végpontokat kiszolgáló modellhez, még akkor sem, ha a felhasználó az alkalmazáson kívülre is képes.

Amikor egy felhasználó először fér hozzá egy alkalmazáshoz, az Azure Databricks kéri, hogy explicit módon engedélyezze az alkalmazásnak a kért hatókörökben való működést. A hozzájárulás megadása után a felhasználók nem vonhatják vissza. A rendszergazdák opcionálisan hozzájárulást adhatnak a felhasználók nevében a hozzáférés szervezeti szabályzatokhoz való igazításához.

Hatókörök hozzáadása alkalmazáshoz

Important

A felhasználói engedélyezés nyilvános előzetes verzióban érhető el. A munkaterület rendszergazdáját engedélyeznie kell, mielőtt hatóköröket adhat hozzá az alkalmazáshoz.

A felhasználói engedélyezés engedélyezése után újra kell indítania a meglévő alkalmazásokat, mielőtt hatóköröket adhat hozzájuk. Ha letiltja a felhasználói engedélyezést, újra kell indítania a meglévő alkalmazásokat, hogy ne használják az aktuális felhasználó hozzáférési jogkivonatát az erőforrások eléréséhez.

Konfigurálja a felhasználói engedélyezést, amikor létrehoz vagy szerkeszt egy alkalmazást az Azure Databricks felhasználói felületén.

A Konfigurálás lépésben kattintson a +Hatókör hozzáadása elemre, és válassza ki azokat a hatóköröket, amelyek meghatározzák, hogy az alkalmazás mely Azure Databricks API-kat vagy erőforrásokat érheti el a felhasználó nevében. Az Azure Databricks futásidőben kikényszeríti ezeket a hatóköröket, és a hozzáférés megadása előtt felhasználói vagy rendszergazdai hozzájárulást igényel.

Felhasználói engedélyezési hatókörök hozzáadása Egy Databricks-alkalmazáshoz

Teljes példáért tekintse meg a Databricks Apps engedélyezési bemutatóját a GitHubon. A példaalkalmazás bemutatja, hogyan használhatja az alkalmazás- és a felhasználói engedélyezési modelleket, és bemutatja a beállítási utasításokat és a felhasználói engedélyekkel rendelkező példa lekérdezéseket.

Felhasználói engedélyezési hitelesítő adatok lekérése

A felhasználói engedélyezéshez az Azure Databricks HTTP-fejlécekben továbbítja a felhasználó identitását és hozzáférési jogkivonatát az alkalmazásnak. Az alkalmazásnak ki kell nyernie ezeket a fejléceket, hogy a felhasználó nevében járjon el.

A fejlécek lekérésének menete a használt keretrendszertől függ.

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")
    ...

A Gradio automatikusan injektálja a kérelemobjektumot az alkalmazás függvényébe, ha paraméterként deklarálja. Nem kell manuálisan létrehoznia vagy lekérnie a kérést.

Dash és Flask

from flask import request

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

Shiny

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

Expressz

import express from 'express';

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

Példa: Lekérdezés felhasználói engedéllyel

Ebben az esetben az alkalmazás közvetlenül az összekötőnek továbbítja a felhasználó hozzáférési jogkivonatát, és az Azure Databricks a felhasználó engedélyeit alkalmazza a lekérdezésre.

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,
    token: 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);

Ajánlott eljárások a felhasználói engedélyezéshez

Amikor olyan alkalmazásokat hoz létre, amelyek műveleteket hajtanak végre a felhasználók nevében, kövesse az alábbi ajánlott eljárásokat a biztonságos és naplózásra alkalmas hozzáférés biztosítása érdekében:

  • Az alkalmazáskódot csak az alkalmazás tulajdonosa vagy a megbízható felhasználók egy kis csoportja számára elérhető mappákban tárolhatja.
  • Csak megbízható, az alkalmazás karbantartásáért és felülvizsgálatáért felelős, magas szintű fejlesztőknek adjon CAN MANAGE engedélyeket. Csak adott felhasználóknak vagy csoportoknak adjon CAN USE engedélyeket az alkalmazás futtatásához.
  • Ügyeljen arra, hogy a tokenek ne kerüljenek nyomtatásra, naplózásra vagy fájlokba írásra. Ez az összes naplózási utasításra, hibakeresési eszközre és hibakezelőre vonatkozik. Például a print(f"User token: {token}") helyett headers = {"Authorization": f"Bearer {token}"} használata.
  • Konfiguráljon minden alkalmazást úgy, hogy csak a működéséhez szükséges minimális engedélyezési hatóköröket kérje le.
  • A kód áttekintése során ellenőrizze, hogy a hatókör- és engedélybeállítások összhangban vannak-e a biztonsági követelményekkel, és ne adjon-e szükségtelen hozzáférést.
  • Az éles környezetekben való üzembe helyezés előtt kényszerítse ki az összes alkalmazáskód társértékelését.
  • Győződjön meg arról, hogy az alkalmazáskód strukturált naplózási naplókat rögzít a felhasználók nevében végrehajtott minden művelethez, beleértve a felhasználói identitást, a művelet típusát, a célerőforrást és az állapotot.

Hitelesítési módszerek

A Databricks Apps-jogkivonatok beszerzéséhez a felhasználók és a szolgáltatásnevek is szabványos OAuth 2.0-folyamatokkal hitelesítik magukat. A módszer attól függ, hogy a hívó felhasználó vagy automatizált számítási feladat-e.

Munkaterület-bejelentkezés esetén (csak felhasználók esetén):

  • Egyszeri bejelentkezés (SSO): A felhasználók az identitásszolgáltatón keresztül hitelesítik magukat, ha az egyszeri bejelentkezés (SSO) konfigurálva van.
  • Egyszeri jelszó (OTP): A felhasználók ideiglenes jelszót kapnak, ha az egyszeri bejelentkezés nincs konfigurálva.

OAuth-folyamatokhoz (alkalmazásokhoz és számítási feladatokhoz):

  • Felhasználó–gép (U2M) OAuth: A felhasználók hitelesítik magukat, és az így kapott jogkivonatok engedélyezik a felhasználói engedélyezést, hogy az alkalmazás a felhasználó nevében járhasson el.
  • Gépről gépre (M2M) – OAuth: A szolgáltatás-főszereplők ügyfél-hitelesítési adatokkal vagy federációval hitelesíthetők. Ezek a tokenek támogatják az alkalmazás-engedélyezést, ahol az alkalmazás nem felhasználóként, hanem saját maga nevében működik.

A Databricks-alkalmazások jogkivonat-hitelesítéssel történő meghívásával kapcsolatos utasításokért lásd: Csatlakozás API Databricks-alkalmazáshoz jogkivonat-hitelesítéssel.

Modellek összehasonlítása és egyesítése

A Databricks Apps egymástól függetlenül vagy együtt használhatja az alkalmazás- és felhasználói engedélyezést. Ezek a modellek különböző célokat szolgálnak, és párhuzamos működésre vannak tervezve.

Engedélyezési modell Mikor érdemes használni? Példák az alkalmazási helyzetekre
Alkalmazás-engedélyezés Amikor az alkalmazás olyan műveleteket hajt végre, amelyek nem függnek a felhasználó identitásától Naplók írása, megosztott konfiguráció elérése, külső szolgáltatások meghívása
Felhasználói engedélyezés Amikor az alkalmazásnak az aktuális felhasználó környezetében kell hozzáférnie az erőforrásokhoz Unity Catalog-adatok lekérdezése, számítás indítása, sorszintű engedélyek kikényszerítése
Both Amikor az alkalmazás megosztott és felhasználóspecifikus műveleteket is végrehajt Metrikák naplózása alkalmazás-identitással, szűrt adatok lekérdezése felhasználói identitással
  • Last updated on