您现在的位置是:网站首页> 数据库

数据库相关技术咨询信息收集

摘要

数据库相关技术咨询信息收集


1.jpg


大数据时代,最全的数据同步总结

前端直用数据库Supabase

Supabase 网络数据库= 基于 PostgreSQL 的开源 BaaS(后端即服务)

Supabse自己部署

数据库RLS(Row-Level Security)

设置了RLS后,要管理所有数据怎么办



Supabase 网络数据库= 基于 PostgreSQL 的开源 BaaS(后端即服务)

准备工作:去 https://supabase.com新建项目,拿到:

- SUPABASE_URL

- SUPABASE_ANON_KEY(前端可用)

- SUPABASE_SERVICE_ROLE_KEY(只放后端)


## 一、数据库初始化(SQL Editor 执行)

业务表 `todos`,用户只能读写自己的待办

```

-- 1. 创建表

CREATE TABLE todos (

  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,

  title TEXT NOT NULL,

  done BOOLEAN DEFAULT false,

  user_id UUID NOT NULL DEFAULT auth.uid(),

  created_at TIMESTAMPTZ DEFAULT now()

);


-- 2. 开启RLS(必须!不开启=裸奔)

ALTER TABLE todos ENABLE ROW LEVEL SECURITY;


-- 3. 授予 authenticated 用户表权限

GRANT SELECT, INSERT, UPDATE, DELETE ON todos TO authenticated;


-- 4. RLS策略

-- SELECT:只能看自己

CREATE POLICY "select own todos" ON todos

FOR SELECT USING (auth.uid() = user_id);


-- INSERT:只能插入自己的数据

CREATE POLICY "insert own todos" ON todos

FOR INSERT WITH CHECK (auth.uid() = user_id);


-- UPDATE:只能改自己的

CREATE POLICY "update own todos" ON todos

FOR UPDATE USING (auth.uid() = user_id);


-- DELETE:只能删自己的

CREATE POLICY "delete own todos" ON todos

FOR DELETE USING (auth.uid() = user_id);

```


---


## 二、前端部分(Vite/React/Vue 通用 JS SDK)

### 1. 安装依赖

```

npm install @supabase/supabase-js

```


### 2. 初始化客户端 `src/lib/supabase.js`


```

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


const supabaseUrl = import.meta.env.VITE_SUPABASE_URL

const supabaseAnonKey = import.meta.env.VITE_SUPABASE_ANON_KEY


export const supabase = createClient(supabaseUrl, supabaseAnonKey, {

  auth: {

    // 生产推荐:cookie存储,规避XSS偷localStorage

    storage: window.location.hostname === 'localhost' ? localStorage : undefined,

    autoRefreshToken: true,

    persistSession: true,

    detectSessionInUrl: true

  }

})

```


`.env.local`


```

VITE_SUPABASE_URL="https://xxx.supabase.co"

VITE_SUPABASE_ANON_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

```


### 3. Auth 登录注册(前端)

```

// 注册,未登录情况下

export async function signUp(email, password) {

  const { data, error } = await supabase.auth.signUp({

    email,

    password

  })

  return { data, error }

}


// 密码登录

export async function signIn(email, password) {

  const { data, error } = await supabase.auth.signInWithPassword({

    email,

    password

  })

  return { data, error }

}


// 登出

export async function signOut() {

  const { error } = await supabase.auth.signOut()

  return { error }

}


// 获取当前用户

export async function getCurrentUser() {

  const { data: { user } } = await supabase.auth.getUser()

  return user

}

```


### 4. 前端 CRUD(重点:不需要手写 WHERE user_id=xxx,RLS 自动过滤)

```

// 查询我的待办

async function getTodos() {

  const { data, error } = await supabase

    .from('todos')

    .select('*')

    .order('created_at', { ascending: false })

  return { data, error }

}


// 新增待办

async function addTodo(title) {

  const { data, error } = await supabase

    .from('todos')

    .insert([{ title }])

    .select()

  return { data, error }

}


// 修改

async function updateTodo(id, done) {

  const { data, error } = await supabase

    .from('todos')

    .update({ done })

    .eq('id', id)

    .select()

  return { data, error }

}


// 删除

async function deleteTodo(id) {

  const { error } = await supabase

    .from('todos')

    .delete()

    .eq('id', id)

  return { error }

}

```


### 5. Realtime 实时订阅(websocket,数据变更自动推送到前端)

```

// 监听todos表变化,只收到RLS允许的自己的数据

const channel = supabase

  .channel('todos_channel')

  .on('postgres_changes', {

    event: '*',

    schema: 'public',

    table: 'todos'

  }, (payload) => {

    console.log('数据变更:', payload)

  })

  .subscribe()


// 取消订阅

// supabase.removeChannel(channel)

```


> ✅ 前端请求链路:

> 前端带 JWT → PostgREST 网关校验 JWT → 注入 `auth.uid()` → PG 执行 RLS 过滤 → 返回数据



## 三、后端部分:Supabase Edge Function(Deno,相当于你的后端接口)

> 什么时候要用 Edge Function?

> - 不能放前端的敏感逻辑(支付、第三方 API 密钥)

> - 复杂计算、批量任务

> - 需要绕过 RLS 读取全库(管理员后台)

> - 对接微信、短信、OpenAI 等外部服务


### 1. 本地 CLI 工具(先装 supabase cli)

```

# 安装cli

npm install -g supabase

# 登录

supabase login

# 关联项目

supabase link --project-ref 你的project-id

```


### 2. 创建 function


```

supabase functions new admin-stats

```


生成文件:`supabase/functions/admin-stats/index.ts`


```

import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'


// Deno环境自动读取环境变量

const supabaseUrl = Deno.env.get('SUPABASE_URL')!

const supabaseServiceKey = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!


Deno.serve(async (req) => {

  // 1. 校验前端传过来的JWT(拿到请求用户)

  const authHeader = req.headers.get('Authorization')

  if (!authHeader) return new Response('Unauthorized', { status: 401 })

  const jwt = authHeader.replace('Bearer ', '')


  // 【客户端A:用户上下文client,遵守RLS】

  const supabaseUserClient = createClient(supabaseUrl, Deno.env.get('SUPABASE_ANON_KEY')!, {

    global: { headers: { Authorization: `Bearer ${jwt}` } }

  })

  const { data: userData } = await supabaseUserClient.from('todos').select('*')

  console.log('用户自己的todos(受RLS限制)', userData)


  // 【客户端B:admin client,service_role,绕过RLS!管理员用】

  const supabaseAdmin = createClient(supabaseUrl, supabaseServiceKey)

  const { data: allTodos } = await supabaseAdmin.from('todos').select('*')

  console.log('全部todos,无视RLS', allTodos)


  return Response.json({

    my_todos: userData,

    all_todos: allTodos

  })

})

```


### 3. 部署

```

supabase functions deploy admin-stats --no-verify-jwt=false

```


### 4. 前端调用 Edge Function

```

// 调用后端接口,自动带上当前登录用户的JWT

const { data, error } = await supabase.functions.invoke('admin-stats', {

  method: 'GET'

})

console.log(data)

```

 

> ⚠️ Edge Function 安全重点:

> - `service_role_key` 在 function 环境变量里,**永远不会下发前端**

> - admin client 会绕过 RLS,只能做管理员任务,不要随便暴露给普通用户

> - 一定要校验 JWT,不要裸接口



## 四、Storage 文件存储(图片上传,同样支持 RLS)

```

// 上传文件到avatars桶

async function uploadAvatar(file) {

  const { data, error } = await supabase

    .storage

    .from('avatars')

    .upload(`public/${Date.now()}.png`, file, {

      cacheControl: '3600',

      upsert: false

    })

  return { data, error }

}


// 获取公开url

const { data } = supabase.storage.from('avatars').getPublicUrl('xxx.png')

```


Storage 桶也可以单独配置 RLS 策略,控制谁能读写文件。


---


## 五、两种开发模式对比(非常关键)


### 模式 A:纯前端直连(适合小项目、独立开发者)

前端 SDK → PostgREST → PG + RLS

✅ 不用写后端接口、开发极快

❌ 不适合敏感业务逻辑(支付、复杂风控)


### 模式 B:前端 + Edge Function(推荐生产)

前端 → Edge Function(后端逻辑) → 再决定用 user-client(RLS) /admin-client(绕过 RLS)

✅ 敏感逻辑收敛在服务端,可控性强

✅ 可以对接第三方服务

❌ 需要写 Deno TS 代码


---


## 六、安全红线清单(踩了就炸)

1. ❌ **service_role key 严禁写前端、严禁提交 git**

2. ✅ 所有业务表必须开启 RLS,忘记开 = 任何人拿 anon key 可以读写全表

3. ✅ RLS 策略 `WITH CHECK` 防止用户伪造 `user_id`

4. ✅ 前端优先使用 Cookie Auth(HttpOnly)防止 XSS 盗取 JWT

5. ❌ 不要写 `USING(true)` 测试策略上线忘记改(所有人可读)

6. ✅ Edge Function 里面区分两种 client:user client(受 RLS) /admin client(绕过 RLS)

7. ✅ CORS 在 Supabase 面板配置,限制域名来源


## 七、和传统后端架构对比

传统:前端 → Node/Java 后端(鉴权 + 手动拼接 WHERE)→ DB

Supabase:前端 → PostgREST 网关(JWT 校验)→ PG(RLS 自动过滤)


Supabse自己部署

**可以自托管(Self-host),完全开源**,底层整套组件(Postgres、Auth、PostgREST、Realtime、Storage、Edge Function、Studio 管理面板)都开源,官方主推 Docker Compose 方案,也有社区 K8s Helm 方案

> 重点区分两个东西:

> - `supabase cli start`:本地开发栈,**不适合直接对外暴露做生产**,没有做安全加固

> - 官方 self-host docker compose:生产自托管版本,是对外部署用的Supabase


## 最简部署步骤(官方 Docker 方式)

```

# 1. 拉取官方仓库

git clone --depth 1 https://github.com/supabase/supabase

mkdir supabase-prod

cp -rf supabase/docker/* supabase-prod/

cp supabase/docker/.env.example supabase-prod/.env


cd supabase-prod

```

然后**必须修改 `.env`**:

1. 把所有默认密钥全部重新生成(JWT secret、db 密码、anon key、service_role key,默认示例密钥是公开的,上线必炸)

2. `SUPABASE_URL` 填你的域名 `https://supabase.xxx.com`

3. 邮箱 SMTP 配置(注册验证码邮件,自托管没有托管邮件,要自己接 SendGrid / 阿里云邮件等)

4. Studio 管理员账号密码


```

# 拉镜像

docker compose pull

# 后台启动

docker compose up -d

```

启动完成:访问 `http://你的服务器:8000` 打开 Studio 面板Supabase



数据库RLS(Row-Level Security)

一句话:**在数据库层自动按规则过滤行,同一个 SELECT,不同用户看到不一样的数据**

## 通俗例子

一张 `orders` 表里存了所有商家订单,加 RLS 规则:`tenant_id = 当前登录商家ID`

- 商家 A 查订单:只能看到自己的行

- 商家 B 查订单:只能看到自己的行

- 管理员:可以看到全部

> 应用代码不用到处写 `WHERE tenant_id=xxx`,数据库引擎自动加上这个过滤条件


实际如何用代码里给例子

场景:多租户,表 `todos`,每个用户只能看 / 改自己的待办

表结构:

```

create table todos (

  id bigint primary key generated always as identity,

  title text not null,

  user_id uuid not null -- 归属用户id

);

```

> 前提:RLS 靠**会话变量**拿当前用户,PostgreSQL 常用 `current_setting('app.current_user_id')`,Supabase 是内置 `auth.uid()`


## 示例 1:原生 PG 版本(自己维护会话变量)

### 1. 开启表 RLS

```

ALTER TABLE todos ENABLE ROW LEVEL SECURITY;

```


### 2. 创建策略:查看自己的数据(SELECT)

```

CREATE POLICY todos_select_policy ON todos

FOR SELECT

USING (

  user_id = current_setting('app.current_user_id')::uuid

);

```


### 3. 创建策略:只能插入属于自己的数据(INSERT)

```

CREATE POLICY todos_insert_policy ON todos

FOR INSERT

WITH CHECK (

  user_id = current_setting('app.current_user_id')::uuid

);

```


### 4. 创建策略:只能更新自己的数据(UPDATE)

```

CREATE POLICY todos_update_policy ON todos

FOR UPDATE

USING (

  user_id = current_setting('app.current_user_id')::uuid

);

```


### 5. 删除策略

```

CREATE POLICY todos_delete_policy ON todos

FOR DELETE

USING (

  user_id = current_setting('app.current_user_id')::uuid

);

```


---


## 📌 后端代码怎么配合(Go + pgx 示例)

重点:**每次数据库连接,先 SET 会话变量**,这个变量就是 RLS 规则里读取的值


```

package main


import (

"context"

"github.com/jackc/pgx/v4/pgxpool"

)


func main() {

// 连接池

pool, _ := pgxpool.Connect(context.Background(), "postgres://xxx")


// 某个用户请求进来,userID = "00000000-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

userID := "71725c38-7374-4000-b170-132827100001"


// ✅ 关键一步:在这个会话里设置变量,RLS读取这个值

_, _ = pool.Exec(context.Background(),

"SET app.current_user_id = $1", userID)


// 正常查询,SQL不需要加 WHERE user_id = xxx!数据库自动过滤

rows, _ := pool.Query(context.Background(), "SELECT * FROM todos;")

// 拿到的永远只有该user_id的数据

}

```

> ⚠️ 坑:连接池复用!**SET 是会话级别的**,如果连接放回池里,变量残留,会串数据!

> 解决办法:

> 1. 事务内设置(`BEGIN` → SET → 查询 → COMMIT),事务结束变量消失

> 2. 或者使用 `SET LOCAL`,只在当前事务生效(推荐!)


```

-- SET LOCAL 仅当前事务有效,不会污染连接池

SET LOCAL app.current_user_id = $1

```


修改 Go 代码版本(安全版,SET LOCAL + 事务):


```

tx, _ := pool.Begin(context.Background())

// 本地变量,事务结束自动清除

_, _ = tx.Exec(context.Background(), "SET LOCAL app.current_user_id = $1", userID)

rows, _ := tx.Query(context.Background(), "SELECT * FROM todos")

tx.Commit(context.Background())

```


---


## 📌 Supabase 版本(最常用,不用自己 set 变量)

Supabase 内置 `auth.uid()`,不用手动设置会话变量


```

ALTER TABLE todos ENABLE ROW LEVEL SECURITY;


-- select策略

CREATE POLICY "Users can view own todos"

ON todos FOR SELECT

USING (auth.uid() = user_id);


-- insert策略

CREATE POLICY "Users can insert own todos"

ON todos FOR INSERT

WITH CHECK (auth.uid() = user_id);

```


前端 js 调用,只需要带 jwt token,SDK 底层自动把 uid 放到 PG 会话:


```

// supabase js

const { data } = await supabase.from('todos').select('*')

// 不用写 .eq("user_id", userId),RLS自动过滤

```


---


## 📌 SQL Server RLS 版本(不一样的写法,简单对比)

SQL Server 用安全谓词函数


```

-- 1. 创建过滤函数

CREATE FUNCTION dbo.fn_user_filter(@user_id uniqueidentifier)

RETURNS TABLE

AS RETURN SELECT 1 AS access_row WHERE @user_id = SUSER_SNAME();


-- 2. 绑定到表

CREATE SECURITY POLICY rls_todos_policy

ADD FILTER PREDICATE dbo.fn_user_filter(user_id) ON dbo.todos

WITH (STATE = ON);

```


---


# 重要避坑总结

1. `USING`:select/update/delete,**哪些行可见**

2. `WITH CHECK`:insert/update,**写入的数据必须满足条件**

3. 连接池场景优先 `SET LOCAL`,防止变量串用户

4. RLS 不会替换权限,表本身还是要有 `GRANT SELECT ON todos TO app_user;`

5. 超级用户(postgres 默认超级账号)**默认绕过 RLS**,测试的时候别用超级账号测!


设置了RLS后,要管理所有数据怎么办

方案一:RLS 策略增加管理员白名单(✅推荐,管理后台页面优先用)


ALTER TABLE todos ENABLE ROW LEVEL SECURITY;


DROP POLICY IF EXISTS "select own todos" ON todos;

CREATE POLICY "select own todos" ON todos

FOR SELECT

USING (

  -- 普通用户:只能看自己

  auth.uid() = user_id

  OR

  -- 管理员白名单

  auth.uid() IN (

    '00000000-0000-0000-0000-000000000001',

    '00000000-0000-0000-000000000002'

  )

);


DROP POLICY IF EXISTS "update own todos" ON todos;

CREATE POLICY "update own todos" ON todos

FOR UPDATE

USING (

  auth.uid() = user_id

  OR

  auth.uid() IN ('00000000-0000-0000-0000-000000000001')

);


DROP POLICY IF EXISTS "insert own todos" ON todos;

CREATE POLICY "insert own todos" ON todos

FOR INSERT

WITH CHECK (

  auth.uid() = user_id

  OR

  auth.uid() IN ('00000000-0000-0000-0000-000000000001')

);


DROP POLICY IF EXISTS "delete own todos" ON todos;

CREATE POLICY "delete own todos" ON todos

FOR DELETE

USING (

  auth.uid() = user_id

  OR

  auth.uid() IN ('00000000-0000-0000-000000000001')

);


管理员写死在 SQL 里,增减管理员要改 SQL;可以升级成 `profiles` 表存 `is_admin` 字段

-- 升级版本,从用户配置表判断管理员(更优雅)

USING (

  auth.uid() = user_id

  OR auth.uid() IN (select id from profiles where is_admin = true)

)




下一篇:数据库目录结构

Top