고급 기능 (Scale to Zero, Lakebase, DABs, AppKit)

# 앱 자동 중지/시작 Job 예시 (Python SDK)
from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# 퇴근 시 앱 중지 (7PM Job으로 등록)
w.apps.stop("my-dashboard-app")

# 출근 시 앱 시작 (7AM Job으로 등록)
w.apps.start("my-dashboard-app")

# cron 또는 Databricks Job으로 실행
# 퇴근 시 (19:00)
databricks apps stop my-dashboard-app

# 출근 시 (07:00)
databricks apps start my-dashboard-app

# 모든 앱 목록 확인
databricks apps list --output json | jq '.[] | select(.status == "RUNNING") | .name'

# 불필요한 앱 중지
databricks apps stop unused-app-1

{
  "name": "my-scaled-app",
  "description": "Horizontally scaled app",
  "compute_size": "MEDIUM",
  "compute_min_instances": 1,
  "compute_max_instances": 3
}

# Git 기반 배포 (CLI)
databricks apps deploy my-app \
  --git-url https://github.com/myorg/myrepo \
  --git-ref main \
  --source-code-path ./app

command: ['streamlit', 'run', 'app.py']
# 텔레메트리 내보내기 설정 (app.yaml 또는 앱 설정 UI에서)

# pyproject.toml
[project]
name = "my-databricks-app"
version = "0.1.0"
requires-python = ">=3.10"
dependencies = [
    "streamlit>=1.32.0",
    "databricks-sdk>=0.20.0",
    "pandas>=2.2.0",
]

# uv.lock 생성
uv lock

command: ['python', 'app.py']
env:
  - name: DB_CONNECTION
    valueFrom: lakebase_db
resources:
  - name: lakebase_db
    type: postgres

# requirements.txt
databricks-sdk
psycopg2-binary    # PostgreSQL 드라이버

import os
import psycopg2

# Lakebase 연결 정보 가져오기
db_connection = os.getenv("DB_CONNECTION")

# PostgreSQL 호환 연결
conn = psycopg2.connect(db_connection)

# CRUD 작업
with conn.cursor() as cur:
    # 테이블 생성
    cur.execute("""
        CREATE TABLE IF NOT EXISTS app_sessions (
            id SERIAL PRIMARY KEY,
            user_id VARCHAR(255),
            data JSONB,
            created_at TIMESTAMP DEFAULT NOW()
        )
    """)

    # 데이터 삽입
    cur.execute(
        "INSERT INTO app_sessions (user_id, data) VALUES (%s, %s)",
        ("user123", '{"page": "dashboard", "action": "view"}')
    )
    conn.commit()

    # 데이터 조회
    cur.execute("SELECT * FROM app_sessions WHERE user_id = %s", ("user123",))
    rows = cur.fetchall()

conn.close()

import os
import streamlit as st
import psycopg2

@st.cache_resource
def get_db_connection():
    """Lakebase 연결을 캐싱하여 재사용합니다."""
    return psycopg2.connect(os.getenv("DB_CONNECTION"))

conn = get_db_connection()

st.title("피드백 수집 앱")

# 피드백 입력 폼
with st.form("feedback_form"):
    name = st.text_input("이름")
    feedback = st.text_area("피드백")
    rating = st.slider("만족도", 1, 5, 3)
    submitted = st.form_submit_button("제출")

    if submitted:
        with conn.cursor() as cur:
            cur.execute(
                "INSERT INTO feedback (name, feedback, rating) VALUES (%s, %s, %s)",
                (name, feedback, rating)
            )
            conn.commit()
        st.success("피드백이 저장되었습니다!")

# 피드백 목록 조회
with conn.cursor() as cur:
    cur.execute("SELECT name, feedback, rating, created_at FROM feedback ORDER BY created_at DESC LIMIT 20")
    rows = cur.fetchall()

if rows:
    import pandas as pd
    df = pd.DataFrame(rows, columns=["이름", "피드백", "만족도", "작성일"])
    st.dataframe(df)

my-app-bundle/
├── databricks.yml          # Bundle 설정 파일
├── src/
│   ├── app.py              # 앱 코드
│   ├── app.yaml            # 앱 런타임 설정
│   └── requirements.txt    # 의존성
└── resources/
    └── my_app.yml           # 앱 리소스 정의

bundle:
  name: my-dashboard-app

workspace:
  host: https://<workspace-url>

targets:
  dev:
    mode: development
    default: true
    workspace:
      host: https://<dev-workspace-url>

  prod:
    mode: production
    workspace:
      host: https://<prod-workspace-url>

include:
  - resources/*.yml

resources:
  apps:
    my_dashboard_app:
      name: "my-dashboard-app"
      description: "매출 분석 대시보드"
      source_code_path: ../src
      config:
        command:
          - streamlit
          - run
          - app.py
        env:
          - name: DATABRICKS_WAREHOUSE_ID
            value: ${var.warehouse_id}
      resources:
        - name: sql_warehouse
          sql_warehouse:
            id: ${var.warehouse_id}
            permission: CAN_USE
      permissions:
        - level: CAN_MANAGE
          user_name: admin@company.com
        - level: CAN_USE
          group_name: data-team

# Bundle 유효성 검사
databricks bundle validate -t dev

# 개발 환경에 배포
databricks bundle deploy -t dev

# 프로덕션 환경에 배포
databricks bundle deploy -t prod

# 배포 상태 확인
databricks bundle summary -t dev

# 1. 매니페스트 확인 (사용 가능한 플러그인과 리소스 확인)
databricks apps manifest --profile <PROFILE>

# 2. 프로젝트 생성
databricks apps init \
  --name my-analytics-app \
  --features analytics \
  --set analytics.sql-warehouse.id=<WAREHOUSE_ID> \
  --description "매출 분석 대시보드" \
  --run none \
  --profile <PROFILE>

# 3. 의존성 설치 및 개발 서버 실행
cd my-analytics-app
npm install
npm run dev

my-analytics-app/
├── client/
│   ├── src/
│   │   ├── App.tsx              # 메인 React 컴포넌트
│   │   ├── appKitTypes.d.ts     # 자동 생성된 SQL 쿼리 타입
│   │   └── main.tsx
│   └── vite.config.ts
├── server/
│   └── server.ts                # tRPC 라우터 (백엔드)
├── config/
│   └── queries/
│       └── sales_by_region.sql  # SQL 쿼리 파일
├── tests/
│   └── smoke.spec.ts            # 스모크 테스트
├── app.yaml                     # 배포 설정
└── package.json

-- config/queries/sales_by_region.sql
SELECT
  region,
  SUM(revenue) as total_revenue,
  COUNT(*) as order_count
FROM catalog.schema.sales
WHERE order_date >= :start_date
  AND order_date <= :end_date
GROUP BY region
ORDER BY total_revenue DESC

npm run typegen
# ✓ sales_by_region — 타입 생성 완료

// client/src/App.tsx
import { BarChart, DataTable } from '@databricks/appkit-ui/react';
import { useAnalyticsQuery } from '@databricks/appkit-ui/react';
import { sql } from '@databricks/appkit-ui/js';
import { useState } from 'react';

function App() {
  const [startDate, setStartDate] = useState('2024-01-01');
  const [endDate, setEndDate] = useState('2024-12-31');

  const params = {
    start_date: sql.date(startDate),
    end_date: sql.date(endDate),
  };

  // KPI 카드용 데이터 조회
  const { data } = useAnalyticsQuery('sales_by_region', params);

  const totalRevenue = data
    ? data.reduce((sum, row) => sum + Number(row.total_revenue), 0)
    : 0;

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold mb-4">매출 분석 대시보드</h1>

      {/* KPI 카드 */}
      <div className="grid grid-cols-3 gap-4 mb-8">
        <div className="p-4 border rounded">
          <p className="text-sm text-gray-500">총 매출</p>
          <p className="text-2xl font-bold">
            ${Number(totalRevenue).toLocaleString()}
          </p>
        </div>
      </div>

      {/* 지역별 매출 차트 */}
      <BarChart
        queryKey="sales_by_region"
        parameters={params}
        xKey="region"
        yKey="total_revenue"
        colors={['#FF3621']}
        height={400}
      />

      {/* 데이터 테이블 */}
      <DataTable
        queryKey="sales_by_region"
        parameters={params}
      />
    </div>
  );
}

export default App;

// server/server.ts
import { initTRPC } from '@trpc/server';
import { getExecutionContext } from '@databricks/appkit';
import { z } from 'zod';

const t = initTRPC.create();

export const appRouter = t.router({
  askAgent: t.procedure
    .input(z.object({ question: z.string() }))
    .mutation(async ({ input }) => {
      const { serviceDatabricksClient: client } = getExecutionContext();

      const response = await client.servingEndpoints.query({
        name: 'my-agent-endpoint',
        messages: [{ role: 'user', content: input.question }],
      });

      return {
        answer: response.choices[0].message.content,
      };
    }),
});

# 유효성 검사
databricks apps validate --profile <PROFILE>

# 배포
databricks apps deploy --profile <PROFILE>

my-react-app/
├── app.yaml
├── package.json
├── server.js                 # Express/Node.js 서버
├── build/                    # React 빌드 결과물
│   ├── index.html
│   └── static/
└── src/                      # React 소스 (빌드 전)
    ├── App.jsx
    └── index.js

command: ['npm', 'run', 'start']
env:
  - name: DATABRICKS_WAREHOUSE_ID
    valueFrom: sql_warehouse
  - name: NODE_ENV
    value: 'production'
resources:
  - name: sql_warehouse
    type: sql-warehouse

{
  "name": "my-react-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node server.js",
    "build": "react-scripts build"
  },
  "dependencies": {
    "@databricks/sql": "^1.8.0",
    "express": "^4.18.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  }
}

const express = require('express');
const path = require('path');
const { DBSQLClient } = require('@databricks/sql');

const app = express();
const port = process.env.DATABRICKS_APP_PORT || 3000;

// React 빌드 결과물 서빙
app.use(express.static(path.join(__dirname, 'build')));
app.use(express.json());

// API 엔드포인트
app.get('/api/data', async (req, res) => {
  try {
    const client = new DBSQLClient();
    const connection = await client.connect({
      authType: 'databricks-oauth',
      host: process.env.DATABRICKS_HOST,
      path: `/sql/1.0/warehouses/${process.env.DATABRICKS_WAREHOUSE_ID}`,
      oauthClientId: process.env.DATABRICKS_CLIENT_ID,
      oauthClientSecret: process.env.DATABRICKS_CLIENT_SECRET,
    });

    const session = await connection.openSession();
    const result = await session.executeStatement(
      'SELECT * FROM catalog.schema.table LIMIT 100'
    );
    const rows = await result.fetchAll();

    await result.close();
    await session.close();
    await connection.close();

    res.json({ data: rows });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// SPA fallback
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'build', 'index.html'));
});

app.listen(port, '0.0.0.0', () => {
  console.log(`Server running on port ${port}`);
});