
Để đạt được độ trễ truy cập dữ liệu dưới 5ms cho các ứng dụng toàn cầu, cần phải đưa dữ liệu đến gần người dùng hơn. Các kiến trúc cơ sở dữ liệu tập trung truyền thống, ngay cả với các bản sao chỉ đọc, cũng gây ra chi phí mạng trở nên quá lớn ở biên. Turso, được xây dựng trên libSQL (một nhánh của SQLite), cung cấp một giải pháp hấp dẫn: SQLite phân tán với các bản sao nhúng. Kiến trúc này cho phép đọc cục bộ, độ trễ thấp trong khi vẫn duy trì tính nhất quán mạnh mẽ cho các thao tác ghi thông qua ủy quyền chính. Hướng dẫn này trình bày chi tiết việc triển khai thực tế Turso với các bản sao nhúng, bao gồm triển khai, đo lường độ trễ, xử lý ghi, đồng bộ hóa ngoại tuyến và các chiến lược di chuyển.
Generate tuned WAL, busy_timeout, cache & mmap configs
Fine-tune SQLite for high concurrency. Configure WAL mode, 5000ms busy timeout, 64MB cache, and generate production connection snippets for Python, Node.js, Go, and Rust.
Sức mạnh cốt lõi của Turso nằm ở mô hình primary-replica của nó. Một cơ sở dữ liệu chính duy nhất xử lý tất cả các thao tác ghi, đảm bảo tuân thủ ACID và tính nhất quán mạnh mẽ. Tuy nhiên, các bản sao chỉ đọc có thể được triển khai trên toàn cầu, bao gồm cả việc nhúng trực tiếp vào các worker biên. Việc nhúng này rất quan trọng: nó loại bỏ các bước nhảy mạng cho các hoạt động đọc, đạt được quyền truy cập tốc độ đĩa cục bộ.
Đầu tiên, cài đặt Turso CLI và tạo một cơ sở dữ liệu.
# Install Turso CLI
curl -sSfL https://get.tur.so/install.sh | bash
# Authenticate
turso auth login
# Create a database in a primary region (e.g., 'ord' for Chicago)
turso db create my-edge-app-db --location ord
# Create a read replica in an edge region (e.g., 'syd' for Sydney)
turso db replicate my-edge-app-db --location syd
# Get connection URL and auth token for the primary
turso db shell my-edge-app-db
# In the shell, run:
# .connection-url
# .auth-token
# Exit the shell
Lưu URL cơ sở dữ liệu chính và mã thông báo xác thực một cách an toàn. Đối với các bản sao nhúng, chúng ta sẽ sử dụng một chuỗi kết nối khác.
Thư viện libsql-client cung cấp giao diện cần thiết.
// src/lib/turso.ts
import { createClient, Client } from '@libsql/client';
let tursoClient: Client | null = null;
export function getTursoClient(
url: string = process.env.TURSO_DATABASE_URL!,
authToken: string = process.env.TURSO_AUTH_TOKEN!
): Client {
if (!tursoClient) {
if (!url || !authToken) {
throw new Error('TURSO_DATABASE_URL and TURSO_AUTH_TOKEN must be set.');
}
tursoClient = createClient({
url,
authToken,
});
}
return tursoClient;
}
// Example usage (e.g., in an API route)
// const db = getTursoClient();
// const result = await db.execute('SELECT * FROM users');
Sức mạnh thực sự của Turso cho các ứng dụng biên đến từ việc nhúng các bản sao. Điều này có nghĩa là tệp cơ sở dữ liệu SQLite được quản lý cục bộ bởi worker biên, đồng bộ hóa với bản chính.
Cloudflare Workers cung cấp Durable Objects cho các ứng dụng có trạng thái, nhưng đối với các bản sao nhúng đơn giản, chúng ta có thể tận dụng hệ thống tệp của Worker (nếu có, hoặc hệ thống tệp trong bộ nhớ/tệp tạm thời cục bộ cho các bản sao tạm thời) hoặc, thực tế hơn, sử dụng khả năng bản sao cục bộ của libsql-client.
libsql-client có thể được cấu hình để hoạt động ở chế độ "bản sao cục bộ", nơi nó duy trì một tệp SQLite cục bộ và đồng bộ hóa với một bản chính Turso từ xa.
// src/lib/turso-edge.ts
import { createClient, Client } from '@libsql/client';
import { fileURLToPath } from 'url';
import path from 'path';
// For Cloudflare Workers, you might need to use a different storage mechanism
// or rely on the remote replica for reads if true local file system access is limited.
// This example assumes a Node.js-like environment where file system access is possible.
// For Workers, consider using a remote replica URL directly or Durable Objects for state.
// In a Node.js environment (e.g., Vercel Edge Functions with Node.js runtime)
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const DB_PATH = path.join(__dirname, '../../data/local.db'); // Path to store the local SQLite file
let edgeTursoClient: Client | null = null;
export function getEdgeTursoClient(
syncUrl: string = process.env.TURSO_DATABASE_URL!, // Primary URL for synchronization
authToken: string = process.env.TURSO_AUTH_TOKEN!,
localDbPath: string = DB_PATH // Path for the local SQLite file
): Client {
if (!edgeTursoClient) {
if (!syncUrl || !authToken) {
throw new Error('TURSO_DATABASE_URL and TURSO_AUTH_TOKEN must be set for edge client.');
}
// Initialize the client in local replica mode
edgeTursoClient = createClient({
url: `file:${localDbPath}`, // Connect to a local SQLite file
syncUrl, // URL of the primary database for synchronization
authToken,
syncInterval: 5000, // Sync every 5 seconds (adjust as needed)
});
// Start synchronization immediately
edgeTursoClient.sync();
}
return edgeTursoClient;
}
// Example usage in an edge function
// import { getEdgeTursoClient } from '../lib/turso-edge';
//
// export default async function handler(req: Request) {
// const db = getEdgeTursoClient();
// try {
// const start = performance.now();
// const result = await db.execute('SELECT * FROM products WHERE category = ?', ['electronics']);
// const end = performance.now();
// console.log(`Read latency: ${end - start}ms`);
// return new Response(JSON.stringify(result.rows), { status: 200 });
// } catch (error) {
// console.error('Edge DB error:', error);
// return new Response('Internal Server Error', { status: 500 });
// }
// }
Những cân nhắc quan trọng cho môi trường biên:
libsql-client để kết nối trực tiếp với URL bản sao chỉ đọc Turso gần nhất. Mặc dù không phải là "nhúng", nó vẫn gần về mặt địa lý./tmp, vốn là tạm thời nhưng đủ cho một lần gọi hàm nếu bản sao được khởi tạo và đồng bộ hóa theo yêu cầu (kém hiệu quả hơn). Đối với trạng thái liên tục, bộ nhớ ngoài hoặc bản sao từ xa được ưu tiên.syncInterval xác định tần suất bản sao cục bộ kéo các thay đổi từ bản chính. Đối với các thao tác đọc quan trọng, bạn có thể kích hoạt db.sync() thủ công trước khi đọc, nhưng điều này làm tăng độ trễ. Tính nhất quán cuối cùng là tiêu chuẩn cho các thao tác đọc biên.Để chứng minh độ trễ dưới 5ms, hãy triển khai ví dụ getEdgeTursoClient vào một môi trường hỗ trợ truy cập hệ thống tệp cục bộ (ví dụ: máy chủ Node.js cục bộ, hoặc Vercel Edge Function với đường dẫn /tmp cho dữ liệu tạm thời).
// src/pages/api/products.ts (Example Vercel Edge Function)
import type { NextRequest } from 'next/server';
import { getEdgeTursoClient } from '../../lib/turso-edge';
export const config = {
runtime: 'edge', // This ensures it runs on the Vercel Edge Network
};
export default async function handler(req: NextRequest) {
const db = getEdgeTursoClient(); // This will initialize and sync the local replica
try {
const start = performance.now();
// Ensure your database has a 'products' table with some data
await db.execute(`
CREATE TABLE IF NOT EXISTS products (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
category TEXT NOT NULL,
price REAL NOT NULL
);
`);
await db.execute(`
INSERT OR IGNORE INTO products (id, name, category, price) VALUES
(1, 'Laptop Pro', 'electronics', 1200.00),
(2, 'Mechanical Keyboard', 'peripherals', 150.00);
`);
const result = await db.execute('SELECT * FROM products WHERE category = ?', ['electronics']);
const end = performance.now();
const latency = end - start;
console.log(`Edge Read Latency: ${latency.toFixed(2)}ms`);
return new Response(JSON.stringify({
data: result.rows,
latency: `${latency.toFixed(2)}ms`,
source: 'edge_replica'
}), {
status: 200,
headers: {
'Content-Type': 'application/json',
},
});
} catch (error: any) {
console.error('Edge DB error:', error);
return new Response(JSON.stringify({ error: error.message }), {
status: 500,
headers: {
'Content-Type': 'application/json',
},
});
}
}
Khi chạy cục bộ hoặc triển khai lên Vercel Edge, bạn sẽ thấy độ trễ đọc thường dưới 5ms, đôi khi thậm chí dưới 1ms, tùy thuộc vào độ phức tạp của truy vấn và môi trường. Điều này là do dữ liệu đang được đọc từ một tệp cục bộ, không phải qua mạng.
Tất cả các hoạt động ghi phải được chuyển đến cơ sở dữ liệu chính Turso để duy trì tính nhất quán mạnh mẽ. libsql-client đơn giản hóa điều này bằng cách cho phép bạn chỉ định syncUrl cho các bản sao cục bộ, được sử dụng cho các thao tác ghi.
Khi sử dụng createClient với URL file: và syncUrl, máy khách tự động ủy quyền các thao tác ghi cho syncUrl (bản chính).
// src/lib/turso-write.ts
import { getEdgeTursoClient } from './turso-edge'; // Re-use the edge client setup
export async function createProduct(name: string, category: string, price: number) {
const db = getEdgeTursoClient(); // This client is configured to delegate writes
try {
const start = performance.now();
const result = await db.execute(
'INSERT INTO products (name, category, price) VALUES (?, ?, ?)',
[name, category, price]
);
const end = performance.now();
console.log(`Write operation to primary latency: ${end - start}ms`);
return result;
} catch (error) {
console.error('Write error:', error);
throw error;
}
}
// Example usage in an API route:
// import { createProduct } from '../../lib/turso-write';
//
// export default async function handler(req: Request) {
// if (req.method !== 'POST') {
// return new Response('Method Not Allowed', { status: 405 });
// }
// const { name, category, price } = await req.json();
// try {
// await createProduct(name, category, price);
// return new Response('Product created successfully', { status: 201 });
// } catch (error) {
// return new Response('Failed to create product', { status: 500 });
// }
// }
Độ trễ cho các hoạt động ghi tự nhiên sẽ cao hơn các hoạt động đọc cục bộ, vì chúng liên quan đến một chuyến đi khứ hồi qua mạng đến cơ sở dữ liệu chính. Đây là một sự đánh đổi cố hữu để có tính nhất quán mạnh mẽ.
Mô hình bản sao nhúng vốn hỗ trợ khả năng ưu tiên ngoại tuyến. Nếu một worker biên hoặc ứng dụng máy khách mất kết nối mạng, nó có thể tiếp tục phục vụ các thao tác đọc từ bản sao cục bộ của nó. Sau khi kết nối được khôi phục, libsql-client sẽ tự động cố gắng đồng bộ hóa với bản chính.
Đối với các ứng dụng phía máy khách (ví dụ: Electron, ứng dụng di động), libsql-client có thể được sử dụng trực tiếp để quản lý cơ sở dữ liệu SQLite cục bộ đồng bộ hóa với Turso.
// Example: Client-side offline-first setup (e.g., in an Electron app)
import { createClient } from '@libsql/client';
import path from 'path';
import { app } from 'electron'; // Assuming Electron context
const userDataPath = app.getPath('userData');
const localDbPath = path.join(userDataPath, 'my-app-offline.db');
const offlineClient = createClient({
url: `file:${localDbPath}`,
syncUrl: process.env.TURSO_DATABASE_URL!,
authToken: process.env.TURSO_AUTH_TOKEN!,
syncInterval: 10000, // Sync every 10 seconds when online
});
// Start synchronization
offlineClient.sync();
// Application logic can now read/write to offlineClient
// Writes will be queued and sent to primary when online.
// Reads will be served from local DB.
Thiết lập này cung cấp khả năng phục hồi và trải nghiệm người dùng mượt mà ngay cả khi có kết nối mạng không liên tục.
Di chuyển từ dịch vụ dựa trên PostgreSQL như Neon hoặc Supabase sang Turso liên quan đến việc chuyển đổi lược đồ và truyền dữ liệu.
Ngôn ngữ SQL của SQLite phần lớn tương thích với PostgreSQL, nhưng có những khác biệt:
TEXT, VARCHAR, INTEGER, BOOLEAN của PostgreSQL ánh xạ tốt. UUID trở thành TEXT. JSONB trở thành TEXT (lưu dưới dạng chuỗi JSON). Các kiểu ARRAY cần được tuần tự hóa (ví dụ: chuỗi JSON).SERIAL hoặc GENERATED BY DEFAULT AS IDENTITY. SQLite sử dụng INTEGER PRIMARY KEY AUTOINCREMENT.GEN_RANDOM_UUID(), NOW()) cần các hàm tương đương của SQLite hoặc xử lý ở cấp ứng dụng.CHECK, FOREIGN KEY được hỗ trợ, nhưng hành vi có thể hơi khác.CREATE INDEX tiêu chuẩn tương thích.Ví dụ chuyển đổi lược đồ:
-- PostgreSQL Schema
CREATE TABLE users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
email TEXT UNIQUE NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Turso (SQLite) Schema
CREATE TABLE users (
id TEXT PRIMARY KEY, -- UUIDs stored as TEXT
email TEXT UNIQUE NOT NULL,
created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) -- ISO 8601 format
);
Xuất từ PostgreSQL: Sử dụng pg_dump để xuất dữ liệu ở định dạng phù hợp để nhập. CSV thường là dễ nhất.
pg_dump -d your_db_name -t users --data-only --column-inserts > users_data.sql
Hoặc, đối với CSV:
COPY users TO '/tmp/users.csv' WITH (FORMAT CSV, HEADER);
Nhập vào Turso:
Nhập CSV: Nếu bạn đã xuất sang CSV, bạn có thể viết một tập lệnh để đọc CSV và chèn vào Turso.
// src/scripts/importUsers.ts
import fs from 'fs';
import csv from 'csv-parser';
import { getTursoClient } from '../lib/turso'; // Use the primary client
async function importUsers() {
const db = getTursoClient();
const users: any[] = [];
fs.createReadStream('/tmp/users.csv')
.pipe(csv())
.on('data', (row) => {
users.push(row);
})
.on('end', async () => {
console.log(`Importing ${users.length} users...`);
for (const user of users) {
await db.execute(
'INSERT INTO users (id, email, created_at) VALUES (?, ?, ?)',
[user.id, user.email, user.created_at]
);
}
console.log('Users imported successfully.');
});
}
importUsers().catch(console.error);
Nhập SQL: Nếu bạn đã sử dụng pg_dump với các câu lệnh INSERT, bạn có thể cần điều chỉnh thủ công SQL để tương thích với SQLite (ví dụ: UUID thành TEXT cho ID, NOW() thành strftime). Sau đó, bạn có thể thực thi tệp SQL thông qua Turso CLI hoặc libsql-client.
# Via Turso CLI
turso db shell my-edge-app-db < users_data_sqlite_compatible.sql
| Tính năng | Turso (libSQL) | PostgreSQL (Neon/Supabase) |
|---|---|---|
| Kiến trúc | Primary-Replica, Bản sao biên nhúng | Primary-Replica, Sao chép logic |
| Độ trễ đọc (Biên) | Dưới 5ms (truy cập tệp cục bộ) | 10-50ms+ (mạng đến bản sao gần nhất) |
| Độ trễ ghi | 20-100ms+ (mạng đến bản chính) | 20-100ms+ (mạng đến bản chính) |
| Mô hình nhất quán | Mạnh (ghi), Cuối cùng (đọc từ bản sao) | Mạnh (tất cả các hoạt động) |
| Mô hình dữ liệu | Quan hệ (ngôn ngữ SQLite) | Quan hệ (ngôn ngữ PostgreSQL), JSONB |
| Hỗ trợ ngoại tuyến | Tuyệt vời (đồng bộ hóa tệp cục bộ) | Hạn chế (yêu cầu lớp bộ nhớ đệm/đồng bộ hóa phía máy khách) |
| Khả năng mở rộng | Đọc mở rộng theo chiều ngang với các bản sao | Đọc mở rộng theo chiều ngang với các bản sao |
| Độ phức tạp | Đơn giản hơn cho biên, quản lý sao chép nội bộ | Phức tạp hơn cho biên, yêu cầu đồng bộ hóa bên ngoài cho ngoại tuyến |
| Mô hình chi phí | Dựa trên mức sử dụng (đọc/ghi/lưu trữ) | Dựa trên mức sử dụng (tính toán/lưu trữ/truyền dữ liệu) |
libsql-client quản lý một tệp cơ sở dữ liệu cục bộ cụ thể.busy_timeout nếu sử dụng trực tiếp libsql-client với tệp cục bộ: createClient({ url: 'file:my.db?busy_timeout=5000' }).syncInterval quá cao, hoặc bản sao chưa đồng bộ hóa gần đây.syncInterval để có dữ liệu cập nhật hơn.db.sync() trước các thao tác đọc quan trọng nếu tính nhất quán cuối cùng không thể chấp nhận được đối với một truy vấn cụ thể.TURSO_DATABASE_URL hoặc TURSO_AUTH_TOKEN:
file: trong serverless/edge:
/tmp có thể ghi được nhưng là tạm thời. Điều này có nghĩa là bản sao sẽ đồng bộ hóa lại sau mỗi lần khởi động lạnh, làm tăng độ trễ cho một vài yêu cầu đầu tiên.file:. Điều này vẫn cung cấp sự gần gũi về mặt địa lý.ALTER TABLE tiêu chuẩn. Đối với các di chuyển phức tạp hơn, hãy cân nhắc các công cụ như sqldef hoặc các tập lệnh tùy chỉnh.Một ứng dụng thương mại điện tử toàn cầu sử dụng Turso với cơ sở dữ liệu primary ở 'us-east' và các replica nhúng được triển khai trong các edge worker trên toàn thế giới. Một người dùng ở Sydney, Úc, thêm một mặt hàng vào giỏ hàng của họ (một thao tác write) và sau đó ngay lập tức điều hướng đến trang giỏ hàng (một thao tác read). Hồ sơ độ trễ có khả năng nhất cho hai thao tác này là gì?
Làm sạch log AI CLI, tạo biểu thức cron, giải mã JWT và tính quyền chmod offline.

Hướng dẫn toàn diện về các chiến lược database seeding hiện đại sử dụng Prisma và TypeScript, khám phá tính idempotency, tích hợp Faker.js, xử lý dữ liệu quan hệ phức tạp và tối ưu hóa hiệu suất cho các seed script lớn.
Đọc tiếp
Hướng dẫn toàn diện về việc di chuyển từ Node.js sang Bun 1.2 trong môi trường production: hiệu suất HTTP, SQLite & package full-stack với kiến trúc cấp độ production và các ví dụ code.
Đọc tiếp
Nắm vững các kiến trúc sharding cơ sở dữ liệu hiện đại: phân vùng ngang, khóa băm theo dải so với khóa băm nhất quán, kết nối liên shard, giao dịch phân tán (2PC so với Saga), Vitess và Citus.
Đọc tiếp