서울은 50ms, 상파울루는 280ms — Turso LibSQL로 격차를 줄이는 법

npm install @libsql/client drizzle-orm
npm install -D drizzle-kit

import { createClient } from "@libsql/client";
 
const client = createClient({
  url: process.env.TURSO_DATABASE_URL!,
  authToken: process.env.TURSO_AUTH_TOKEN!,
});

import { createClient } from "@libsql/client";
 
const client = createClient({
  url: "file:./local.db",
  syncUrl: process.env.TURSO_DATABASE_URL!,
  authToken: process.env.TURSO_AUTH_TOKEN!,
  syncInterval: 60, // 단위: 초. 생략 시 자동 동기화 없음
});
 
// 앱 시작 시 최신 상태로 동기화
await client.sync();

# Turso CLI 설치 (macOS)
brew install tursodatabase/tap/turso
 
# 로그인
turso auth login
 
# DB 생성 (도쿄를 프라이머리로)
turso db create my-app --location nrt
 
# 읽기 레플리카 추가
turso db replicate my-app --location iad  # 버지니아 (미국 동부)
turso db replicate my-app --location lhr  # 런던
 
# 연결 정보 확인
turso db show my-app --url
turso db tokens create my-app

import { text, integer, sqliteTable } from "drizzle-orm/sqlite-core";
import { sql, relations } from "drizzle-orm";
 
export const users = sqliteTable("users", {
  id: integer("id").primaryKey({ autoIncrement: true }),
  name: text("name").notNull(),
  email: text("email").notNull().unique(),
  createdAt: integer("created_at", { mode: "timestamp" })
    .notNull()
    .default(sql`(unixepoch())`),
});
 
export const posts = sqliteTable("posts", {
  id: integer("id").primaryKey({ autoIncrement: true }),
  title: text("title").notNull(),
  content: text("content"),
  userId: integer("user_id")
    .notNull()
    .references(() => users.id, { onDelete: "cascade" }),
  publishedAt: integer("published_at", { mode: "timestamp" }),
});
 
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));
 
export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.userId],
    references: [users.id],
  }),
}));

import { drizzle } from "drizzle-orm/libsql";
import { createClient } from "@libsql/client";
import * as schema from "./schema";
 
const client = createClient({
  url: process.env.TURSO_DATABASE_URL ?? "file:./dev.db",
  authToken: process.env.TURSO_AUTH_TOKEN,
});
 
export const db = drizzle(client, { schema });
export { client };

import { db } from "./db";
import { users, posts } from "./schema";
import { eq, desc } from "drizzle-orm";
 
// 모든 사용자 조회
const allUsers = await db.select().from(users);
 
// 특정 사용자의 최신 포스트 5개 (JOIN)
const recentPosts = await db
  .select({
    title: posts.title,
    publishedAt: posts.publishedAt,
    authorName: users.name,
  })
  .from(posts)
  .innerJoin(users, eq(posts.userId, users.id))
  .where(eq(posts.userId, 1))
  .orderBy(desc(posts.publishedAt))
  .limit(5);
 
// 새 사용자 추가 (쓰기 → 프라이머리로 라우팅)
const newUser = await db
  .insert(users)
  .values({ name: "김철수", email: "kim@example.com" })
  .returning();

import { defineConfig } from "drizzle-kit";
 
export default defineConfig({
  dialect: "turso",
  schema: "./src/schema.ts",
  out: "./drizzle",
  dbCredentials: {
    url: process.env.TURSO_DATABASE_URL ?? "file:./dev.db",
    authToken: process.env.TURSO_AUTH_TOKEN,
  },
});

# 스키마 변경 후 마이그레이션 파일 생성
npx drizzle-kit generate
 
# drizzle/ 디렉토리에 생성된 SQL 파일 확인
cat drizzle/0001_add_published_at.sql
 
# 실제 DB에 적용
npx drizzle-kit migrate

async function createTenantDatabase(tenantId: string): Promise<string> {
  const response = await fetch(
    `https://api.turso.tech/v1/organizations/${process.env.TURSO_ORG}/databases`,
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.TURSO_API_TOKEN}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        name: `tenant-${tenantId}`,
        group: "default",
      }),
    }
  );
 
  if (!response.ok) {
    throw new Error(`DB 생성 실패: ${response.status} ${response.statusText}`);
  }
 
  const data = await response.json();
  return data.database.Hostname;
}

import { createClient } from "@libsql/client";
import { drizzle } from "drizzle-orm/libsql";
import * as schema from "./schema";
 
const tenantDbCache = new Map<string, ReturnType<typeof drizzle>>();
 
function getTenantDb(tenantId: string) {
  if (tenantDbCache.has(tenantId)) {
    return tenantDbCache.get(tenantId)!;
  }
 
  const client = createClient({
    url: `libsql://tenant-${tenantId}-${process.env.TURSO_ORG}.turso.io`,
    authToken: process.env.TURSO_AUTH_TOKEN!,
  });
  const db = drizzle(client, { schema });
  tenantDbCache.set(tenantId, db);
  return db;
}
 
// API 라우터 예시 (Next.js App Router)
export async function GET(
  request: Request,
  { params }: { params: { tenantId: string } }
) {
  const db = getTenantDb(params.tenantId);
  const data = await db.select().from(schema.posts);
  return Response.json(data);
}

import { createClient } from "@libsql/client";
import { drizzle } from "drizzle-orm/libsql";
import { users } from "./schema";
 
// 임베디드 레플리카 클라이언트 — syncUrl 필수
const client = createClient({
  url: "file:./local.db",
  syncUrl: process.env.TURSO_DATABASE_URL!,
  authToken: process.env.TURSO_AUTH_TOKEN!,
});
const db = drizzle(client, { schema: { users } });
 
async function createUserAndReturn(name: string, email: string) {
  const newUser = await db
    .insert(users)
    .values({ name, email })
    .returning();
 
  // 로컬 레플리카를 원격 프라이머리와 즉시 동기화
  await client.sync();
 
  // 이 시점부터 로컬 레플리카 읽기에 방금 쓴 데이터가 반영됨
  return newUser;
}