Turso & libSQL: SQLite phân tán với các bản sao nhúng cho backend độ trễ thấp

Giới thiệu: Sự cần thiết của Cơ sở dữ liệu biên

Để đạ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.

Tổng quan kiến trúc: Mô hình Primary-Replica với nhúng biên

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ộ.

Các thành phần kiến trúc chính:

1. Cơ sở dữ liệu chính Turso: Nguồn dữ liệu đáng tin cậy cho tất cả dữ liệu, chịu trách nhiệm cho các hoạt động ghi và truyền các thay đổi đến các bản sao. Thường được triển khai ở một khu vực trung tâm.
2. Bản sao chỉ đọc Turso: Các phiên bản cơ sở dữ liệu được phân phối theo địa lý, nhận các bản cập nhật từ bản chính. Đây có thể là các bản sao truyền thống được lưu trữ trên đám mây hoặc được nhúng trong các quy trình ứng dụng.
3. Thư viện máy khách libSQL: Giao diện phía máy khách để tương tác với cơ sở dữ liệu Turso. Hỗ trợ cả kết nối từ xa và các bản sao nhúng cục bộ.
4. Worker/Ứng dụng biên: Môi trường tính toán (ví dụ: Cloudflare Workers, Vercel Edge Functions, Fly.io Machines) nơi bản sao nhúng libSQL cư trú.

Luồng dữ liệu:

• Ghi: Tất cả các hoạt động ghi được định tuyến đến cơ sở dữ liệu chính Turso. Máy khách libSQL xử lý việc ủy quyền này một cách minh bạch hoặc rõ ràng.
• Đọc: Các hoạt động đọc được phục vụ ưu tiên bởi bản sao gần nhất hoặc được nhúng. Nếu một bản sao được nhúng có sẵn và được cập nhật, các thao tác đọc là cục bộ. Nếu không, chúng sẽ quay trở lại một bản sao từ xa hoặc bản chính.
• Sao chép: Bản chính sao chép dữ liệu không đồng bộ đến tất cả các bản sao được kết nối. Turso tận dụng cơ chế sao chép dựa trên nhật ký ghi trước (WAL), đảm bảo tính nhất quán cuối cùng cho các bản sao.

Thiết lập Turso & libSQL

Đầ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.

Khởi tạo máy khách libSQL

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

Các bản sao nhúng cho các thao tác đọc dưới 5ms

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.

Triển khai với Cloudflare Workers (Ví dụ)

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:

• Truy cập hệ thống tệp: Các bản sao nhúng thực sự yêu cầu quyền truy cập hệ thống tệp liên tục. Cloudflare Workers thường không cung cấp trực tiếp điều này cho các yêu cầu riêng lẻ. Các giải pháp bao gồm:
  • Durable Objects: Một Durable Object có thể quản lý một máy khách libSQL và tệp cục bộ của nó, hoạt động như một bản sao đơn thể cho một phạm vi cụ thể.
  • Dự phòng bản sao từ xa: Đối với các môi trường không có bộ nhớ cục bộ liên tục, hãy cấu hình 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ý.
  • Vercel Edge Functions (Node.js Runtime): Chúng có thể ghi vào /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.
• Chiến lược đồng bộ hóa: 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.

Đo lường độ trễ đọc cục bộ dưới 5ms

Để 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.

Ủy quyền ghi cho các nút chính

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ẽ.

Đồng bộ hóa ưu tiên ngoại tuyến

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ừ Neon/Supabase PostgreSQL

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.

1. Chuyển đổi lược đồ

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:

• Kiểu dữ liệu: 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).
• ID tự động tăng: PostgreSQL sử dụng SERIAL hoặc GENERATED BY DEFAULT AS IDENTITY. SQLite sử dụng INTEGER PRIMARY KEY AUTOINCREMENT.
• Hàm: Nhiều hàm dành riêng cho PostgreSQL (ví dụ: 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.
• Ràng buộc: Các ràng buộc CHECK, FOREIGN KEY được hỗ trợ, nhưng hành vi có thể hơi khác.
• Chỉ mục: Cú pháp 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
);

2. Xuất & Nhập dữ liệu

1. 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.

   bashCopy

   pg_dump -d your_db_name -t users --data-only --column-inserts > users_data.sql
   

   Hoặc, đối với CSV:

   sqlCopy

   COPY users TO '/tmp/users.csv' WITH (FORMAT CSV, HEADER);
   

2. 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.

     typescriptCopy

     // 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.

     bashCopy

     # Via Turso CLI
     turso db shell my-edge-app-db < users_data_sqlite_compatible.sql
     

So sánh: Turso (libSQL) so với PostgreSQL (Neon/Supabase)

Những vấn đề và cách khắc phục trong sản xuất

1. Lỗi "Database is locked":
   • Nguyên nhân: SQLite là cơ sở dữ liệu dựa trên tệp. Các thao tác ghi đồng thời từ nhiều quy trình hoặc luồng vào cùng một tệp SQLite cục bộ có thể gây ra các vấn đề khóa.
   • Cách khắc phục:
     • Đảm bảo chỉ có một phiên bản libsql-client quản lý một tệp cơ sở dữ liệu cục bộ cụ thể.
     • Đối với các môi trường biên có độ đồng thời cao, hãy cân nhắc sử dụng trực tiếp URL bản sao Turso từ xa thay vì tệp cục bộ, hoặc tận dụng Durable Objects để đảm bảo một người ghi duy nhất.
     • Tăng 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' }).
2. Đọc cũ từ các bản sao biên:
   • Nguyên nhân: syncInterval quá cao, hoặc bản sao chưa đồng bộ hóa gần đây.
   • Cách khắc phục:
     • Giảm syncInterval để có dữ liệu cập nhật hơn.
     • Kích hoạt thủ công 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ể.
     • Đối với các thao tác đọc yêu cầu độ mới tuyệt đối, hãy định tuyến chúng trực tiếp đến cơ sở dữ liệu chính.
3. Thiếu TURSO_DATABASE_URL hoặc TURSO_AUTH_TOKEN:
   • Nguyên nhân: Các biến môi trường không được đặt đúng cách trong môi trường triển khai (ví dụ: Vercel, Cloudflare, Fly.io).
   • Cách khắc phục: Kiểm tra lại cấu hình biến môi trường cho nền tảng cụ thể của bạn. Đảm bảo chúng có thể truy cập được trong thời gian chạy.
4. Các vấn đề về URL file: trong serverless/edge:
   • Nguyên nhân: Các hàm serverless thường có hệ thống tệp tạm thời hoặc bị hạn chế. Ghi vào các đường dẫn tùy ý có thể thất bại hoặc bị mất giữa các lần gọi.
   • Cách khắc phục:
     • Đối với Cloudflare Workers, sử dụng Durable Objects để quản lý trạng thái liên tục cho bản sao.
     • Đối với Vercel Edge Functions, /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.
     • Nếu không thể duy trì cục bộ thực sự, hãy kết nối trực tiếp với URL bản sao chỉ đọc Turso từ xa thay vì URL file:. Điều này vẫn cung cấp sự gần gũi về mặt địa lý.
5. Độ trễ ghi quá cao:
   • Nguyên nhân: Cơ sở dữ liệu chính cách xa về mặt địa lý so với hàm biên của bạn, hoặc đường dẫn mạng bị tắc nghẽn.
   • Cách khắc phục:
     • Đảm bảo bản chính Turso của bạn nằm trong một khu vực gần về mặt địa lý với phần lớn lưu lượng ghi của bạn.
     • Tối ưu hóa ứng dụng của bạn để giảm thiểu các hoạt động ghi, hoặc nhóm chúng lại nếu có thể.
     • Cân nhắc một mô hình nhất quán khác (ví dụ: CRDTs) nếu tính nhất quán mạnh mẽ cho các thao tác ghi không thực sự cần thiết và độ trễ ghi thấp là tối quan trọng, mặc dù điều này làm tăng đáng kể độ phức tạp.

Các câu hỏi thường gặp

1. Tôi có thể sử dụng Turso cho các truy vấn phân tích không? Có, Turso hỗ trợ SQL tiêu chuẩn. Đối với các truy vấn phân tích phức tạp, bạn có thể chạy chúng trên một bản sao chỉ đọc chuyên dụng hoặc bản chính. Tuy nhiên, đối với phân tích quy mô rất lớn, một giải pháp OLAP chuyên dụng có thể phù hợp hơn.
2. Turso xử lý các di chuyển lược đồ như thế nào? Các di chuyển lược đồ được áp dụng cho cơ sở dữ liệu chính. Các bản sao cuối cùng sẽ bắt kịp. Bạn có thể sử dụng các câu lệnh SQL 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.
3. Điều gì xảy ra nếu cơ sở dữ liệu chính bị lỗi? Các thao tác ghi sẽ thất bại. Các thao tác đọc từ các bản sao hiện có, đã đồng bộ hóa sẽ tiếp tục hoạt động, nhưng chúng sẽ ngày càng cũ hơn. Turso cung cấp tính khả dụng cao cho các bản chính, nhưng trong một sự kiện thảm khốc, tính khả dụng ghi sẽ bị ảnh hưởng cho đến khi bản chính được khôi phục hoặc một bản chính mới được thăng cấp.
4. Turso có phù hợp với khối lượng công việc giao dịch cao không? Turso vượt trội trong các khối lượng công việc đọc cao, độ trễ thấp ở biên. Đối với các khối lượng công việc ghi giao dịch cực kỳ cao (hàng nghìn thao tác ghi mỗi giây vào một bảng duy nhất), mô hình một bản chính có thể trở thành nút thắt cổ chai. Tuy nhiên, đối với hầu hết các ứng dụng web, bản chính của Turso có thể xử lý thông lượng ghi đáng kể.
5. Làm cách nào để giám sát cơ sở dữ liệu Turso của tôi? Turso cung cấp một bảng điều khiển với các số liệu cho các hoạt động đọc/ghi, lưu trữ và trạng thái sao chép. Bạn cũng có thể tích hợp với các công cụ giám sát bên ngoài bằng cách thu thập nhật ký và số liệu từ các phiên bản ứng dụng của bạn.