Supabase vs Firebase 2026：全面对比 — PostgreSQL vs NoSQL 如何选择

Supabase 和 Firebase 是 2026 年最流行的两个后端即服务（BaaS）平台，但它们代表着截然不同的理念。Supabase 是基于 PostgreSQL 的开源平台，提供完整的关系型数据库和 SQL 能力；Firebase 是 Google 的专有 NoSQL 平台，针对快速原型开发和移动端应用进行了优化。本指南从数据库架构、认证、存储、实时功能、定价、安全等各个方面进行对比，并附真实代码示例，帮助你做出正确选择。

理念与架构

Supabase 和 Firebase 的核心区别在于开源关系型 vs 专有 NoSQL。Supabase 封装了现有的开源工具 — PostgreSQL、GoTrue、PostgREST、Realtime 和 Storage — 提供统一的 API。你拥有自己的数据，可随时迁移或自托管。

Firebase 是 Google Cloud 服务的集合（Firestore、Authentication、Cloud Functions、Hosting、Cloud Storage），通过客户端 SDK 呈现。它与 Google Cloud 生态深度集成，提供 Analytics、Crashlytics、Remote Config、ML Kit 等 Supabase 没有的服务。

数据库：PostgreSQL vs Firestore

这是两个平台差异最大的地方。Supabase 提供完整的 PostgreSQL 数据库，拥有 SQL 的全部能力 — JOIN、聚合、窗口函数、CTE、全文搜索以及 PostGIS 等扩展。Firestore 是面向文档的 NoSQL 数据库，数据以集合和文档的形式存储。

以下是在两个平台上建模博客（用户、文章、评论）的方式：

Supabase：PostgreSQL Schema

-- Supabase: Relational schema with SQL
CREATE TABLE users (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  email TEXT UNIQUE NOT NULL,
  display_name TEXT,
  avatar_url TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE posts (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  author_id UUID REFERENCES users(id) ON DELETE CASCADE,
  title TEXT NOT NULL,
  content TEXT,
  published BOOLEAN DEFAULT false,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE comments (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  post_id UUID REFERENCES posts(id) ON DELETE CASCADE,
  author_id UUID REFERENCES users(id) ON DELETE CASCADE,
  body TEXT NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Complex query: Top 5 authors by comment count
SELECT u.display_name, COUNT(c.id) AS comment_count
FROM users u
JOIN posts p ON p.author_id = u.id
JOIN comments c ON c.post_id = p.id
WHERE p.published = true
GROUP BY u.id
ORDER BY comment_count DESC
LIMIT 5;

Firebase：Firestore 数据模型

// Firebase: Document-based NoSQL structure
// Collection: users/{userId}
{
  "email": "alice@example.com",
  "displayName": "Alice",
  "avatarUrl": "https://...",
  "createdAt": "2026-01-15T10:30:00Z"
}

// Collection: posts/{postId}
{
  "authorId": "user_abc123",
  "authorName": "Alice",  // Denormalized!
  "title": "My First Post",
  "content": "Hello world...",
  "published": true,
  "commentCount": 42,     // Denormalized counter!
  "createdAt": "2026-01-20T14:00:00Z"
}

// Subcollection: posts/{postId}/comments/{commentId}
{
  "authorId": "user_xyz789",
  "authorName": "Bob",    // Denormalized!
  "body": "Great post!",
  "createdAt": "2026-01-20T15:30:00Z"
}

// Note: "Top 5 authors by comments" requires
// a Cloud Function to aggregate across collections

查询能力对比：PostgreSQL 可以执行 Firestore 中不可能或成本极高的复杂查询。聚合、跨表 JOIN、子查询、窗口函数和递归 CTE 都原生支持。在 Firestore 中，通常需要反规范化数据（在文档间复制）并使用 Cloud Functions 处理基本查询以外的需求。

功能对比表

认证

两个平台都提供全面的认证方案。Supabase Auth（基于 GoTrue）和 Firebase Auth 都支持邮箱/密码、社交 OAuth、手机验证码和魔术链接。Firebase 还支持匿名认证，与 Google 登录集成更深。

Supabase Auth

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);

// Email/password sign up
const { data, error } = await supabase.auth.signUp({
  email: 'user@example.com',
  password: 'secure-password-123',
});

// OAuth (Google, GitHub, Discord, etc.)
const { data, error } = await supabase.auth.signInWithOAuth({
  provider: 'google',
  options: { redirectTo: 'https://myapp.com/callback' },
});

// Phone OTP
const { data, error } = await supabase.auth.signInWithOtp({
  phone: '+1234567890',
});

// Get current user
const { data: { user } } = await supabase.auth.getUser();

// Listen to auth state changes
supabase.auth.onAuthStateChange((event, session) => {
  console.log(event, session);
});

Firebase Auth

import { getAuth, createUserWithEmailAndPassword,
  signInWithPopup, GoogleAuthProvider,
  RecaptchaVerifier, signInWithPhoneNumber,
  onAuthStateChanged } from 'firebase/auth';

const auth = getAuth();

// Email/password sign up
const userCredential = await createUserWithEmailAndPassword(
  auth, 'user@example.com', 'secure-password-123'
);

// OAuth (Google)
const provider = new GoogleAuthProvider();
const result = await signInWithPopup(auth, provider);

// Phone auth
const recaptcha = new RecaptchaVerifier(auth, 'recaptcha', {});
const confirmation = await signInWithPhoneNumber(
  auth, '+1234567890', recaptcha
);
await confirmation.confirm('123456'); // OTP code

// Listen to auth state changes
onAuthStateChanged(auth, (user) => {
  if (user) console.log('Signed in:', user.uid);
  else console.log('Signed out');
});

Firebase Auth 在移动开发方面略有优势，提供预构建的 UI 组件（FirebaseUI）。Supabase Auth 对 Web 应用更友好，直接与行级安全策略集成。

存储对比

两个平台都提供带 CDN 的文件存储。Supabase Storage 基于 S3 兼容的对象存储，与 PostgreSQL 直接集成 — 可以对存储桶使用 RLS 策略。Firebase Cloud Storage 底层使用 Google Cloud Storage。

Supabase Storage

// Upload a file
const { data, error } = await supabase.storage
  .from('avatars')
  .upload('user-123/profile.png', file, {
    cacheControl: '3600',
    upsert: true,
  });

// Get public URL
const { data: { publicUrl } } = supabase.storage
  .from('avatars')
  .getPublicUrl('user-123/profile.png');

// Generate signed URL (time-limited access)
const { data: { signedUrl } } = await supabase.storage
  .from('private-docs')
  .createSignedUrl('report.pdf', 3600);

// Image transformation on the fly
const { data: { publicUrl: thumb } } = supabase.storage
  .from('avatars')
  .getPublicUrl('user-123/profile.png', {
    transform: { width: 200, height: 200, resize: 'cover' },
  });

Firebase Cloud Storage

import { getStorage, ref, uploadBytes,
  getDownloadURL } from 'firebase/storage';

const storage = getStorage();

// Upload a file
const storageRef = ref(storage, 'avatars/user-123/profile.png');
const snapshot = await uploadBytes(storageRef, file, {
  contentType: 'image/png',
  customMetadata: { uploadedBy: 'user-123' },
});

// Get download URL
const downloadUrl = await getDownloadURL(storageRef);

// Upload with progress tracking
const uploadTask = uploadBytesResumable(storageRef, file);
uploadTask.on('state_changed',
  (snapshot) => {
    const progress = (snapshot.bytesTransferred /
      snapshot.totalBytes) * 100;
    console.log('Upload: ' + progress + '%');
  },
  (error) => console.error(error),
  () => getDownloadURL(uploadTask.snapshot.ref)
);

实时功能

实时功能是 Firebase 成名之处。Firebase 实时数据库从一开始就为实时数据同步而设计。Supabase Realtime 由 Phoenix（Elixir）驱动，提供三种模式：Postgres Changes（监听数据库变更）、Broadcast（发布/订阅消息）和 Presence（跟踪在线用户）。

Supabase Realtime

// 1. Postgres Changes: Listen to database changes
const channel = supabase
  .channel('posts-changes')
  .on('postgres_changes',
    { event: '*', schema: 'public', table: 'posts' },
    (payload) => {
      console.log('Change:', payload.eventType, payload.new);
    }
  )
  .subscribe();

// 2. Broadcast: Pub/sub for ephemeral messages
const room = supabase.channel('room-1');
room.on('broadcast', { event: 'cursor' }, (payload) => {
  updateCursorPosition(payload.x, payload.y);
});
room.subscribe();
room.send({ type: 'broadcast', event: 'cursor',
  payload: { x: 100, y: 200 } });

// 3. Presence: Track online users
const presence = supabase.channel('online-users');
presence.on('presence', { event: 'sync' }, () => {
  const state = presence.presenceState();
  console.log('Online:', Object.keys(state).length);
});
presence.subscribe(async (status) => {
  if (status === 'SUBSCRIBED') {
    await presence.track({ user_id: 'abc', name: 'Alice' });
  }
});

Firebase 实时监听器

import { getFirestore, collection, query, where,
  onSnapshot, orderBy, limit } from 'firebase/firestore';

const db = getFirestore();

// Listen to a single document
const unsub = onSnapshot(doc(db, 'posts', 'post-1'),
  (doc) => {
    console.log('Current data:', doc.data());
  }
);

// Listen to a filtered query
const q = query(
  collection(db, 'posts'),
  where('published', '==', true),
  orderBy('createdAt', 'desc'),
  limit(20)
);

const unsubscribe = onSnapshot(q, (snapshot) => {
  snapshot.docChanges().forEach((change) => {
    if (change.type === 'added') {
      console.log('New post:', change.doc.data());
    }
    if (change.type === 'modified') {
      console.log('Updated:', change.doc.data());
    }
    if (change.type === 'removed') {
      console.log('Removed:', change.doc.id);
    }
  });
});

// Firebase also supports offline persistence
// Data is cached locally and synced when online
// enableIndexedDbPersistence(db); // Firestore
// enableNetwork(db) / disableNetwork(db)

Firebase 的离线持久化为移动应用提供了显著优势 — 数据在本地缓存，设备重新上线时自动同步。Supabase 没有内置离线支持。

Edge Functions vs Cloud Functions

Supabase Edge Functions 在 Deno 上运行于边缘节点（低延迟、全球分布）。Firebase Cloud Functions 在 Node.js 上运行于特定区域。Edge Functions 冷启动更快（约 50ms vs Cloud Functions 的 500ms-3s），但内存限制为 150MB。

Supabase Edge Function (Deno)

// supabase/functions/send-welcome-email/index.ts
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts';
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2';

serve(async (req) => {
  const { email, name } = await req.json();

  // Access Supabase with service role key
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
  );

  // Send email via Resend
  const res = await fetch('https://api.resend.com/emails', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + Deno.env.get('RESEND_API_KEY'),
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      from: 'hello@myapp.com',
      to: email,
      subject: 'Welcome, ' + name + '!',
      html: '<h1>Welcome to our app!</h1>',
    }),
  });

  return new Response(JSON.stringify({ sent: true }),
    { headers: { 'Content-Type': 'application/json' } });
});

// Deploy: supabase functions deploy send-welcome-email
// Cold start: ~50ms | Max memory: 150MB

Firebase Cloud Function (Node.js)

// functions/src/index.ts
import { onCall, HttpsError } from 'firebase-functions/v2/https';
import { onDocumentCreated } from
  'firebase-functions/v2/firestore';
import * as admin from 'firebase-admin';

admin.initializeApp();

// Callable function
export const sendWelcomeEmail = onCall(async (request) => {
  if (!request.auth) {
    throw new HttpsError('unauthenticated', 'Login required');
  }

  const { email, name } = request.data;
  // Send email with your preferred service
  await sendEmail(email, name);
  return { sent: true };
});

// Firestore trigger: runs when a new user doc is created
export const onUserCreated = onDocumentCreated(
  'users/{userId}',
  async (event) => {
    const userData = event.data?.data();
    await admin.messaging().send({
      topic: 'new-users',
      notification: {
        title: 'New user joined!',
        body: userData?.displayName + ' signed up',
      },
    });
  }
);

// Deploy: firebase deploy --only functions
// Cold start: ~500ms-3s | Max memory: 8GB

定价对比

定价是最大的差异化因素之一，往往是决定性因素。Firebase 按操作（读、写、删除）收费，可能导致不可预测的成本。Supabase 按计算资源和存储收费，成本更可预测。

以下是不同规模下的真实成本对比：

免费额度对比

预估成本：10,000 月活用户

预估成本：100,000 月活用户

预估成本：1,000,000 月活用户

关键洞察：Firebase 成本可能因读密集型操作而意外飙升。一个 Firestore 监听器在频繁更新的文档上每月可消耗数百万次读取。Supabase 定价更线性、更可预测，因为它基于计算和存储而非操作次数。

安全模型：RLS vs 安全规则

Supabase 使用 PostgreSQL 行级安全（RLS）— 用 SQL 编写的策略，在数据库层面强制执行。Firebase 使用安全规则 — 一种类 JSON 的自定义 DSL，在数据库外部的沙箱环境中评估。

Supabase 行级安全

-- Enable RLS on the posts table
ALTER TABLE posts ENABLE ROW LEVEL SECURITY;

-- Anyone can read published posts
CREATE POLICY "Public posts are viewable"
  ON posts FOR SELECT
  USING (published = true);

-- Users can only insert their own posts
CREATE POLICY "Users can create own posts"
  ON posts FOR INSERT
  WITH CHECK (auth.uid() = author_id);

-- Users can only update/delete their own posts
CREATE POLICY "Users can update own posts"
  ON posts FOR UPDATE
  USING (auth.uid() = author_id);

CREATE POLICY "Users can delete own posts"
  ON posts FOR DELETE
  USING (auth.uid() = author_id);

-- Admin role can do everything
CREATE POLICY "Admins have full access"
  ON posts FOR ALL
  USING (EXISTS (
    SELECT 1 FROM user_roles
    WHERE user_id = auth.uid() AND role = 'admin'
  ));

Firebase 安全规则

// firestore.rules
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {

    // Posts collection
    match /posts/{postId} {
      // Anyone can read published posts
      allow read: if resource.data.published == true;

      // Authenticated users can create posts
      allow create: if request.auth != null
        && request.resource.data.authorId
           == request.auth.uid;

      // Only the author can update/delete
      allow update, delete: if request.auth != null
        && resource.data.authorId
           == request.auth.uid;

      // Comments subcollection
      match /comments/{commentId} {
        allow read: if true;
        allow create: if request.auth != null;
        allow update, delete:
          if request.auth.uid
             == resource.data.authorId;
      }
    }

    // Admin override using custom claims
    match /{document=**} {
      allow read, write:
        if request.auth.token.admin == true;
    }
  }
}

RLS 优势：策略是 SQL（熟悉）、在数据库层面强制执行（无法绕过）、可与视图和函数组合。Firebase 规则优势：初学更容易、支持文档路径模式匹配、内置验证。

TypeScript 支持

Supabase 在这方面有重大优势。Supabase CLI 可以直接从 PostgreSQL schema 生成 TypeScript 类型（supabase gen types typescript）。每个查询返回正确类型化的结果。Firebase 需要手动类型定义或 Zod 验证等第三方工具。

// Supabase: Auto-generated types
// Run: supabase gen types typescript --local > types/supabase.ts

import { createClient } from '@supabase/supabase-js';
import type { Database } from './types/supabase';

const supabase = createClient<Database>(URL, KEY);

// Fully typed! IDE knows the shape of every table
const { data: posts } = await supabase
  .from('posts')         // autocomplete table names
  .select('id, title, users(display_name)') // typed joins
  .eq('published', true); // typed filter values

// posts is typed as:
// { id: string; title: string;
//   users: { display_name: string } | null }[]

// ---- Firebase: Manual types ----
// You must define interfaces yourself
interface Post {
  authorId: string;
  title: string;
  content: string;
  published: boolean;
  createdAt: Timestamp;
}

// Type assertion required on every query
const snapshot = await getDocs(
  collection(db, 'posts') as CollectionReference<Post>
);
const posts = snapshot.docs.map(doc => doc.data());

自托管与供应商锁定

Supabase 可以使用 Docker Compose 完全自托管。整个技术栈 — PostgreSQL、GoTrue、PostgREST、Realtime、Storage、Studio — 都是开源的。这意味着零供应商锁定：你的数据在标准 PostgreSQL 数据库中，可迁移到任何 PostgreSQL 主机。

# Self-host Supabase with Docker Compose
git clone https://github.com/supabase/supabase
cd supabase/docker
cp .env.example .env
# Edit .env: POSTGRES_PASSWORD, JWT_SECRET, SITE_URL, SMTP

docker compose up -d

# Services: PostgreSQL (:5432), PostgREST (:3000),
# GoTrue Auth (:9999), Realtime (:4000), Storage (:5000),
# Studio (:3000), Kong API Gateway (:8000)

Firebase 无法自托管。你的数据存在 Google Cloud 中，迁移需要大量工作。Firestore 数据必须导出为 JSON/CSV 并转换为其他数据库格式。Cloud Functions 必须重写。认证提供商必须重新配置。

框架集成

两个平台都为主流框架提供 SDK，但开发体验有所不同：

性能基准

性能因查询模式、数据量和区域配置而异。以下是常见操作的典型基准：

何时选择 Supabase

迁移指南：Firebase 迁移到 Supabase

随着项目增长需要 SQL 能力，从 Firebase 迁移到 Supabase 是常见路径。以下是高层迁移指南：

生产环境最佳实践

Supabase 生产建议

• 在每个表上启用 RLS — 即使你认为没必要
• 使用数据库迁移（Supabase CLI）而非手动修改 schema
• 为无服务器环境设置连接池（PgBouncer）
• 使用 pg_stat_statements 监控查询性能
• 使用 Edge Functions 处理 webhook 和 API 路由
• 为生产数据库启用时间点恢复
• 设置数据库备份并测试恢复流程
• 对读密集型工作负载使用只读副本

Firebase 生产建议

• 部署前务必设置安全规则 — 默认开放规则是安全风险
• 主动为复杂查询创建复合索引
• 仔细监控 Firestore 用量以避免账单飙升
• 批量操作使用批量写入（每批最多 500 个）
• 为频繁读取的数据启用 Firestore bundle 生成
• 使用 Cloud Functions 2nd gen 获得更好性能
• 仅在需要时启用离线持久化（会增加 SDK 大小）
• 使用 Firebase App Check 防止 API 滥用

社区与生态

Firebase 拥有更大更成熟的生态，已有 8 年以上的生产使用历史。Supabase 社区增长迅速，文档优秀，Discord 活跃成员超过 30,000。Supabase 的开源特性意味着社区贡献了扩展、工具和自托管指南。

常见问题