零代码 / 低代码 搭建笔记

用零代码,自己搭一套能跑的 ERP

作者:制造业 · 分管过信息化 / 工程 / 品质 / 行政 文章:18 篇

技术文章

Notes

基座(一):先定骨架,这套零代码 ERP 分四层

2026-09-14

我第一版是直接写表单渲染,写到一半发现改一个字段要动三处代码,返工了。后来把系统切成四层,每层只管一件事。定位是自己用、一台小机器、一个进程,数据层就用了 SQLite:一个文件、一个对象一张表,装完就能跑,备份就是拷文件。

架构基座SQLite
展开全文

零代码的麻烦大多不在功能多少,在改一个配置要牵动几处逻辑。同样一处改动,落在不同层上,代价差很多。所以先划层次,把改动限制在一层里,功能往后放。

四层各管什么

配置层业务对象、字段 schema、列表视图、审批流定义。纯数据,可随时改
数据层SQLite:库就是一个文件,一个业务对象一张表
服务层Node 进程。鉴权、路由、引擎(表单求值、审批推进、权限判定)
接入层Nginx。静态页、同源反代、访问日志

分层的用处是让出错的地方有个范围。渲染错了 → 配置层;查得慢 → 数据层;权限绕过了 → 服务层;反代 502 → 接入层。排查从第一天起就不用全链路找。

为什么用 SQLite

定位很简单:一台小机器、一个进程、自己部署,不另起数据库服务。这样库也就没得挑。

  • 不要服务:不装数据库进程、不建用户、不管端口,一个文件跟着代码走,装机的步骤少一半;
  • 备份即拷文件:出问题换个文件就回滚,改坏了成本极低;
  • 写入压力很小:只有一个 Node 进程、没有后台任务,同时写的人基本为零。

这两条代价要一起记下来:写永远是单写者,改字段要动表结构。选了它就得认下这两条,它们本来就在那儿。

目录也按四层切

/opt/app       代码(可整目录替换,升级不动数据)
/opt/data      库文件(起步是 SQLite 单文件)、附件、运行流水
/opt/secrets   口令文件,权限 600
/opt/node22    Node 运行时(解压版,不依赖系统包)

三条一开始就该守的红线

  • 别把渲染逻辑塞进服务层:为了“少一次请求”在接口里拼 HTML,最后一套表单两种渲染路径,改一处忘一处;
  • 别把数据范围的判断散在 SQL 里:条件散在几十条语句里,漏一条就是越界取数,应该只在数据访问入口加;
  • 别把业务规则写进视图配置:视图只管“怎么显示”,一旦把“能不能审批通过”写进去,换个入口就失效。

骨架立完,剩下的是装环境、分目录、让服务常驻,然后把第一个模块配出来。

基座(二):装运行环境,Node 用解压版,库是一个 SQLite 文件

2026-09-18

起步只要两样:一个跑得起来的 Node,一个空文件。这时候还没有数据库服务,也没有数据库用户要建。

部署NodeSQLite
展开全文

一、Node 装解压版,不装包

tar -xJf node-v22.x.x-linux-x64.tar.xz -C /opt
mv /opt/node-v22.x.x-linux-x64 /opt/node22
ln -sf /opt/node22/bin/node /usr/local/bin/node
ln -sf /opt/node22/bin/npm  /usr/local/bin/npm
node -v && npm -v

好处是版本切换只是改一条软链,不污染系统包。用发行版自带的 Node 有个隐患:机器上可能同时存在两三个版本,which node 和进程实际用的那个经常对不上。

二、库:一个文件,打开 WAL

sqlite3 /opt/data/app.db "pragma journal_mode=wal;"
sqlite3 /opt/data/app.db "pragma synchronous=normal;"
sqlite3 /opt/data/app.db "pragma integrity_check;"   # 期望 ok

WAL 让读不被写卡住:默认的 rollback journal 里,一次写入会把读也顶住。但它改不了一件事:写只有一个写者。单进程提交,这个限制等于不存在;一旦有两个进程同时写,就开始排队。

三、swap 先划一块

fallocate -l 1G /opt/swap && chmod 600 /opt/swap
mkswap /opt/swap && swapon /opt/swap
echo "/opt/swap none swap sw 0 0" >> /etc/fstab

它不是性能手段,只在编译原生模块、跑备份这种峰值时刻顶一下。没有它,OOM 直接杀进程。

四、三个容易绊住的默认值

  • PATH:守护方式不读 .bashrc,/opt/node22/bin 得在启动时显式给,否则起不来还看不出原因;
  • 原生模块:SQLite 的驱动也是按 Node ABI 编译的二进制,换 Node 版本必须重编(npm rebuild --build-from-source),编译加 --jobs=2,否则机器自己把自己顶死;
  • 时区:默认是 UTC,必须显式给 TZ,否则单据时间整体偏 8 小时。

验收标准

不看命令有没有报错,看三样:进程手工能跑通、curl 本机端口有响应、重启后能自动拉起。这样环境就齐了:一个能跑的 Node,一个空文件库。

基座(三):代码、数据、密钥,必须放在三个地方

2026-09-21

目录规划看着是小事,实际定下的是升级时能不能只换代码、备份时能不能只备数据、密钥会不会跟着代码流出去。

目录规划密钥备份边界
展开全文
/opt/app/          代码 + 依赖 + 原生模块
/opt/data/         库文件、附件、运行流水、临时导出
/opt/secrets/      接口凭证、签名密钥(chmod 600)

为什么必须分开

  • 升级:换版本时只替换 /opt/app,数据与密钥一动不动,回滚也只是把旧目录换回来;
  • 备份:数据目录每天备,代码用版本管理或打包,密钥单独离线保管。三者混在一起,备份包就成了“谁拿到谁全有”;
  • 交付:要交给别人自部署时,代码包和密钥包分开给,权限边界一眼可见。

密钥的正确用法

umask 077
openssl rand -hex 32 > /opt/secrets/app_key
chmod 600 /opt/secrets/app_key

库本身就是个文件,这会儿没有数据库口令要管;这个目录先立着,签名密钥、以后要接的第三方凭证都往这里放。规矩只有一条:权限 600,属主是运行应用的那个用户,值不进代码、不进日志。

踩过的坑:早期用 root 跑应用,密钥文件 600 也没意义:进程本身就是最高权限,任何代码漏洞都等于整机失守。

目录分完之后,各放什么

代码可整目录替换;升级、回滚都不碰数据与密钥
数据库、附件、流水;备份只备这里,恢复也只还原这里
密钥口令与接口凭证;600 权限,不进版本库,不进备份包

边界定死之后,升级和搬家就是换目录、重启、探活,出问题把旧目录换回来。有一个文件放错地方,这两件事就只能靠猜。

还有一个细节:/opt/data 里不要放任性增长的东西(日志、导出包),否则备份包会从几兆涨到几个 G,最后没人愿意备。该轮转的轮转,该清定时清。

基座(四):让服务常驻,用 systemd、只听本机、探活探到底

2026-09-24

手工能跑起来,和放一个月不出事,中间隔着三处配置:谁拉起它、它监听哪、怎么判断它还活着。

systemd探活日志
展开全文

用一个 unit,不用一堆脚本

[Unit]
Description=App service
After=network.target

[Service]
Type=simple
ExecStart=/opt/node22/bin/node /opt/app/server.js
WorkingDirectory=/opt/app
Restart=always
RestartSec=3
User=appuser
Environment=NODE_ENV=production
Environment=PATH=/opt/node22/bin:/usr/local/bin:/usr/bin:/bin
Environment=TZ=Asia/Shanghai

[Install]
WantedBy=multi-user.target

Restart=always 是底线:进程崩溃、被 OOM 杀掉,3 秒后自动回来。TZ 必须显式给,否则精简系统或预置镜像里时区默认是 UTC,单据时间会整体偏 8 小时。这种错最不容易发现,因为系统“看起来”一切正常。

只监听 127.0.0.1

应用端口只绑 127.0.0.1,对外一律经 Nginx。好处:除 Nginx 之外的口,在局域网里也碰不到;反正这台机器没有固定公网 IP,外面本来就进不来,能少开一个是一个;限流、日志、访问控制这些统一在接入层做,应用只关心业务。

探活要探到底层依赖

探活最容易写成“返回 200 就算活着”。库文件读不了、库被锁住的时候,HTTP 照样 200,这种探活等于没做。我的 /healthz 会真的执行一次 select 1:

{"ok": true, "db": {"ok": true}}

只要 db.ok 是 false,整个接口返回 503。探活要回答的是能不能服务;进程在不在,是另一回事。

配置只留一处真源

最初用 .env,很快出事:同一台机器上两个入口、两套工作目录,读到的 env 不是同一份。收进这个 unit 的 Environment= 之后只剩一处,systemctl cat 就能看到进程实际拿到的全部配置。

升级带自动回滚

换版本的标准流程:备份旧目录 → 替换代码 → 重启 → 轮询 /healthz,25 秒内不通就还原旧目录并重启。有这条兜底,升级动作才敢在白天做,不用等半夜。

日志别只丢 journal

journal 方便但会被轮转掉,排查三天前的问题就没了。应用日志写到固定文件 + 按天切分,访问日志交给 Nginx,两边各自轮转,互不干扰。

基座(五):第一个模块从零配起来,以采购申请为例

2026-09-28

骨架搭好后,拿一个最小的真实业务跑通全链路:建对象、定字段、配列表、配表单、配审批、配权限。跑通这一个,后面所有模块都是同一套动作。

模块配置实战采购申请
展开全文

1. 建对象

采购申请:collection = purchase_request。名字一旦上线就别改。它同时是表名的一部分、接口路径的一部分、历史记录里的键。要改名就新建一个对象做迁移,别原地改。

2. 定字段

申请人关联用户,默认当前登录人,锁定不可改
申请部门下拉,取部门档案
需求日期日期,默认今天 +7
明细子表:物料、规格、数量、单位、预估单价、用途
合计金额由子表计算,只读

几个细节:金额这类计算字段必须由后端算,前端算只用于展示;子表里的“物料”要关联档案而不是自由文本,否则后面没法汇总;每个字段的 key 用英文短名,别用中文当键,中文键在 URL、导出、接口里到处都是坑。

3. 配列表视图

默认筛选“我提交的 / 待我审批的”两个 tab,列只留 6 个:单号、申请人、部门、需求日期、金额、状态。列表页别把所有字段铺出来。加载慢、看着累,用户还是找不到重点。

4. 配表单

分三组:基本信息、需求明细、附件。子表限制 2 层递归(子表里再嵌子表),不然渲染成本指数上升。

5. 配审批流

节点:部门主管 → 采购经理 → 财务(金额 ≥ 5000 才走)。条件写“字段比较”,不要写“人名”,写人名的那一刻,这个人离职流程就断了。审批人用角色或“发起人的上级”,让组织变动自己生效。

6. 配权限

谁能建、谁能看全部、谁只能看自己的、谁能改草稿。这一层不做行级过滤的完整体系,只做“本人/本部门/全部”三档,够用,而且用户配得明白。

跑通标准:从登录、提交、驳回、修改再提交、审批通过、生成下游单据,走完不报错、历史可追溯,这个模块才算完成。第一个模块花的时间最久,第二个开始就是复制这套动作。

基座(六):一个模块配完,我会检查这十条

2026-10-01

配完看着对、用起来不对,是我遇到最多的一类问题。所以每配完一个模块,跑一遍下面这十项。

自检清单上线权限
展开全文

模块能点通,不代表能上线。每配完一个,我固定跑十项检查,半小时,挡掉大部分“第二天就出问题”的情况。十条分三组:会不会把数据弄错、会不会漏权限、会不会把流程卡死。

  • 必填的后端也拦:只在前端加星号,接口直连能提交空值,报表立刻脏;
  • 越权直连接口:拿低权限账号的 token 直接 POST 别人的单据,能过就是洞;
  • 列表默认筛选:没有默认筛选的系统,一上线就是几千条往外吐;
  • 并发编辑:两个人同时改一张单,后保存的不该默默覆盖前者;
  • 删除是不是软删:删了就查不到的单据,对账时无法解释,我默认软删 + 状态;
  • 附件大小与类型:client_max_body_size 默认 1 M,附件一传就 413,这个必调;
  • 审批流有没有“无人可审”:角色里一个成员都没有时,单据会永久卡住,要有兜底审批人;
  • 时区:进程 TZ 必须显式给,存进单据的时间要统一按这个时区换算,否则跨零点提交的单据日期会错一天;
  • 日志有没有带敏感信息:手机号、身份号、口令不能明文落盘,脱敏要在写入前做;
  • 探活是否探到底层:只返回 200 的 healthz,等于没装监控。

两项最容易被当成小事

并发编辑:听起来是小概率,实际在车间很常见:审批人退回的同时,申请人正在改同一张单。做法是保存时带版本号,提交的版本小于当前版本就提示“已被修改”,不要静默覆盖。覆盖的后果很难查,单据看着对,内容却少了几个字。

无人可审:角色是配出来的,配的时候没人,跑起来就永久卡住。兜底规则很简单:节点解析出的审批人为空,就把单据转到上一级管理员,同时记一条“兜底”事件,事后能查出是哪个节点没人。

整套跑一遍不到半小时。多数“第二天出问题”的事,在这半小时里能撞见。

临时租户的自动回收:定时任务怎么设计才不误删

2026-10-02

演示租户到期得清,清错了就是事故。我的做法是到期先只标记,删除做成幂等,删之前留一条审计。

定时任务幂等审计
展开全文

设计原则

  • 先标记后删除:到期先写 expired 状态,过一小时再真正删,中间留人工干预窗口;
  • 删除必须幂等:重复执行不报错、不重复删;删除失败要重试,不能一失败就丢掉任务;
  • 白名单:正式租户永远不在回收名单里,判断依据是租户类型字段,不是命名约定;
  • 留审计:每次创建/删除写一条脱敏流水,出了问题能追溯,同时不留个人敏感信息。

跑在进程里还是独立 cron?我倾向放应用启动时注册一个每小时执行的定时器,并 unref() 避免占住事件循环。这样部署只有一个进程,少一个会忘记配置的 crontab。

日志脱敏这件事容易被忽略:流水里如果直接落手机号,等于给个人信息开了个永久副本。写入前就把中间四位打码。

回收分两步,中间留一小时

下面按换库之后的语句写。早先在 SQLite 上跑的是同一套逻辑,只是语句要换写法。

-- 每小时:先标记,不删
update tenants set status='expired', expired_at=now()
where type='trial' and expires_at < now();

-- 再过一小时:真删,只删已标记的
delete from records r using tenants t
where r.company_code = t.code
  and t.status = 'expired'
  and t.expired_at < now() - interval '1 hour';

那一小时是给人留的:对方刚续期、或者误建了租户,改个状态就停住。一旦真删了,恢复只能从备份里捞,代价完全不同。

怎么确认它真的在跑

定时任务最常见的问题是静默不执行,连报错都没有。我的做法是每次执行都写一条摘要流水:扫到几个到期、标记几个、删掉几个。连续两天一条记录都没有,就是进程没在跑,比等用户来投诉早。

从 SQLite 迁到 PostgreSQL:做完善之后才下的决心

2026-10-04

前面六篇跑完,功能是通的,库一直是 SQLite。10-01 那天我把 SQLite 大概能撑多少、撑不住多少写在纸上:要商业化,多个租户同时写、几百个用户、还要能在线备份,这几样它顶不住。库里没出过故障,是我自己算账算出来的。

迁移SQLitePostgreSQL
展开全文

骨架、常驻、第一个模块、上线自检都走了一遍,能用;临时租户的回收也能跑。这时候才回头想一个问题:如果继续往“给别人用”的方向走,库要不要换。

算账:SQLite 撑得住什么,撑不住什么

  • 写单写者:一个文件同一时刻只有一个写者。自己用、单进程,等于没有限制;一旦多个租户、定时任务、批量导入同时来,就是排队;
  • 改字段要动表:一个业务对象一张表,字段一变就要 ALTER TABLE,线上改结构比换代码危险得多;
  • 备份是拷文件:自己用很方便,但要做到“每天自动备、出问题能恢复到某一时刻”,靠拷文件拼不起来。

这三条现在都还过得去,是规模上来才撑不住。所以当成升级来做:功能照跑,挑个不忙的时候换。

第零步:装 PostgreSQL,建独立库和独立用户

apt install postgresql -y
sudo -u postgres psql -c "create user app with password '从文件读';"
sudo -u postgres psql -c "create database app owner app;"
# 口令不要留在 history 与进程列表里
umask 077 && printf '%s' "实际口令" > /opt/secrets/pg_pass
chmod 600 /opt/secrets/pg_pass

三条必须做到:应用不用超级用户连库、口令不写进代码与命令行、连接只走 127.0.0.1 或 Unix socket。

第一步:SQLite 侧做一致性快照

# 1. 先停写(停应用,不是停库)
systemctl stop app
# 2. 一致性快照(直接 cp 文件会漏 -wal)
sqlite3 /opt/data/app.db ".backup /opt/data/app.bak"
# 3. 确认快照本身没坏
sqlite3 /opt/data/app.bak "pragma integrity_check;"   # 期望 ok

.backup 会把 WAL 里的内容一并写进快照。跳过这步,后面就算搬完了也无法确认“搬的是完整数据”。

第二步:结构一起换,逐对象映射导入

换的不只是库,还有模型:源侧“一个对象一张表”,目标侧收成 collections(存定义)+ records(存 JSONB 记录)两张表。结构变了,就不存在“直接导过去”,必须走应用层映射:读一个对象的每行数据,套上它的字段 schema,转成 JSONB 写进 records。

顺带解决第二个问题:以后再给对象加字段,只是改 JSONB 里的一条配置,不再 ALTER TABLE。

导入分批提交(每 500 条一次),失败从断点续。不要一个事务包到底:几十万行一个事务,回滚代价高到没人敢按下回车。

第三步:核条数,不看“没报错”

psql -At -c "select count(*) from records;"
psql -At -c "select collection, count(*) from records group by 1 order by 2 desc;"

要和 SQLite 侧逐对象比:总数对得上、单个对象也对得上。只有总数一致而分布不对,通常是有对象名映射错了。这种错不主动查永远发现不了,报表会莫名少一批单据。

第四步:序列与索引

records 的主键若用自增序列,导入完必须 setval 校准,否则第二天第一次写入就撞主键;再给高频筛选字段建表达式索引,建完跑一次 ANALYZE,否则执行计划还按空表算。

pg_dump 是用在同构搬家上的

PG 到 PG 的搬家、每天的备份,用的是 pg_dump -Fc + pg_restore。跨库搬迁用它不通:格式不兼容,表结构也已经整个换了。工具选错,多半是先没想清楚结构变没变。

原生模块的残留

旧数据访问层里的 SQLite 驱动不会因为迁库就消失,启动时仍会被 require。它是按 Node ABI 编译的二进制,换 Node 版本必须重编,否则进程起不来。这一点在版本升级时要先想到。

权限模型:为什么我只做两级,不做 RBAC 全套

2026-10-06

头一版我按标准 RBAC 建了角色、权限点、行级过滤。给自己配第一套角色时就卡住了:一个人既管采购又管仓库,套不进任何一个角色,配置页我自己看着都晕。后来改成两级加三档数据范围。

权限RBAC落地取舍
展开全文

为什么只用两级

平台管理员管租户与全局配置;公司管理员管本公司的用户、角色、模块开关。往下不再做第三级“部门管理员”。部门变更频繁的单位,第三级权限永远配不准,最后靠人肉维护。

不做权限点矩阵的理由

  • 配不明白:几十个权限点勾选界面,用户通常全选,等于没做;
  • 维护成本:加一个字段就可能要加一组权限点,配置与代码强耦合;
  • 审计更难:真正的越权往往发生在“没想到要拦”的地方,靠权限点穷举挡不住。

我改用“业务角色”:角色是业务概念(采购员、仓管、财务),权限跟着模块走:能看哪些单据、能不能新增、能不能审批。角色是数据,不是配置矩阵。

数据范围只有三档

本人 / 本部门 / 全部。这三档覆盖了实际需求的九成,第四档“指定人范围”看着合理,但一旦允许自由组合,边界测试就做不完。

实现只有一个入口

所有数据访问走同一个入口,在那里统一补 company_code 和 scope。绕过入口直接拼 SQL,权限迟早漏。

判定只发生在一个地方

// 所有业务查询都从这里出,业务代码拿不到裸连接
function query(ctx, collection, where) {
  return db.query(collection, {
    ...where,
    company_code: ctx.company,   // 租户永远由服务端补
    scope: ctx.scope             // 本人 / 本部门 / 全部
  });
}

角色到“能干什么”的映射,我放在一张声明表里:角色 × 模块 × 动作(读 / 新建 / 修改 / 审批)。表是数据,改权限不改代码。界面上也不给勾选矩阵,只列“这个角色能碰哪几个模块”,选项越少,配错的概率越低。

最容易犯的错:把按钮在前端隐藏就当做了权限。接口仍可直连,改一个请求就能提交。权限必须在服务端判定,前端隐藏只是体验。

备份要能恢复,不只是每天 dump 一下

2026-10-10

每天定时 dump,只解决一半。剩下的得靠试:真恢复一次,看多久能起来、恢复到哪一刻、恢复完数据对不对。这三样没试过,出事时手里那包东西是废的。

备份恢复演练RPO
展开全文

三份东西,备法不同

数据库每日 pg_dump -Fc,保留 7 天,另存一份到不同位置
附件/上传目录打包,体积大就增量同步,不跟数据库混在一个包里
密钥/口令离线保管,不进任何自动备份(备份包外流等于全失守)

恢复演练的固定动作

# 1. 新建空库(不要往在跑的库上恢复)
createdb -h 127.0.0.1 -U app restore_test
# 2. 恢复
pg_restore -h 127.0.0.1 -U app -d restore_test --clean --if-exists /backup/db.fc
# 3. 核对条数与最新一条时间
psql -d restore_test -At -c "select count(*) from records"
psql -d restore_test -At -c "select max(created_at) from records"
# 4. 索引与序列(漏了会在下次写入时主键冲突)

恢复完必须做四件事:条数比对、最新记录时间比对、索引是否存在、序列是否校准。只做前两件,会在真正切换那天才发现写不进去。

三个踩过的坑

  • 备份和原库放同一块盘:盘一坏,两份一起没;
  • 只 dump 不试恢复:dump 成功率高得让人放松,直到某天恢复失败;
  • 不记录 RPO/RTO:说不清“最多丢多久数据、多久能恢复”,等于没有承诺。

现在的做法是每月做一次恢复演练,记下时间。看备份有没有用,就看上次成功恢复是什么时候。

备份包落地之后,我会顺手跑一次 pg_restore --list,能列出内容才说明这包没坏。只看文件大小没意义,一个读不出来的包大小也一样对。

Nginx 反代 + 同源接口:静态页和接口走同一个入口

2026-10-14

静态页面和 Node 接口,最省心的做法是放在同一个入口下用 location 分流,前端就不用处理跨域和 Cookie 边界。

Nginx反向代理局域网
展开全文

结构很简单:页面走静态目录,接口走 proxy_pass 到本机端口。关键是别让 Node 直接对外,只监听 127.0.0.1。

location / { try_files $uri $uri/ /index.html; }
location /api/ {
  proxy_pass http://127.0.0.1:18081;
  proxy_set_header Host $host;
  proxy_set_header X-Real-IP $remote_addr;
  proxy_set_header X-Forwarded-Proto $scheme;
}

三个细节容易漏:X-Forwarded-Proto 不给,应用生成的链接会是 http;WebSocket 要单独配 Upgrade 头,否则长连接握手失败;上传体积上限默认只有 1M,传附件必调。

为什么值得做成同源

页面和接口走同一个入口,前端请求不用跨域:没有预检请求,Cookie 也不受 SameSite 的折腾,入口只有一个,日志都在一处。代价是不能让 Node 直接对外,本来也不该让它对外。

没有证书这回事

局域网里用 IP 直接访问,走 http,没有证书要申请,浏览器也不会拦。80 端口就够:Node 只监听 127.0.0.1,外面这层是 Nginx。再往上加一层转发,就多一处要查的地方。

配置我留两份:当前在用的,上一次改动的。改坏了把旧的一覆盖再 reload,比在现场一条一条往回找快。

2G 内存的小服务器,怎么跑一套 ERP

2026-10-18

这套东西一直跑在家里那台 NAS 上开的一台虚拟机里:Debian 13、2 核、2G 内存、40 G 盘,随便一个进程多吃一百兆都看得见。所以先算账,再决定装什么。

运维内存预算部署形态
展开全文

一、先算能剩下多少

这台虚拟机给的 2G 内存,扣掉系统与缓存,稳定可用的部分大约 800 M。这块不按比例估,按几样东西的常驻占用加起来看(ps_mem,或者 grep VmRSS /proc/<pid>/status):

nginx       2 进程    20–25 M
node        单进程    90–140 M(随连接数上涨)
postgres    常驻      100–300 M(随 shared_buffers 定)
面板进程    常驻      70 M 左右(装了运维面板才有,不装更省)
其余        系统/缓存 剩余

四项加完已经逼近 500 M,剩下 300 M 就是所有峰值操作的余地。所以参数按那 300 M 的余量定,不是能开多大开多大。

二、为什么最后没用容器

  • 内存:dockerd + containerd 常驻一两百兆,相当于直接砍掉可用内存的六分之一;
  • 磁盘:基础镜像几十兆起步,换一版留一层,杂项很快吃掉半 G;
  • 排障:日志、端口、进程都要穿透一层再看,而这里只有一台机器、一套环境,隔离带来的好处用不上。

单机、单环境、不折腾多版本,原生进程更划算。多节点和灰度才用得上容器,眼下就一台机器,用不上。

三、四个参数为什么这么定

  • shared_buffers 128–256 M:常见的“内存 25%”公式假设整机只跑数据库,这里不是。给 256 M,剩下的留给连接与排序更划算;
  • work_mem 要乘以并发:单连接 8 M 看着小,20 个连接同时排序就是 160 M 峰值。这层开销最容易漏算,宁可给 4 M;
  • Node 限制堆上限:--max-old-space-size=384,否则内存泄漏时一路涨到 swap,整机变卡而不是进程崩掉,更难查;
  • 连接池别超过 20:数据库连接是拿内存换等待,连接越多单连接开销越大,超出后吞吐反而下降。

四、两个早期预警

一是 dmesg -T | grep -i oom:看到进程被 OOM killer 杀掉,说明峰值已经越线,不是“偶发重启”;二是 swap 使用率持续高于 30%,说明常驻部分已在换页,性能缓慢劣化而没有任何报错。

看内存看 free -m 的 available,别看 free。Linux 把空闲内存当缓存,free 数小是常态;照着 free 去加内存、杀进程,白忙。

五、最后的取法

小机器跑得稳靠留余量。参数往保守里给,比贴着上限跑、最后被系统杀掉强。

多租户:一个库多前缀,还是每租户一套?

2026-10-21

这套东西要能云端托管,也要能装进客户自己的机器。两边的隔离要求不一样,一套代码得同时应付,最后落成一个库、一个租户字段。

多租户数据隔离部署形态
展开全文

三种方案的实际代价

每租户一个库隔离最彻底,但备份、升级、监控都要按租户遍历,几十个租户就变成运维灾难
一库一 schema比一库一租户轻,但迁移脚本要按 schema 重复执行,DDL 风险成倍
一库 + 租户字段运维最简单,代价是每条查询都必须带租户条件,漏一次就是串数据

我选第三种。它不算最安全,但在几十个租户、单机、还要能自部署这个前提下,总成本最低。

把“漏写”漏洞堵在入口

租户条件不靠人记,靠入口统一补:所有读写经同一层封装,在那里按当前会话的租户补上条件;业务代码里根本拿不到“不带租户”的查询能力。界面、报表、导出都走这条路径。

再加一道静态检查:发布前扫一遍有没有裸 SQL 绕开封装。人总会犯错,靠检查比靠自觉可靠。

查询和索引长什么样

create index on records (company_code, collection);
-- 业务查询永远是这个样子,租户列在第一位
select * from records where company_code = $1 and collection = $2;

租户列放在联合索引第一列,过滤快,漏写租户条件的查询也会在计划里露出来:全表扫很扎眼,比评审容易发现。

单租户导出与归档

第三种方案还有个好处:单租户导出就是一条 where,把这个租户的记录导成独立文件,有租户要迁走时不需要拆库。

什么时候该换方案

租户数到几百、或者单个租户数据量远超其他,就开始按大租户单独分库。分库不是一开始就设计好的,是长到那一步才动。

审批流引擎:状态机加事件溯源,不把流程图存进 JSON

2026-10-26

流程改一次,之前跑过的单据状态就跟着乱,这是我碰到的第一个坑。后来把“流程定义”和“审批事件”分开存,任何时刻的当前状态都能由事件重算出来。

审批流状态机事件溯源
展开全文

流程定义只描述“可能怎么走”:节点列表、每个节点的审批人规则(指定人 / 角色 / 上级 / 发起人自选)、分支条件、会签或签。定义是配置,可以随时改,改了只影响新发起的单据。

{ "nodes": [
    { "id": "apply", "by": "initiator" },
    { "id": "mgr",   "by": "role:dept_manager" },
    { "id": "fin",   "by": "role:finance", "mode": "any",
      "when": "amount >= 5000" }
  ],
  "edges": [["apply","mgr"],["mgr","fin"]] }

审批事件是 append-only 的流水:submit / approve / reject / return / transfer / withdraw,每条带操作人、时间、意见、附件。

这样带来三个好处:

  • 历史永远可解释:某张单为什么卡在财务,翻事件就知道是谁什么时候退回的;
  • 改流程不破坏在途单据:在途单据沿用发起时的定义版本;
  • 状态可重算:出问题时可以从事件流重建当前节点,而不是靠“补一条状态”。

退回是最大的坑

“退回上一节点”和“退回到发起人”是两种语义。我早期混在一起,导致退回后再次提交会跳过中间节点。正确做法是把退回当作一个显式事件,记下目标节点,重新提交时从目标节点继续,而不是从头发起。

会签与或签

会签要记“已签集合”,全部到齐才推进;或签第一个人通过即推进,但其余人的待办要撤回。这两个用同一张待办表 + 节点实例状态就能表达,不需要另建模型。

零代码平台的数据模型:我为什么放弃了“动态建表”

2026-11-04

一开始走的是动态建表,最直观。走到字段要改、历史数据要留、多租户要隔离这三步,麻烦全冒出来了。最后换成「集合定义 + 记录 JSONB」,改字段等于改配置,不动表结构。

数据模型JSONBPostgreSQL
展开全文

一开始最自然的想法是:用户在界面上建了一个“采购订单”,后台就建一张 po_xxx 表。字段加一个就 ALTER TABLE 加一列。听着很爽,做起来也快,但三个问题很快压上来。

问题一:字段变更变成 DDL 运维

用户改个字段名、调个类型、删个字段,每次都是 DDL。表一多,DDL 会锁表;线上几十个租户同时改,运维根本不可控。而且 DDL 不可回滚,改错了只能再改回来,历史数据已经脏了。

问题二:多租户隔离没法统一

每个租户一套表,表数量等于租户数乘以业务对象数,几十个租户就是几千张表。备份、迁移、统计全都不好做;反过来如果所有租户共用一张表,又必须每一行都带租户标识,靠应用层保证不漏写。

问题三:稀疏字段浪费严重

同一个对象,不同工厂关注的字段差别很大。建宽表意味着大量 NULL,建窄表意味着业务表达不了。

我最后的结构

这套结构最早是在把数据从 SQLite 搬到 PostgreSQL 时定下的(见「从 SQLite 迁到 PostgreSQL」那篇),后面所有模块都沿着它长。

两张业务主表:collections(业务对象定义:名称、字段 schema、视图配置)和 records(记录本身:对象名、租户、数据 JSONB、创建时间)。collections 主键用 (company_code, name),租户维度天然存在。

collections(company_code, name, schema_json, view_json, ...)
records    (company_code, collection, data_jsonb, created_at, ...)

查询靠 JSONB 上的表达式索引:只给真正高频筛选的字段建索引,其余走顺序扫描 + 分页。这套结构在中小体量(单表几十万行以内)非常好用,代价是复杂聚合要写应用层逻辑,不能指望一个 SELECT 出报表。

结论:灵活不能靠改表结构,得把结构放进数据里。DAO 层只做两件事:读 schema、读写 JSONB。

表单引擎:schema 驱动渲染,还是组件拼装?

2026-11-05

选哪种,看谁能改表单。运营要自己加字段,就得 schema 驱动;只有开发能改,组件拼装省事。我用的是前者,代价是所有校验、联动、默认值都得写进配置,改一次要重看一遍配置。

表单引擎Schema校验联动
展开全文

表单配置我分成四层,每层只解决一件事,混在一起就会失控。

字段层

每个字段:key / label / type / required / default / options / validate。类型只有十来种:文本、数字、日期、下拉、多选、关联引用、附件、子表。类型越少,前端渲染越稳;需要新类型时,先问“能不能用已有类型组合出来”。

校验层

不要写自定义脚本校验(安全与可维护双重灾难)。我用“声明式规则表”:必填、长度、数值区间、正则、与其他字段比较。规则在前后端各执行一遍,前端给人看,后端兜底。后端校验永远不能省,前端能绕。

联动层

常见需求是“客户选了 A,付款方式变 B”“数量×单价自动算金额”。做法是把联动写成依赖表达式:when: {field:'customer', op:'eq', value:'...'} → {field:'pay_type', set:'...'}。渲染器按依赖图求值,避免出现循环依赖。这一点必须在校验器里拦住,否则用户配出环,页面直接转圈。

布局层

行列栅格 + 分组标题 + 子表。子表最容易出问题:它的字段又是一套 schema,递归深度要限制(我用 2 层),否则渲染成本指数上升。

踩坑:一开始把默认值写在前端,结果 API 直连时字段为空,报表统计全是脏数据。默认值必须由后端在写入时补齐,前端只负责展示。

表单配置我存库里,一个模块一份 JSON。改完先在一个临时租户上试,试过再推到常用的那套,省得改错一次,整套单据都跟着变。

域名到手之后,我把服务器那一步拖了几个月

2026-11-12
随笔域名备案
展开全文

先把域名买了下来

几个月前注册了 jancor.cn。名字想了很久,注册倒不难,也不贵。买完当天什么都没做,就是把这个名字占住了——这话听着像借口,但当时确实是这么想的:先拿着,免得哪天要用发现没了。

第一次想动手,停在付款页

后来有个周末,翻到别人做的产品站,页面很干净,功能一条一条列着,看完就顺手打开了云厂商的控制台。选配置、选镜像、加购物车,一路点到付款页面,然后关掉了。

当时脑子里的话是:域名还没备案,执照也没有,买了也只是我自己看得到。

第二次想动手,列完提纲又停了

再往后是在写这里这些文章的时候。写到部署、迁移那几篇,忽然觉得这些要是能挂在公网上,别人打开就能看,比写十篇解释有用。那晚真把提纲列了一遍:能力怎么讲、界面放什么图、哪些案例能公开。

列完发现一半填不上——界面能截图,案例拿不出来。于是又停了。

最近这次,配置单一直开着

这几天机器选好了,配置单就存在浏览器的一个标签里,没关。这个标签我每天都会看到。到最后也没下单。

原因说出来其实有点没面子:不是嫌贵,也不是技术做不到——那几篇文章里的事我自己跑过一遍又一遍,两三天就能弄完。是我心里还没准备好走出这一步。挂上去就等于对外,名字、产品、能力都摆在那儿让人看,被看好或被看坏,都得接着。这一关我没迈过去。

顺带说一句,那一晚列的提纲里,有一半不是笔记的样子,是一个能对外看的官网:能力讲清楚、界面摆出来、案例放上去。这个念头比做笔记早得多,只是每次都停在“准备好了再说”。

现在的位置

域名在续费提醒里躺着,服务器没买,机器还是自己那台,跑着我自己写的那套。能公开的部分我整理成笔记,发在这里。

写下来是因为它确实发生了:想、打开、关掉,来回好几次。下次再打开那个标签的时候,可能就下单了,也可能还是关掉。这次先记在这里。

AI 搭手写代码:省下的时间和返工的事

2026-11-14
AI编码流程
展开全文

最先交给它的,是一段 SQL 补丁

改一个字段的取值规则,牵连三张表。我自己写要来回核对字段名。把表结构和规则一起贴过去,两分钟拿到一段 update,我逐个字段对了一遍,能用。从那以后边界往外挪:写 CRUD 模板、写迁移脚本、造测试数据、读报错日志、写 Nginx 配置、把一段两百行的 diff 说完。

省下来的时间

采购申请那个模块的列表接口,原来一套写完要四个小时:分页、排序、筛选条件、导出。把字段 schema 和表定义给它,四十分钟拿到能跑的版本,剩下的时间花在一个条件一个条件地对。

数据从 SQLite 搬到 PostgreSQL 那阵,对象映射的脚本是它先出的初稿,我改了映射细节,两天里省下大半天。

造三百条采购单,跨五个部门、十几个物料,人工写要一下午,它十分钟写完,我改了两处日期范围。

质量这笔账

省时间是看得见的,返工也都发生过:

  • 迁移脚本初稿没写 setval。导入完序列还从 1 走,第二天第一次写入就撞主键。
  • 分页查询给的是 limit offset 的写法,我要的那张表上没有对应的索引,翻到第五十页就慢。执行计划它不会替我去看。
  • systemd unit 少了 Restart=always,进程被 OOM 杀掉之后再没起来。
  • 它写过一个根本不存在的 npm 包名,install 直接 404。
  • 让它读一段启动日志,它把日志里的数据库口令原样写进了回答。

这些错不算它写得差,是它不知道我的现场:机器多大、表上有什么索引、谁在连库、日志里哪些能往回答里放。所以现在它给的东西要过三关:跑一遍、看执行计划、读 diff。

质量能不能算回来,看谁审。这块业务我自己清楚,哪句不对一眼能看出来;换一个不懂业务的人来审,省下的时间多半要还回去。

固定交给它的活

样板代码、脚本、SQL 的第一版、报错日志归类、接口文档、测试数据、读别人的 diff、交接说明。这些活写错了当场能看出来,或者跑一遍就知道。

不交给它的:库结构怎么切、权限判定写在哪、迁移完怎么核对条数、哪些字段该建索引。这几件错了不会当天报错,要过几天才在数据上露出来,露出来的时候已经脏了一批单据。

写系统时,还能用它做别的事

车间的纸质单据版式是我自己定的,要哪几个字段、什么类型、哪些必填,直接说给它就行,不用拍。真用得上拍照的是老系统留下来的旧单据:让它照着认字,把字段抄成一列,我再对着实物核。这一步省的是打字,判断还是我的。

老系统导出的 Excel 二十几个页签,让它先分出哪些是主数据、哪些是流水,我再对着实物核。分错的地方它不会知道,核的时候才发现。

报错日志一天几百条,让它按错误码归堆,重复的合成一条,剩下的我自己看。

审批流的节点,我用文字描述一遍,让它出 Mermaid,贴进文档,开会不用再画。

上线自检那十条,让它写成能勾的清单,配完一个模块照着走一遍。

写得很乱的运维步骤,让它整理成有序号的命令,我再逐条在测试机上试。这一步它最容易把“在我这里能跑”写成“在你这儿也能跑”,试的时候要改路径、改用户、改端口。

这些活单独看都不大,零碎时间基本都在这儿。

现在的用法

两个窗口,左边它,右边我。它出草稿,我改;出错就把日志贴回去,第二遍通常能用。三天里有一天完全不用它,就是写库结构和权限那一段。

省下来的时间没有变成更多功能。原来是赶三个模块,现在一天一个,多出来的时间花在核对:对字段、对条数、对执行计划。

两个月下来,省的时间和核对的时间都在这儿,净省多少看我自己。

项目:知序(Jancor)

Project

上面这些文章,都是在做这个项目过程中写的。它是一个用零代码方式配置出来的制造业管理平台,自部署运行。这套东西是我下班以后和周末写的,跟公司手上的项目没有关系;机器是我自己的,单据和数据也是照流程自己造出来试的。起因很简单:用过几套第三方系统,交付出来的跟业务需要的对不上,提一个改动要先开会,沟通花的时间比开发还多,索性照自己的想法搭一套。

目前这套东西是自己写、自己改:思路自己琢磨,也翻了网上公开的一些方案,过程里还拿 AI 当过参考,哪条能用、哪条不能用都是自己试过才定下。将来会不会把它做成对外售卖的产品,不排除这种可能——但那属于另一件事,需要单独去准备,跟写这些文章不是一回事。

它是什么

一套可自部署的制造业业务管理平台:业务对象、表单、审批流都通过配置生成,换配置就能适配不同业务口径,不用改代码。

覆盖采购、销售、库存、生产、品质、财务、人事几条主线,单据之间能串起来,审批留痕可追溯。

部署形态自部署(单机原生进程,不依赖容器)
技术栈Node.js + PostgreSQL + Nginx
数据模型集合定义 + JSONB 记录
隔离方式单库 + 租户字段(company_code)

主要模块

采购采购申请、询价与比价管理、采购订单、采购合同、收货、退货
销售客户与商机、报价管理、销售订单、出货签收、对账
库存多仓多库位、调拨、盘点、安全库存预警
生产工单、领料、报工、工序流转
品质检验标准、来料/过程/出货检验、不合格处置
财务应收应付、发票、费用报销
说明:文章源于自己搭这套东西的过程。文中的单据、数据和截图都是测试用的,不是真实业务数据。

关于

About

在制造业做了十几年,管过的摊子比较杂:信息化、工程、品质、行政都带过。好处是知道一张单据从车间到办公室,中间要经过谁的手、最容易卡在哪一步。

后来自己动手写系统,动机其实挺直白:第三方做出来的东西跟想要的不一样。他们不理解车间的实际流程,按自己认为对的方式设计:字段这样归拢、审批流那样串,提一个改动要先开会对齐三天。沟通成本比开发成本还高。索性自己写:哪里别扭我自己改,改完当天就能上手试。

这套东西是下班后和周末自己搭的,机器、数据、域名都自己出,跟公司手上的项目没关系;但里面的判断来自上班这些年看的现场:单据怎么流转、卡在谁手上、车间和办公室之间来回改什么。做系统时习惯把这些翻成表单、规则和审批节点,文章里也多写当时为什么这么定,少写用了哪个技术。

开这个博客,是因为网上讲零代码的多是产品宣传;数据模型怎么定、审批退回怎么处理、多租户怎么隔离,这些真要动手的地方很少有人写。