Ansluta en anpassad Databricks-app till Lakebase

Viktigt!

Autoskalning av Lakebase är tillgängligt i följande regioner: eastus, eastus2, centralus, southcentralus, westus, westus2, canadacentral, brazilsouth, northeurope, uksouth, westeurope, australiaeast, centralindia, southeastasia.

Lakebase Autoscaling är den senaste versionen av Lakebase, med automatisk skalningsberäkning, skalning till noll, förgrening och omedelbar återställning. Om du är en Lakebase Provisioned-användare kan du läsa Lakebase Provisioned.

Den här självstudien visar hur du ansluter en Databricks-app till Lakebase Autoscaling med automatisk rotation av autentiseringsuppgifter. Appen genererar nya databasautentiseringsuppgifter från Databricks innan de upphör att gälla. Exemplet använder Flask, men autentiseringsmönstret gäller för alla ramverk.

Så här fungerar det

Databricks-appar autentiseras till Lakebase med OAuth-token som upphör att gälla efter en timme. För att hantera detta skapar du en Postgres-roll för appens tjänsthuvudnamn och konfigurerar sedan appen så att den automatiskt genererar nya token när den behöver ansluta till databasen. Detta sker via ett mönster för anslutningspoolen: poolen skapar nya anslutningar med nya token efter behov, så att appen aldrig använder utgångna autentiseringsuppgifter.

När du distribuerar appen till Databricks körs den som en servicereferens och genererar tokens för den identiteten. När du testar lokalt körs appen som ditt Databricks-användarkonto och genererar token åt dig. Båda använder samma tokenroteringskod: endast autentiseringskontexten ändras.

Innan du börjar

För att slutföra denna handledning behöver du:

• Åtkomst till en Databricks-arbetsyta med Lakebase Postgres Autoscaling aktiverat (kontakta din arbetsyteadministratör om du inte ser Lakebase i appväxlaren)
• Behörighet att skapa Databricks-appar
• Grundläggande kunskaper om Python och SQL
• Databricks CLI installerat för lokal utveckling
• Python 3.9 eller senare installerat lokalt

Steg 1: Skapa din app och databas

Skapa först både en Databricks-app och ett Lakebase-projekt. Appen hämtar automatiskt en identitet för tjänstens huvudnamn som du ska använda för databasautentisering.

Skapa appen

Skapa en ny Databricks-app med hjälp av Flask Hello World-mallen (+ Ny > app på din arbetsyta). Detaljerade instruktioner finns i Skapa en Databricks-app.

Efter installationen går du till appens miljöflik och noterar DATABRICKS_CLIENT_ID värdet (UUID-format som 6b215d2b-f099-4bdb-900a-60837201ecec). Detta blir appens Postgres-användarnamn för OAuth-autentisering.

Anmärkning

Distribuera inte appen ännu – du konfigurerar databasanslutningen först.

Skapa databasen

Skapa ett nytt Lakebase Autoscaling-projekt som värd för databasen. Klicka på Appar i det övre högra hörnet väljer Lakebase och skapar sedan ett nytt projekt med önskat namn (till exempel my-app-db) och Postgres-versionen (acceptera standardversionen av Postgres 17). Fullständig konfigurationsinformation finns i Skapa ett projekt.

Vänta tills beräkningen blir aktiv (cirka 1 minut) innan du fortsätter.

Steg 2: Konfigurera databasautentisering och schema

Skapa en Postgres-roll för appens tjänsthuvudnamn med OAuth-autentisering och skapa sedan en exempeltabell med data som appen ska visa.

Konfigurera OAuth-autentisering

I ditt Lakebase-projekt öppnar du SQL-redigeraren och kör dessa kommandon. Tillägget databricks_auth möjliggör OAuth-autentisering, vilket gör att dina Postgres-roller kan acceptera Databricks-token i stället för traditionella lösenord:

-- Enable the Databricks authentication extension
CREATE EXTENSION IF NOT EXISTS databricks_auth;

-- Create a Postgres role for your app's service principal
-- Replace the UUID below with your DATABRICKS_CLIENT_ID from Step 1
SELECT databricks_create_role('<DATABRICKS_CLIENT_ID>', 'service_principal');

-- Grant necessary permissions (use the same DATABRICKS_CLIENT_ID)
GRANT CONNECT ON DATABASE databricks_postgres TO "<DATABRICKS_CLIENT_ID>";
GRANT CREATE, USAGE ON SCHEMA public TO "<DATABRICKS_CLIENT_ID>";

Ersätt <DATABRICKS_CLIENT_ID> med appens DATABRICKS_CLIENT_ID värde. Tjänstens huvudnamn kan nu autentisera med OAuth-token som Databricks hanterar automatiskt. Mer information finns i Skapa en OAuth-roll för en Databricks-identitet.

Skapa databasschema

Skapa en exempeltabell med explicita behörigheter för tjänstens huvudnamn (tjänstens huvudnamn ärver inte standardschemabehörigheter):

-- Create a sample table
CREATE TABLE notes (
    id SERIAL PRIMARY KEY,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Grant permissions to your app's service principal (use your DATABRICKS_CLIENT_ID)
GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE notes TO "<DATABRICKS_CLIENT_ID>";

-- Insert sample data
INSERT INTO notes (content) VALUES
   ('Welcome to Lakebase Autoscaling!'),
   ('This app connects to Postgres'),
   ('Data fetched from your database');

Ersätt <DATABRICKS_CLIENT_ID> med ditt DATABRICKS_CLIENT_ID värde.

Steg 3: Skapa och konfigurera ditt program

Ladda ned dina appfiler, konfigurera databasanslutningen med automatisk OAuth-tokenrotation och testa lokalt innan du distribuerar.

Ladda ned och konfigurera appfiler

Ladda ned dina appfiler från arbetsytan genom att kopiera exportkommandot från avsnittet Synkronisera filer i appen:

databricks workspace export-dir /Workspace/Users/<your-email>/databricks_apps/<app-folder>/flask-hello-world-app .

Redigera app.yaml för att lägga till information om databasanslutning. Hämta dina anslutningsvärden från Lakebase Connect-modalen genom att endast välja Parametrar:

command: ['flask', '--app', 'app.py', 'run', '--host', '0.0.0.0', '--port', '8000']

env:
  - name: PGHOST
    value: '<your-endpoint-hostname>'
  - name: PGDATABASE
    value: 'databricks_postgres'
  - name: PGUSER
    value: '<DATABRICKS_CLIENT_ID>'
  - name: PGPORT
    value: '5432'
  - name: PGSSLMODE
    value: 'require'
  - name: ENDPOINT_NAME
    value: 'projects/<project-id>/branches/<branch-id>/endpoints/<endpoint-id>'

Ersätt platshållarna:

• <your-endpoint-hostname>: Kopiera PGHOST-värdet från anslutningsmodalen (till exempel ep-xyz.database.us-west-2.dev.databricks.com)
• <DATABRICKS_CLIENT_ID>: Använd din DATABRICKS_CLIENT_ID från steg 1
• projects/<project-id>/branches/<branch-id>/endpoints/<endpoint-id>: Kör databricks postgres list-endpoints och kopiera name fältvärdet (format: projects/<uuid>/branches/<uuid>/endpoints/<id>)

Implementera OAuth-tokenrotation och databasfråga

Ersätt app.py med den här koden. Detta implementerar två viktiga ändringar: automatisk OAuth-tokenrotation för autentisering och en databasfråga som hämtar och visar anteckningarna som du skapade i steg 2:

import os
from databricks.sdk import WorkspaceClient
import psycopg
from psycopg_pool import ConnectionPool
from flask import Flask

app = Flask(__name__)

# Initialize Databricks client for token generation
w = WorkspaceClient()

# Custom connection class that generates fresh OAuth tokens
class OAuthConnection(psycopg.Connection):
    @classmethod
    def connect(cls, conninfo='', **kwargs):
        # Generate a fresh OAuth token for each connection (tokens are workspace-scoped)
        endpoint_name = os.environ["ENDPOINT_NAME"]
        credential = w.postgres.generate_database_credential(endpoint=endpoint_name)
        kwargs['password'] = credential.token
        return super().connect(conninfo, **kwargs)

# Configure connection parameters
username = os.environ["PGUSER"]
host = os.environ["PGHOST"]
port = os.environ.get("PGPORT", "5432")
database = os.environ["PGDATABASE"]
sslmode = os.environ.get("PGSSLMODE", "require")

# Create connection pool with automatic token rotation
pool = ConnectionPool(
    conninfo=f"dbname={database} user={username} host={host} port={port} sslmode={sslmode}",
    connection_class=OAuthConnection,
    min_size=1,
    max_size=10,
    open=True
)

@app.route('/')
def hello_world():
    # Use connection from pool (automatically gets fresh token)
    with pool.connection() as conn:
        with conn.cursor() as cur:
            cur.execute("SELECT content, created_at FROM notes ORDER BY created_at DESC LIMIT 5")
            notes = cur.fetchall()

    # Display results
    notes_html = "<ul>" + "".join([f"<li>{note[0]} - {note[1]}</li>" for note in notes]) + "</ul>"
    return f'<h1>Hello from Lakebase!</h1><h2>Recent Notes:</h2>{notes_html}'

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=8000)

Den här koden implementerar automatisk rotation av databasautentiseringsuppgifter med hjälp av tre nyckelkomponenter:

• WorkspaceClient: Genererar nya databasautentiseringsuppgifter via Databricks SDK
• OAuthConnection-klass: Anpassad anslutningsklass som matar in en ny autentiseringsuppgift i varje ny anslutning
• ConnectionPool: Hanterar databasanslutningar och anropar den anpassade anslutningsklassen när du skapar anslutningar

Det här mönstret säkerställer att din app alltid har giltiga autentiseringsuppgifter för databasen. En detaljerad förklaring av hur rotation av autentiseringsuppgifter fungerar, olika rotationsstrategier och felhantering finns i Tokenrotation i Lakebase.

Uppdatera requirements.txt för att inkludera de paket som krävs:

flask
psycopg[binary,pool]
databricks-sdk>=0.81.0

Den minsta SDK-versionen (0.81.0) säkerställer att generate_database_credential() metoden är tillgänglig för generering av OAuth-token.

Testa lokalt

Testa appen lokalt för att verifiera att databasanslutningen fungerar innan du distribuerar den. När du testar lokalt körs appen som ditt Databricks-användarkonto (inte tjänstens huvudnamn), så du måste ändra PGUSER till din e-postadress i miljövariablerna nedan.

Autentisera till din arbetsyta och exportera miljövariabler:

databricks auth login

export PGHOST="<your-endpoint-hostname>"
export PGDATABASE="databricks_postgres"
export PGUSER="your.email@company.com"  # Use YOUR email for local testing, not the service principal
export PGPORT="5432"
export PGSSLMODE="require"
export ENDPOINT_NAME="<your-endpoint-name>"

Kopiera värdena från app.yaml, men ersätt PGUSER-värdet (klient-ID för tjänstens huvudnamn) med din Databricks-e-postadress.

Installera beroenden och kör appen:

pip3 install --upgrade -r requirements.txt
python3 app.py

Öppna http://localhost:8000 i webbläsaren. Du bör se "Hello from Lakebase!" med dina tre exempelanteckningar. Anslutningspoolen genererar automatiskt nya OAuth-token när nya anslutningar skapas. Mer information finns i Autentisering i Lakebase.

Steg 4: Distribuera och verifiera

När du har testat lokalt synkroniserar du ändringarna till en arbetsytemapp och distribuerar från den platsen:

# Upload files to workspace
databricks sync . /Workspace/Users/<your-email>/my-lakebase-app

# Deploy from the uploaded location
databricks apps deploy <app-name> --source-code-path /Workspace/Users/<your-email>/my-lakebase-app

Ersätt <your-email> med din Databricks-e-postadress och <app-name> med ditt appnamn. Flaggan --source-code-path instruerar distributionen att använda dina uppladdade filer i stället för appens standardplats.

Vänta tills distributionen har slutförts (2–3 minuter) och få sedan åtkomst till din app på den angivna URL:en. Du bör se "Hej från Lakebase!" tillsammans med dina exempelanteckningar.

Se även

• Autentisering i Lakebase
• Dokumentation om Databricks Apps