Udostępnij przez

Poradnik: Połącz aplikację Databricks z Lakebase Autoscaling

Ważne

Skalowanie automatyczne bazy danych Lakebase znajduje się w wersji beta w następujących regionach: eastus2, westeurope, westus.

Autoskalowanie bazy danych Lakebase to najnowsza wersja bazy danych Lakebase z automatycznym skalowaniem obliczeniowym, skalowaniem do zera, rozgałęzianiem i natychmiastowym przywracaniem. Aby zapoznać się z porównaniem funkcji z Lakebase Provisioned, sprawdź wybieranie między wersjami.

W tym samouczku pokazano, jak połączyć aplikację usługi Databricks z usługą Lakebase Autoscaling z automatycznym obracaniem poświadczeń. Aplikacja generuje nowe poświadczenia bazy danych z usługi Databricks przed ich wygaśnięciem. W przykładzie użyto platformy Flask, ale wzorzec uwierzytelniania ma zastosowanie do dowolnej struktury.

Jak to działa

Usługa Databricks Apps uwierzytelnia się w usłudze Lakebase przy użyciu tokenów OAuth wygasających po godzinie. Aby to obsłużyć, należy utworzyć rolę Postgres dla jednostki usługi aplikacji, a następnie skonfigurować aplikację tak, aby automatycznie generowała nowe tokeny za każdym razem, gdy musi nawiązać połączenie z bazą danych. Dzieje się tak za pomocą wzorca puli połączeń: pula tworzy nowe połączenia z nowymi tokenami zgodnie z potrzebami, więc aplikacja nigdy nie używa wygasłych poświadczeń.

Podczas wdrażania aplikacji w usłudze Databricks jest ona uruchamiana jako jednostka usługi i generuje tokeny dla tej tożsamości. Podczas testowania lokalnego aplikacja jest uruchamiana jako konto użytkownika usługi Databricks i generuje tokeny. Oba używają tego samego kodu rotacji tokenu: zmienia się tylko kontekst uwierzytelniania.

Zanim rozpoczniesz

Do ukończenia tego samouczka potrzebne są następujące elementy:

Krok 1. Tworzenie aplikacji i bazy danych

Najpierw utwórz zarówno aplikację usługi Databricks, jak i projekt Lakebase. Aplikacja automatycznie pobiera tożsamość głównego obiektu usługi, a Ty będziesz używać jej do uwierzytelniania bazy danych.

Tworzenie aplikacji

Utwórz nową aplikację Databricks przy użyciu szablonu Flask Hello World (+ Nowa > aplikacja w przestrzeni roboczej). Aby uzyskać szczegółowe instrukcje, zobacz Utwórz aplikację Databricks.

Po zakończeniu instalacji przejdź do karty Środowisko aplikacji i zanotuj DATABRICKS_CLIENT_ID wartość (format UUID, taki jak 6b215d2b-f099-4bdb-900a-60837201ecec). Ta nazwa użytkownika Postgres staje się nazwą użytkownika w aplikacji używaną do uwierzytelniania OAuth.

Uwaga / Notatka

Nie wdrażaj jeszcze aplikacji — najpierw skonfigurujesz połączenie z bazą danych.

Tworzenie bazy danych

Utwórz nowy projekt autoskalowania w usłudze Lakebase w celu hostowania bazy danych. Kliknij pozycję Ikona aplikacji.Aplikacje w prawym górnym rogu wybierz pozycję Lakebase, a następnie utwórz nowy projekt z odpowiednią nazwą (na przykład my-app-db) i wersją postgres (zaakceptuj domyślną wersję postgres 17). Aby uzyskać szczegółowe informacje o konfiguracji, zobacz Tworzenie projektu.

Przed kontynuowaniem poczekaj, aż zasoby obliczeniowe staną się aktywne (około 1 minuta).

Krok 2. Konfigurowanie uwierzytelniania i schematu bazy danych

Utwórz rolę Postgres dla jednostki usługi aplikacji przy użyciu uwierzytelniania OAuth, a następnie utwórz przykładową tabelę z danymi wyświetlanymi przez aplikację.

Konfigurowanie uwierzytelniania OAuth

W projekcie Lakebase otwórz edytor SQL i uruchom te polecenia. Rozszerzenie databricks_auth umożliwia uwierzytelnianie OAuth, dzięki czemu role postgres akceptują tokeny usługi Databricks zamiast tradycyjnych haseł:

-- 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>";

Zastąp <DATABRICKS_CLIENT_ID> wartością DATABRICKS_CLIENT_ID z aplikacji. Główny element usługi może teraz uwierzytelniać się przy użyciu tokenów OAuth, którymi Databricks zarządza automatycznie. Aby uzyskać szczegółowe informacje, zobacz Tworzenie roli OAuth dla tożsamości Databricks.

Tworzenie schematu bazy danych

Utwórz przykładową tabelę z jawnymi uprawnieniami jednostki usługi (jednostki usługi nie dziedziczą domyślnych uprawnień schematu):

-- 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');

Zastąp <DATABRICKS_CLIENT_ID> wartość wartością DATABRICKS_CLIENT_ID .

Krok 3. Kompilowanie i konfigurowanie aplikacji

Pobierz pliki aplikacji, skonfiguruj połączenie bazy danych z automatycznym obracaniem tokenu OAuth i przetestuj je lokalnie przed wdrożeniem.

Pobieranie i konfigurowanie plików aplikacji

Pobierz pliki aplikacji z obszaru roboczego, kopiując polecenie eksportu z sekcji Synchronizuj pliki aplikacji:

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

Edytuj app.yaml , aby dodać szczegóły połączenia z bazą danych. Pobierz wartości połączenia z okna modalnego Lakebase Connect, wybierając tylko parametry:

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>'

Zastąp symbole zastępcze:

  • <your-endpoint-hostname>: Skopiuj wartość PGHOST z modalnego połączenia (na przykład ep-xyz.database.us-west-2.dev.databricks.com)
  • <DATABRICKS_CLIENT_ID>: Użyj tego DATABRICKS_CLIENT_ID z kroku 1
  • projects/<project-id>/branches/<branch-id>/endpoints/<endpoint-id>: Uruchom databricks postgres list-endpoints i skopiuj name wartość pola (format: projects/<uuid>/branches/<uuid>/endpoints/<id>)

Implementowanie rotacji tokenów OAuth i zapytania bazy danych

Zamień app.py na ten kod. Implementuje to dwie kluczowe zmiany: automatyczną rotację tokenu OAuth na potrzeby uwierzytelniania oraz zapytanie bazy danych, które pobiera i wyświetla notatki utworzone w kroku 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)

Ten kod implementuje automatyczną rotację poświadczeń bazy danych przy użyciu trzech kluczowych składników:

  • WorkspaceClient: generuje nowe poświadczenia bazy danych za pomocą zestawu SDK usługi Databricks
  • Klasa OAuthConnection: niestandardowa klasa połączenia, która wprowadza świeże poświadczenia przy każdym nowym połączeniu
  • ConnectionPool: zarządza połączeniami bazy danych i wywołuje niestandardową klasę połączenia podczas tworzenia połączeń

Ten schemat gwarantuje, że aplikacja zawsze ma poprawne poświadczenia bazy danych. Aby uzyskać szczegółowe wyjaśnienie działania rotacji poświadczeń, różne strategie rotacji i obsługa błędów, zobacz Rotacja tokenów w usłudze Lakebase.

Aktualizacja requirements.txt w celu uwzględnienia wymaganych pakietów:

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

Minimalna wersja zestawu SDK (0.81.0) gwarantuje, że generate_database_credential() metoda jest dostępna dla generowania tokenów OAuth.

Testowanie lokalne

Przetestuj aplikację lokalnie, aby sprawdzić, czy połączenie z bazą danych działa przed wdrożeniem. Podczas testowania lokalnego aplikacja jest uruchamiana jako konto użytkownika Databricks (a nie pryncypał serwisowy), więc musisz zmienić PGUSER na swój adres e-mail w poniższych zmiennych środowiskowych.

Uwierzytelnij się w obszarze roboczym i wyeksportuj zmienne środowiskowe:

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

Skopiuj wartości z elementu app.yaml, ale zastąp wartość elementu PGUSER (identyfikator klienta głównego usługi) twoim adresem e-mail w Databricks.

Zainstaluj zależności i uruchom aplikację:

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

Otwórz http://localhost:8000 w przeglądarce. Powinien zostać wyświetlony komunikat "Hello from Lakebase!" z trzema przykładowymi notatkami. Pula połączeń automatycznie generuje nowe tokeny OAuth podczas tworzenia nowych połączeń. Aby uzyskać więcej informacji, zobacz Authentication in Lakebase (Uwierzytelnianie w usłudze Lakebase).

Wyjście lokalnej aplikacji pokazujące

Krok 4. Wdrażanie i weryfikowanie

Po przetestowaniu lokalnie zsynchronizuj zmiany do folderu obszaru roboczego i wdróż je z tej lokalizacji:

# 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

Zastąp <your-email> swoim adresem e-mail w Databricks i <app-name> nazwą aplikacji. Flaga --source-code-path informuje wdrożenie o użyciu przekazanych plików zamiast domyślnej lokalizacji aplikacji.

Poczekaj na zakończenie wdrożenia (2–3 minuty), a następnie uzyskaj dostęp do aplikacji pod podanym adresem URL. Powinna zostać wyświetlona informacja "Hello from Lakebase!" z przykładowymi notatkami.

Zobacz także

  • Last updated on