工蚁科技工作室 | 博客

使用Docker快速部署Postgres数据库实例

Mon, 24 Aug 2026 00:00:00 GMT

先决条件

需要实现完成Docker安装。

部署

可使用如下Docker部署命令：

set -e
name="postgres"
# 启动容器
docker run -d \
--name $name \
-p 5432:5432 \
-e POSTGRES_PASSWORD=<strong-password> \
-e TZ=Asia/Shanghai \
-v "/path/to/percist/postgres/data":/var/lib/postgresql \
-v /etc/localtime:/etc/localtime:ro \
postgres:18-trixie
# 查看容器日志
docker logs -f $name

DrizzleORM多租户支持方案

Sat, 22 Aug 2026 00:00:00 GMT

背景

drizzle是一个轻量级、全功能的typescript ORM，提供了类似SQL语法的使用方式。在开发SaaS应用时，通过Postgres Schema将不同的租户业务数据进行隔离是比较普遍的选择。

drizzle本身支持给表指定schema，但是只能在定义时指定，无法在运行时根据租户身份进行切换：

import { integer, pgSchema } from "drizzle-orm/pg-core";

export const tenantSchema = pgSchema('tenant_xxxx');
export const customerTable = tenantSchema.table('customer', {
  id: integer(),
  // ...
})
// 查询时固定死了只能从 tenant_xxxx schema 查询
db.select().from(customerTable)

从官方在 GitHub Issues 上回复的内容看，貌似并没有短期内支持动态schema的打算，所以需要一种在运行时动态指定shcema的方案

Schema 分类

一般认为需要三类 schema：

admin，用于管理后台，例如租户表、用户表等
public，用于租户之间共享数据，例如各类字典
tenant_xxx，只属于xxx租户，存储该租户业务数据

动态构建

用于drizzle-kit进行数据库迁移的 schema 和查询时使用的 schema 除了数据库 schema 外其他部分都是相同的，所以我们可以使用工具函数创建 schema

src/db/db.utils.ts

import {
  AnyPgColumnBuilder,
  PgBuildExtraConfigColumns,
  PgTableExtraConfigValue,
  snakeCase,
} from 'drizzle-orm/pg-core';

export type TableParams<
  TTableName extends string = string,
  TColumnsMap extends Record<string, AnyPgColumnBuilder> = Record<
    string,
    AnyPgColumnBuilder
  >,
> = {
  name: TTableName;
  columns: TColumnsMap;
  extra?: (
    self: PgBuildExtraConfigColumns<TColumnsMap>,
  ) => PgTableExtraConfigValue[];
};

export function createSchemaTable<
  TSchemaName extends string,
  TTableName extends string,
  TColumnsMap extends Record<string, AnyPgColumnBuilder>,
>(schema: TSchemaName, table: TableParams<TTableName, TColumnsMap>) {
  return snakeCase.schema(schema).table(table.name, table.columns, table.extra);
}

export function createTable<
  TTableName extends string,
  TColumnsMap extends Record<string, AnyPgColumnBuilder>,
>(table: TableParams<TTableName, TColumnsMap>) {
  return snakeCase.table(table.name, table.columns, table.extra);
}

使用

drizzle-kit

drizzle-kit根据配置文件指定的 schema 文件将表结构同步到数据库，schema 文件示例如下：

Admin Schema

src/db/admin.schema.ts

import { AnyPgColumnBuilder, integer, varchar } from 'drizzle-orm/pg-core';
import { createSchemaTable, createTable, TableParams } from './db.utils';

export function withAdminSchema<TTableName extends string = string, TColumnsMap extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>>(params: TableParams<TTableName, TColumnsMap>) {
  return createSchemaTable('admin', params);
}

// 可以用 withAdminSchema 从该参数构建schema
export const tenantTableParams = {
  name: 'core_tenant',
  columns: {
    id: integer().primaryKey().generatedAlwaysAsIdentity(),
    name: varchar({ length: 255 }).notNull(),
    code: varchar({ length: 255 }).notNull(),
    logo: varchar({ length: 255 }),
  },
} satisfies TableParams;
// drizzle-kit 会读取该导出对象进行数据库同步
export const tenantTable = createTable(tenantTableParams);

export const userTableParams = {
  name: 'core_user',
  columns: {
    id: integer().primaryKey().generatedAlwaysAsIdentity(),
    username: varchar({ length: 255 }).notNull(),
    email: varchar({ length: 255 }),
  },
} satisfies TableParams;
export const userTable = createTable(userTableParams);

Public Schema

import { AnyPgColumnBuilder, integer, varchar } from "drizzle-orm/pg-core";
import { createSchemaTable, createTable, TableParams } from "./db.utils";

export function withPublicSchema<TTableName extends string = string, TColumnsMap extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>>(params: TableParams<TTableName, TColumnsMap>) {
  return createSchemaTable('public', params)
}

export const industryTableParams = {
  name: 'industry',
  columns: {
    id: integer().primaryKey().generatedAlwaysAsIdentity(),
    name: varchar({ length: 255 }).notNull(),
    code: varchar({ length: 255 }).notNull(),
  }
} satisfies TableParams
export const industryTable = createTable(industryTableParams);

Tenant Schema

import { AnyPgColumnBuilder, integer, varchar } from "drizzle-orm/pg-core";
import { createSchemaTable, createTable, TableParams } from "./db.utils";

export function withTenantSchema<TTenantName extends string = string,TTableName extends string = string, TColumnsMap extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>>(tenant: TTenantName, params: TableParams<TTableName, TColumnsMap>) {
  return createSchemaTable(`tenant_${tenant}`, params)
}

export const customerTableParams = {
  name: 'customer',
  columns: {
    id: integer().primaryKey().generatedAlwaysAsIdentity(),
  companyName: varchar({ length: 255 }).notNull(),
  }
} satisfies TableParams
export const customerTable = createTable(customerTableParams)

export const orderTableParams = {
  name: 'order',
  columns: {
    id: integer().primaryKey().generatedAlwaysAsIdentity(),
    serialNumber: varchar({ length: 255 }).notNull(),
  }
} satisfies TableParams
export const orderTable = createTable(orderTableParams)

动态查询

在从数据库插叙时可使用如下形式：

import { drizzle } from 'drizzle-orm/bun-sql';
import { tenantTableParams, withAdminSchema } from './db/admin.schema';
import { customerTableParams, withTenantSchema } from './db/tenant.schema';

const db = drizzle(import.meta.env.DATABASE_URL)
const tenants = await db.select().from(withAdminSchema(tenantTableParams));
// 这会只从指定的租户 schema 中查询客户信息
const customers = await db.select().from(withTenantSchema('xxxx', customerTableParams));

迁移

drizzle-kit支持业务表结构变更后同步到数据库，为了适配以上多租户方案，需要调整迁移脚本

drizzle.config.ts

原来的drizzle.config.ts文件不足以支撑多租户方案，所以分成三个配置文件，分别对应三类schema。可以在drizzle/config目录下创建以下三个配置文件：

admin.config.ts

import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  out: './drizzle/migration/admin',
  schema: './src/db/admin.schema.ts',
  dialect: 'postgresql',
  dbCredentials: {
    url: import.meta.env.DATABASE_URL,
  },
});

public.config.ts

import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  out: './drizzle/migration/public',
  schema: './src/db/public.schema.ts',
  dialect: 'postgresql',
  dbCredentials: {
    url: import.meta.env.DATABASE_URL,
  },
});

tenant.config.ts

import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  out: './drizzle/migration/tenant',
  schema: './src/db/tenant.schema.ts',
  dialect: 'postgresql',
  dbCredentials: {
    url: import.meta.env.DATABASE_URL,
  },
});

drizzle-kit会根据这三个配置文件在drizzle/migration/<admin|public|tenant>目录下形成各自的迁移脚本

迁移逻辑

核心迁移逻辑放在了drizzle/migration.ts:

import { migrate } from 'drizzle-orm/bun-sql/migrator';
import { drizzle } from 'drizzle-orm/bun-sql/postgres';
import { tenantTableParams } from '../src/db/admin.schema';
import { createSchemaTable } from '../src/db/db.utils';

async function migration(schema: string) {
  const db = drizzle(import.meta.env.DATABASE_URL);
  if (schema === 'tenant') {
    const tenants = await db.select().from(createSchemaTable('admin', tenantTableParams));
    if (tenants.length > 0) {
      await Promise.all(tenants.map((t) => migration(`tenant_${t.code}`)));
    }
    console.log(`🚀 ${tenants.length} tenants migrated successfully!`);
    return;
  }
  await db.execute(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
  await db.execute(`SET search_path TO ${schema};`);
  await migrate(db, {
    migrationsFolder: `drizzle/migration/${schema.split('_')[0]}`,
    migrationsSchema: schema,
    migrationsTable: 'drizzle_migration',
  });
  console.log(`✅ ${schema} migrated successfully!`);
}

migration(process.argv[2]).catch((err) => {
  console.error('migration fail:', err);
  process.exit(1);
});

迁移脚本

package.json

{
  "name": "drizzle-multi-tenant-demo",
  "scripts": {
    "db:generate:admin": "drizzle-kit generate --config=drizzle/config/admin.config.ts",
    "db:generate:public": "drizzle-kit generate --config=drizzle/config/public.config.ts",
    "db:generate:tenant": "drizzle-kit generate --config=drizzle/config/tenant.config.ts",
    // 生成迁移所需的 SQL 脚本。分开是为了在开发阶段完成迁移 SQL 固定，避免 CI 环境中需要手动选择
    "db:generate": "bun db:generate:admin && bun db:generate:public && bun db:generate:tenant",
    "db:migrate:admin": "bun run drizzle/migration.ts admin",
    "db:migrate:public": "bun run drizzle/migration.ts public",
    "db:migrate:tenant": "bun run drizzle/migration.ts tenant",
    // 将 SQL 迁移脚本同步到各schema
    "db:migrate": "bun db:migrate:admin && bun db:migrate:public && bun db:migrate:tenant",
    // 一个脚本完成迁移
    "db:push": "bun db:generate && bun db:migrate"
  },
  "dependencies": {
    "drizzle-orm": "^1.0.0-rc.5"
  },
  "devDependencies": {
    "@biomejs/biome": "2.5.8",
    "@types/bun": "latest",
    "drizzle-kit": "^1.0.0-rc.5"
  }
}

通过Gitea部署自己的DevOps平台

Sat, 15 Aug 2026 00:00:00 GMT

背景

当讨论自托管DevOps时，脑海里面出现的可能是GitLab+Jenkins+Nexus的组合，但是搭建一套这样的DevOps平台对基础设施的要求是非常高的。Gitea基于Go语言实现，在包含代码托管、CI/CD、项目管理、制品库等功能的同时做到非常轻量，2C1G的机器就能满足小型团队的需求，是中小规模实现DevOps的不错选择。

部署

更详细的部署教程请访问官方文档

系统要求

树莓派Pi3功能强大，足以运行 Gitea 来处理小型工作负载。
对于小型团队/项目而言，2 个 CPU 内核和 1GB 内存通常就足够了。
在 UNIX 系统上，Gitea 应使用专用的非 root 系统账户运行。
- 注意：Gitea 管理 ~/.ssh/authorized_keys 文件。以普通用户身份运行 Gitea 可能会破坏该用户的登录能力。
Git 需要 2.0.0 或更高版本。
- Git LFS 如果启用，且 Git 版本大于等于 2.1.2，则该选项可用
- 如果 Git 版本大于等于 2.18，将自动启用 Git 提交历史图形化展示功能

数据库

Gitea 支持 PostgreSQL（>= 12）、MySQL（>= 8.0）、MariaDB（>= 10.4）、SQLite（内置）和 MSSQL（>= 2012 SP4）这几种数据库。推荐使用PostgreSQL。

安装

执行git --version检查系统是否安装git，未安装时通过apt install git安装
从下载页面下载对应平台的最新版可执行程序，将可执行文件移动到/usr/local/bin并赋予执行权限

wget -O gitea https://dl.gitea.com/gitea/x.x.x/gitea-x.x.x-linux-amd64
mv gitea /usr/local/bin/gitea
chmod +x /usr/local/bin/gitea

创建组和用户

# 创建组
groupadd gitea
# 创建用户并加入到组
adduser \
   --system \
   --shell /bin/bash \
   --gecos 'Git Version Control' \
   --ingroup gitea \
   --disabled-password \
   --home /home/git \
   git

mkdir -p /var/lib/gitea/{custom,data,log}
chown -R git:gitea /var/lib/gitea/
chmod -R 750 /var/lib/gitea/
mkdir /etc/gitea
chown git:gitea /etc/gitea
chmod 770 /etc/gitea

编辑/etc/systemd/system/gitea.service文件内容如下：

[Unit]
Description=Gitea (Git with a cup of tea)
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=gitea
WorkingDirectory=/var/lib/gitea/
ExecStart=/usr/local/bin/gitea web --config /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target

启动gitea服务

systemctl enable gitea
systemctl start gitea
# 查看是否启动成功
systemctl status gitea

访问http://<you-host>:3000完成配置

数据库按照实际情况选择，填写正确的连接信息
站点名称填写自己公司/团队名即可
服务器域名填写类似gitea.example.com或保留默认
基础URL填写类似https://gitea.example.com或保留默认
可选设置中主要设置管理员账号密码，邮箱和第三方服务设置按照实际需求设置

完成后点击立即安装，等待安装完成并刷新。如果上一步未设置管理员账号，现在注册成为管理员
现在可以正常创建团队或仓库并推送代码了

Actions

Gitea Actions是官方内置的CI/CD解决方案，需要将Job委托给单独部署的Gitea Runner

由于Gitea Actions将任务运行在Docker中，所以请保证系统已经安装Docker

从下载页面下载对应平台的最新版二进制文件，将可执行文件移动到/usr/local/bin并赋予执行权限

wget -O runner https://dl.gitea.com/gitea-runner/x.x.x/gitea-runner-x.x.x-linux-amd64
mv runner /usr/local/bin/runner
chmod +x /usr/local/bin/runner

创建用户并添加到组

adduser \
   --system \
   --shell /bin/bash \
   --gecos 'Gitea Actions Runner' \
   --ingroup gitea \
   --disabled-password \
   --home /home/runner \
   runner
usermod -aG docker runner

mkdir /etc/runner
mkdir /var/lib/runner
chown -R runner:gitea /var/lib/runner
chown -R runner:gitea /etc/runner
runner config generate > /etc/runner/config.yaml

按需调整配置文件内容，示例如下：

log:
  level: info

runner:
  file: /etc/runner/.runner
  capacity: 1
  env_file: /etc/runner/.env
  timeout: 3h
  shutdown_timeout: 0s
  insecure: true
  fetch_timeout: 5s
  fetch_interval: 2s
  fetch_interval_max: 5s
  workdir_cleanup_age: 24h
  idle_cleanup_interval: 10m
  log_report_interval: 5s
  log_report_max_latency: 3s
  log_report_batch_size: 100
  state_report_interval: 5s
  report_close_timeout: 10s
  github_mirror: ''
  action_shallow_clone: true
  set_act_env: true
  labels:
    - "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
  allocate_pty: true
  post_task_script: ''
  post_task_script_timeout: 5m

cache:
  enabled: true
  dir: "/var/lib/runner/cache"
  host: "192.168.100.40"
  port: 4000
  external_server: ""
  external_secret: ""
  offline_mode: false

container:
  network: ""
  network_create_options:
    enable_ipv4: true
    enable_ipv6: false
  privileged: true
  options:
  workdir_parent:
  valid_volumes:
    - '**'
  docker_host: ""
  force_pull: false
  force_rebuild: false
  require_docker: false
  docker_timeout: 0s
  bind_workdir: true

host:
  workdir_parent: /var/lib/runner/workspace

metrics:
  enabled: false
  addr: "127.0.0.1:9101"

将runner注册到gitea实例

cd /etc/runner
# instance是Gitea实例的地址，如http://192.168.8.8:3000或https://gitea.example.com
# token 用于身份验证和标识，可以设置不同层级的runner，一般团队只用设置实例级别
# 实例级别：管理员设置页面，例如 <your_gitea.com>/admin/actions/runners
# 组织级别：组织设置页面，例如 <your_gitea.com>/<org>/settings/actions/runners
# 存储库级别：存储库设置页面，例如 <your_gitea.com>/<owner>/<repo>/settings/actions/runners
# name是runner名称
runner register \
  --no-interactive \
  --config /etc/runner/config.yaml \
  --instance https://gitea.example.com \
  --token <token> \
  --name <name>

# 注册后，当前目录中将出现一个名为 .runner 的新文件件存储了注册信息

编辑/etc/systemd/system/runner.service文件内容如下：

[Unit]
Description=Gitea Actions runner
Documentation=https://gitea.com/gitea/runner
After=docker.service

[Service]
ExecStart=/usr/local/bin/runner daemon --config /etc/runner/config.yaml
ExecReload=/bin/kill -s HUP $MAINPID
WorkingDirectory=/var/lib/runner
TimeoutSec=0
RestartSec=10
Restart=always
User=runner
Group=gitea

[Install]
WantedBy=multi-user.target

启动runner

systemctl enable runner
systemctl start runner
# 检查runner运行状态
systemctl status runner

流水线

Gitea流水线通过yaml文件定义，存放在项目根目录下的.gitea/workflows文件夹下。流水线语法请参考Github Actions语法

基础

执行顺序

当存在多个流水线时，Gitea Actions按照文件在.gitea/workflows文件夹下的顺序执行，如果想要编排不同流水线，可通过文件名前缀实现，例如：

001-server-nest.yaml
002-server-gateway.yaml
003-server-calendar.yaml

条件触发

流水线应该只在影响部署结果的内容发生变化时才重新运行，触发条件可以在yaml配置中通过如下示例设置：

on:
  push:
    # 只管列出的分支
    branches:
      - master
    # 只管列出路径匹配的文件内容是否变动
    paths:
      # 流水线本身配置变化
      - .gitea/workflows/demo.yaml
      # 代码内容变化
      - apps/demo/**/*.ts
      # monorepo中可能存在代码没变，但是内部依赖更新导致需要重新部署的情况
      - apps/demo/package.json

插件

actions/checkout

用于拉取代码，最基础的插件。使用方式如下：

- name: Checkout Code
  uses: actions/checkout@v7

pnpm/action-setup

设置pnpm环境，详情参考官方文档。使用方式如下：

- name: Install Pnpm
  uses: pnpm/action-setup@v6
# 一般设置缓存
- name: Setup Pnpm Store
  run: pnpm config set store-dir /workspace/pnpm

actions/setup-node

设置node环境，详情参考官方文档。使用方式如下：

- name: Setup Node
  uses: actions/setup-node@v7
  with:
    # 使用项目根目录的node-version安装特定版本node
    node-version-file: .node-version
    # 使用pnpm缓存
    cache: 'pnpm'

docker/login-action

Docker仓库登录插件，登录后支持推送、拉取镜像等操作，详情参考官方文档。使用方式如下：

# 基于 git commit hash 设置镜像tag
- name: Setup Image Tag
  env:
    FULL_SHA: ${{ gitea.sha }}
    DOCKER_REGISTRY: ${{ vars.DOCKER_REGISTRY }}
    WORKFLOW_NAME: ${{ gitea.workflow }}
  run: |
    IMAGE_NAME="$DOCKER_REGISTRY/ergate/$WORKFLOW_NAME:${FULL_SHA:0:7}"
    echo "IMAGE_NAME=$IMAGE_NAME" >> $GITEA_ENV
    echo "$IMAGE_NAME"
# 登录Docker仓库
- name: Login Docker
  uses: docker/login-action@v4
  with:
    # 支持自定义DOCKER_REGISTRY
    registry: ${{ vars.DOCKER_REGISTRY }}
    username: ${{ secrets.DOCKER_USERNAME }}
    password: ${{ secrets.DOCKER_TOKEN }}
# 推送镜像并删除本地镜像
- name: Push Image
  run: |
    docker push ${{ env.IMAGE_NAME }}
    docker rmi ${{ env.IMAGE_NAME }}

appleboy/ssh-action

SSH到远程主机执行命令，一般用于部署，详情参考官方文档。使用方式如下：

- name: Deploy Remote
  uses: appleboy/ssh-action@v1
  with:
    host: ${{ secrets.REMOTE_HOST }}
    username: ${{ secrets.SSH_USERNAME }}
    password: ${{ secrets.SSH_PASSWORD }}
    script: |
      cat /etc/os-release
      ip addr show

easingthemes/ssh-deploy

基于rsync实现文件同步，适合部署前端项目打包结果到远程机器，详情参考官方文档。使用方式如下：

- name: Transfer Remote
  uses: easingthemes/ssh-deploy@v6
  with:
    REMOTE_HOST: ${{ secrets.SSH_HOST }}
    REMOTE_USER: ${{ secrets.SSH_USERNAME }}
    SSH_PRIVATE_KEY: ${{ secrets.SSH_KEY }}
    TARGET: '/var/www/demo' # 远程服务器的目标部署目录
    SOURCE: 'apps/demo/dist'
    ARGS: '-avzr --delete' # 增量同步并清理旧文件

示例

部署NestJS应用

name: server-gateway
run-name: Deploy GATEWAY service

on:
  push:
    branches:
      - master
    paths:
      - .gitea/workflows/*-server-gateway.yaml
      - apps/server-gateway/**/*.ts
      - apps/server-gateway/package.json
      - Dockerfile

jobs:
  Deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v7

      - name: Setup Image Tag
        env:
          FULL_SHA: ${{ gitea.sha }}
          DOCKER_REGISTRY: ${{ vars.DOCKER_REGISTRY }}
          WORKFLOW_NAME: ${{ gitea.workflow }}
        run: |
          IMAGE_NAME="$DOCKER_REGISTRY/$WORKFLOW_NAME:${FULL_SHA:0:7}"
          echo "IMAGE_NAME=$IMAGE_NAME" >> $GITEA_ENV
          echo "$IMAGE_NAME"

      - name: Install Pnpm
        uses: pnpm/action-setup@v6

      - name: Setup Pnpm Store
        run: pnpm config set store-dir /workspace/pnpm

      - name: Setup Node
        uses: actions/setup-node@v7
        with:
          node-version-file: .node-version
          cache: 'pnpm'

      - name: Prune Service
        run: |
          pnpm add turbo --global
          turbo prune @ergate/server-gateway --docker

      - name: Build Image
        run: |
          rm -rf deploy && cp -r out/json deploy
          cd deploy
          pnpm install --frozen-lockfile --prefer-offline
          cp -r ../out/full/. ./
          turbo build --filter="./libs/*" --filter="./packages/*"
          pnpm install --frozen-lockfile --prefer-offline
          turbo build
          pnpm --filter=@ergate/server-gateway deploy --prod app
          docker build -f ./Dockerfile -t ${{ env.IMAGE_NAME }} ./app

      - name: Login Docker
        uses: docker/login-action@v4
        with:
          registry: ${{ vars.DOCKER_REGISTRY }}
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_TOKEN }}

      - name: Push Image
        run: |
          docker push ${{ env.IMAGE_NAME }}
          docker rmi ${{ env.IMAGE_NAME }}

      - name: Deploy Remote
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.GATEWAY_HOST }}
          username: ${{ secrets.GATEWAY_USERNAME }}
          password: ${{ secrets.GATEWAY_PASSWORD }}
          script: |
            # 删除原有容器
            docker rm -f gateway || true
            # 启动新容器
            docker run -d \
            --name gateway \
            --network host \
            -v /app/platform/gateway/config.yaml:/app/config.yaml \
            -v /app/platform/data:/app/data \
            ${{ env.IMAGE_NAME }}

部署前端网页

name: web-www
run-name: Deploy WWW Website

on:
  push:
    branches:
      - master
    paths:
      - .gitea/workflows/web-www.yaml
      - apps/web-www/**/*.{ts,css,astro,md,mdx}
      - apps/web-www/package.json

jobs:
  Deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v7

      - name: Install Pnpm
        uses: pnpm/action-setup@v6

      - name: Setup Pnpm Store
        run: pnpm config set store-dir /workspace/pnpm

      - name: Setup Node
        uses: actions/setup-node@v7
        with:
          node-version-file: .node-version
          cache: 'pnpm'

      - name: Prune Website
        run: |
          pnpm add turbo --global
          turbo prune @ergate/web-www

      - name: Build
        run: |
          cd out
          pnpm install --frozen-lockfile --prefer-offline
          turbo build --filter=@ergate/web-www

      - name: Transfer Remote
        uses: easingthemes/ssh-deploy@v6
        with:
          REMOTE_HOST: ${{ secrets.SSL_HOST }}
          REMOTE_USER: ${{ secrets.SSL_USERNAME }}
          SSH_PRIVATE_KEY: ${{ secrets.SSL_KEY }}
          TARGET: '/var/www/web-www' # 远程服务器的目标部署目录
          SOURCE: 'out/apps/web-www/dist/'
          ARGS: '-avzr --delete' # 增量同步并清理旧文件

基于Garage部署轻量级自托管S3

Fri, 14 Aug 2026 00:00:00 GMT

核心概念

S3 全称 Simple Storage Service，是亚马逊 AWS 在 2006 年推出的对象存储标准服务接口规范，现在已经成为行业通用的对象存储协议，不只是 AWS 专有。

和电脑硬盘、服务器磁盘（块存储）、网盘文件夹（文件存储）不同：

最小存储单元是对象：文件 + 元数据（大小、上传时间、标签、权限等）打包为一个整体；
存储空间层级：存储桶 Bucket（顶层容器）→ 对象 Object（文件），没有传统文件夹层级，但可以用前缀模拟目录；
数据扁平化存放，海量文件读写性能稳定，适合存图片、备份、视频、静态资源、归档数据。

部署

从官网下载页面下载最新版二进制文件并移动到/usr/local/bin目录
编写配置文件/etc/garage.toml，更多内容参考全量配置

# 数据存储目录
metadata_dir = "/var/lib/garage/meta"
data_dir = "/var/lib/garage/data"
db_engine = "sqlite"

replication_factor = 1

rpc_bind_addr = "[::]:3901"
rpc_public_addr = "127.0.0.1:3901"
# 通过 openssl rand -hex 32 获取
rpc_secret = "xxxx"

# 客户端连接配置
[s3_api]
s3_region = "global"
api_bind_addr = "[::]:3900"
root_domain = ".garage-api.example.com"

[s3_web]
bind_addr = "[::]:3902"
root_domain = ".garage-web.example.com"
index = "index.html"

[admin]
api_bind_addr = "[::]:3903"
# 通过 openssl rand -base64 32 获取
admin_token = "xxxxx"
# 通过 openssl rand -base64 32 获取
metrics_token = "xxxxxx"

编写/etc/systemd/system/garage.server，通过systemd将garage运行为系统服务

[Unit]
Description=Garage Data Store
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/local/bin/garage server --single-node
StateDirectory=garage
DynamicUser=true
ProtectHome=true
NoNewPrivileges=true
LimitNOFILE=42000

[Install]
WantedBy=multi-user.target

启动服务

# 识别到server配置
systemctl daemon-reload
# 启动服务
systemctl start garage
# 检查服务状态
systemctl status garage

创建bucket和credentials

# 创建桶
garage bucket create global
# 创建密钥，需要保存好Secret key，后续不会展示
garage key create global-key
# 允许密钥访问桶
garage bucket allow \
  --read \
  --write \
  --owner \
  global \
  --key global-key

通过S3客户端验证

import { ListBucketsCommand, S3Client } from '@aws-sdk/client-s3';

async function main() {
  const client = new S3Client({
    endpoint: 'http://192.168.100.44:3900',
    region: 'global',
    // garage key create global-key 得到的密钥信息
    credentials: {
      accessKeyId: 'GKxxxx',
      secretAccessKey:'xxxxx',
    },
  });

  const buckets = await client.send(new ListBucketsCommand({}));
  console.log(buckets);
}

main();

UI

Garage官方并没有提供web管理页面，但是社区有开源的Garage UI解决方案

部署

Garage UI 需要通过docker部署，需要保证已经安装docker
在/etc/garage-ui.yaml编写配置

# Garage UI Backend Configuration

# Server configuration
server:
  host: "::" # IPv6 wildcard; dual-stack behavior depends on OS/runtime socket settings
  # web后台访问端口
  port: 8080
  environment: "production" # development, production
  domain: "localhost" # Domain name for the application
  protocol: "http" # Protocol for internal communication (http/https)
  root_url: "https://garage.example.com" # Full external URL for OAuth2 redirects (adjust for production)

  # Request size limits (in bytes)
  max_body_size: 314572800 # 300MB - Maximum request body size (increase for large file uploads)
  max_header_size: 1048576 # 1MB - Maximum request header size
  read_buffer_size: 4096 # 4KB - Read buffer size
  write_buffer_size: 4096 # 4KB - Write buffer size

# Garage S3 Configuration
garage:
  endpoint: "http://localhost:3900" # Garage S3 API endpoint
  region: "global" # S3 region (ensure it matches Garage S3 configuration)

  # Garage Admin API configuration
  admin_endpoint: "http://localhost:3903" # Garage Admin API endpoint
  admin_token: "xxxx" # Admin API bearer token

# Authentication Configuration
# You can enable one or both authentication methods
auth:
  # JWT Configuration
  # Ed25519 private key in PEM format for JWT token signing
  # If not specified, a new key will be generated on each startup (tokens won't persist across restarts)
  # Generate with: openssl genpkey -algorithm ED25519 -out jwt-key.pem
  # The key is a 64-byte Ed25519 private key
  jwt_private_key: "" # Leave empty to auto-generate, or provide PEM-encoded Ed25519 private key

  # Expose Prometheus metrics at top-level /metrics WITHOUT authentication.
  # Needed for Prometheus to scrape when auth (admin/token/oidc) is enabled.
  # WARNING: exposes operational cluster telemetry (no object data or secrets)
  # to anyone who can reach the port. Restrict with a NetworkPolicy / firewall.
  metrics_public: false # Set to true to serve /metrics unauthenticated

  # Admin Authentication (username/password)，用于web后台登录
  admin:
    enabled: true # Set to true to enable admin login
    username: "admin"
    password: "xxxx"

  # Admin Token Authentication
  # When enabled, users can log in using the Garage admin token
  # Auto-enabled when no other auth method is configured (zero-config fallback)
  token:
    enabled: false # Set to true to explicitly enable, or leave all auth disabled for auto-enable

  # OIDC Configuration
  # NOTE: When OIDC is enabled, server.root_url is required for OAuth2 redirects
  # The redirect URL will be automatically constructed as: {root_url}/auth/oidc/callback
  oidc:
    enabled: false # Set to true to enable OIDC login
    provider_name: "Keycloak"
    client_id: "garage-ui"
    client_secret: "your-client-secret"

    # OIDC scopes to request
    scopes:
      - openid
      - email
      - profile

    # OIDC Provider URLs
    issuer_url: "https://keycloak.example.com/realms/master"

    # Token validation
    skip_issuer_check: false
    skip_expiry_check: false

    # Attribute mappings
    email_attribute: "email"
    username_attribute: "preferred_username"
    name_attribute: "name"

    # Role-based access (optional)
    role_attribute_path: "resource_access.garage-ui.roles"
    # Team-based access control (optional, see access_control below).
    # team_attribute_path: "groups"
    # Single admin role (backward-compatible).
    admin_role: "admin"
    # Multiple admin roles: a user is granted admin if ANY of their roles
    # matches ANY entry below. Values from admin_role and admin_roles are
    # merged, so you can set either, both, or only admin_roles.
    # admin_roles:
    #   - "garage-admins"
    #   - "platform-team"

    # TLS configuration
    tls_skip_verify: false # Only set to true for testing, not recommended for production

    # Session configuration
    session_max_age: 86400 # 24 hours in seconds
    cookie_name: "garage_session"
    cookie_secure: false # Set to true in production with HTTPS
    cookie_http_only: true
    cookie_same_site: "lax" # lax, strict, none

# Optional: team-based access control (see docs/access-control.md).
# Absent  -> every authenticated user has full access.
# Present -> default-deny: OIDC users get only what their teams grant; users
#            matching no team get 403 everywhere. admin_role users, admin
#            password logins, and token logins are always full-admin.
# NOTE: this is UI-layer policy, NOT a security boundary. Anyone holding the
# Garage admin token or S3 keys bypasses it entirely.
#
# access_control:
#   presets:
#     bucket_readonly: [bucket.list, bucket.read, object.list, object.read]
#     bucket_owner: ["preset:bucket_readonly", bucket.create, bucket.update,
#                    bucket.delete, object.write, object.delete]
#   teams:
#     - name: backend
#       claim_values: ["garage-team-backend"]   # matched against team_attribute_path claim
#       bindings:
#         - bucket_prefixes: ["backend-"]
#           permissions: ["preset:bucket_owner"]
#         - bucket_prefixes: ["shared-"]
#           permissions: ["preset:bucket_readonly"]
#       cluster_permissions: [cluster.status, cluster.health]

# CORS Configuration (for frontend)
cors:
  enabled: true
  allowed_origins:
    - "*" # Vite default
  allowed_methods:
    - GET
    - POST
    - PUT
    - DELETE
    - OPTIONS
  allowed_headers:
    - Origin
    - Content-Type
    - Accept
    - Authorization
  allow_credentials: false
  max_age: 3600

# Logging Configuration
# The application uses zerolog for structured logging
logging:
  level: "info" # Options: debug, info, warn, error
  format: "text" # or "json"

启动容器

docker run -d \
--name garage-ui \
--network host \
-v /etc/garage-ui.yaml:/app/config.yaml \
noooste/garage-ui:latest

docker logs -f garage-ui

配置nginx反向代理

server {
    listen 443 ssl;
    server_name garage.example.com;
    charset utf-8;
    client_max_body_size 200m;
    ssl_certificate     /etc/nginx/cert.d/example.pem;
    ssl_certificate_key /etc/nginx/cert.d/example.key;
    if ($http_x_from_where = "frp") {
        return 404;
    }
    location / {
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_set_header X-NginX-Proxy true;
        proxy_pass http://192.168.100.44:8080;
        proxy_redirect off;
        proxy_connect_timeout 300s;
    }
}

访问web后台https://garage.example.com并使用配置的管理员账号密码登录

静态文件桶

有时想要将一些资源无需鉴权共享给他人，可以通过创建静态文件桶实现。

在garage-ui后台buckets菜单下新建bucket，名称为resource.example.com，即资源域名，其中资源可通过https://resource.example.com/xxx.png的形式访问
进入该资源桶详情页，点击Permissions标签页，选择一个access key，permissions中勾选read、write，并点击Grant access进行授权
点击Website标签页，打开website access并保存更改
点击Objects标签页，选择一个文件进行上传，成功后访问https://resource.example.com/filename.ext的形式访问验证

使用allinssl实现SSL证书自由

Thu, 13 Aug 2026 00:00:00 GMT

背景

不知从何时开始，各大云厂商不仅限制免费SSL证书数量，还限制证书有效实现为90天，后续还有可能变少。对于独立开发者来说，不仅是自己的域名还是给客户的域名，都需要SSL证书加密，而频繁更新配置是个繁琐的工作。

🚀 allinssl是一站式SSL证书生命周期管理解决方案，支持Let’s Encrypt、ZeroSSL、Google、SSL.COM、BuyPass等多家CA，还支持：

✅ 全自动证书申请/续期
🌐 多平台部署（CDN/WAF/面板/云存储）
🔔 证书过期监控
🛡️ 安全入口保护
📊 可视化证书管理
🤖 GO语言单个可执行文件

部署

从Github发布页面下载适合部署环境的最新报release
将压缩包解压得到的allinssl和allinssl.sh文件上传到服务器部署目录

# allinssl.sh中默认部署目录是/www/allinssl，需要调整时可以修改为自定义目录
WORK_DIR="/path/to/allinssl"

给allinssl赋予可执行全县并执行allinssl.sh，选择1启动服务

chmod +x allinssl
bash allinssl.sh 1

设置访问配置

# 查看面板访问信息
./allinssl 15
#  外网面板地址:      http://120.71.201.81:33927/6INIUUe1
#  内网面板地址:      http://192.168.100.51:33927/6INIUUe1
#  用户名:      admin
#  密码:       ********

# 👤 修改用户名
allinssl 5

# 🔑 修改密码
allinssl 6

全部CLI命令使用方式如下：

##
# Basic Operations
##
# Start service 🚀
allinssl 1
# Stop service ⛔
allinssl 2
# Restart service 🔄
allinssl 3
# Modify secure entry 🔐
allinssl 4
# Modify username 👤
allinssl 5
# Modify password 🔑
allinssl 6
# Modify port 🔧
allinssl 7

##
# Web Service Management
##
# Disable web service 🌐➖
allinssl 8
# Enable web service 🌐➕
allinssl 9
# Restart web service 🌐🔄
allinssl 10

##
# Background Task Management
##
# Disable background scheduler 📻⛔
allinssl 11
# Enable background scheduler 📻✅
allinssl 12
# Restart background scheduler 📻🔄
allinssl 13

##
# System Management
##
# Disable HTTPS 🔓
allinssl 14
# Get panel URL 📋
allinssl 15
# Update ALLinSSL to latest version (overwrite install) 🔄⬆️
allinssl 16
# Uninstall ALLinSSL 🗑️
bash allinssl.sh 17

使用

访问./allinssl 15输出的面板地址，输入设置的账号密码进行登录
点击授权API管理菜单，这里可以配置访问云厂商DNS所需的SecretId和SecretKey以及证书部署到远程服务器的SSH信息等。至少需要配置DNS提供商的SecretId和SecretKey，一般在云厂商后管理后台-访问页面获取
点击自动化部署菜单，添加基于快速部署模板的工作流
在边界页面可以调整工作流名称
点击开始节点，可以设置工作流执行模式（手动/定时）
点击申请证书节点，按照提示填写表单内容并保存
点击部署节点，选择本地部署/SSH/云厂商等不同类型并填写部署参数保存
根据实际情况决定是否需要通知节点，不需要时可删除
保存后在部署工作流页面可以手动执行验证

使用FRP实现内网穿透

Wed, 12 Aug 2026 00:00:00 GMT

frp 是一款高性能的反向代理应用，专注于内网穿透。它支持多种协议，包括 TCP、UDP、HTTP、HTTPS 等，并且具备 P2P 通信功能。使用 frp，您可以安全、便捷地将内网服务暴露到公网，通过拥有公网 IP 的节点进行中转。

官方文档

详细配置或更多内容请参考官方文档网站

安装

下载github releases页面中的frpc和frps，分别为客户端和服务端。客户端运行在需要暴露的服务所在内网服务器，服务端运行在有公网IP的服务器上。

systemd

在 Linux 系统下，使用 systemd 可以方便地控制 frps/frpc 的启动、停止、配置后台运行以及开机自启动。

如果您的 Linux 服务器上尚未安装 systemd，可以使用包管理器如 yum（适用于 CentOS/RHEL）或 apt（适用于 Debian/Ubuntu）来安装它：

# 使用 yum 安装 systemd（CentOS/RHEL）
yum install systemd

# 使用 apt 安装 systemd（Debian/Ubuntu）
apt install systemd

使用文本编辑器 (如 vim) 在 /etc/systemd/system 目录下创建一个 frps.service 文件，用于配置 frps 服务。

[Unit]
# 服务名称，可自定义
Description = frp server
After = network.target syslog.target
Wants = network.target

[Service]
Type = simple
# 启动frps的命令，需修改为您的frps的安装路径
ExecStart = /path/to/frps -c /path/to/frps.toml

[Install]
WantedBy = multi-user.target

现在可以轻松地使用 systemd 来管理 frps/frpc 服务，实现启动、停止、自动运行和开机自启动。确保替换路径和配置文件名称以匹配您的实际安装。

# 启动frp
sudo systemctl start frps
# 停止frp
sudo systemctl stop frps
# 重启frp
sudo systemctl restart frps
# 查看frp状态
sudo systemctl status frps
# 设置开机自启
sudo systemctl enable frps

nssm

在Windows系统下，可以使用NSSM将FRP运行为系统服务。NSSM（Non-Sucking Service Manager）是一款轻量级的 Windows 服务管理工具。它能将普通的第三方 .exe 程序、脚本或 Java 应用封装为标准的 Windows 系统服务，并在程序崩溃时自动重启，确保服务稳定运行。

从官网下载nssm应用，双击可查看应用程序使用方式。
找一个目录存放nssm可执行文件，并在资源管理器路径栏输入powershell打开powershell
执行.\nssm.exe install frpc吊起安装GUI

# 其他常用命令
#修改服务：
.\nssm.exe edit <服务名>
# 启动服务：
.\nssm.exe start <服务名>
# 停止服务：
.\nssm.exe stop <服务名>
# 删除服务：
.\nssm.exe remove <服务名>

执行文件路径选择frpc存放路径，arguments中填入-c \path\to\frpc.toml来指定配置文件

配置

frps.toml

# 监听的IP
bindAddr = "0.0.0.0"
# 服务端口
bindPort = 3000
vhostHTTPPort=80
vhostHTTPSPort=443

# 认证信息，与客户端一致
auth.method = "token"
auth.token = "xxxxxxx"

# web后台，浏览器可访问
webServer.addr = "0.0.0.0"
webServer.port = 4000
webServer.user = "xxxxxxx"
webServer.password = "xxxxxxx"

需要保证外界可访问bindPort和webServer.port端口，可能需要调整服务器安全组。

frpc.toml

# 服务端信息
serverAddr = "x.x.x.x"
serverPort = 3000

# 认证信息，与服务端一致
auth.method = "token"
auth.token = "xxxxxx"

# 一些优化配置，详情参考https://gofrp.org/zh-cn/docs/reference/client-configures/
transport.poolCount = 100
transport.heartbeatInterval = 30
transport.heartbeatTimeout = 90

# 日志
log.to = "/path/to/frp/log"
log.level = "info"

# 代理示例
# 将本地9999的服务暴露为x.x.x.x:21999
[[proxies]]
name = "proxy_tcp"
type = "tcp"
localIP = "127.0.0.1"
localPort = 9999
remotePort = 21999
# 将域名访问通过插件代理到内网
[[proxies]]
name = "https2http"
type = "https"
customDomains = ["example.com", "*.example.com"]
[proxies.plugin]
type = "https2http"
localAddr = "127.0.0.1:80"
crtPath = "/etc/nginx/cert.d/ssl.pem"
keyPath = "/etc/nginx/cert.d/ssl.key"
requestHeaders.set.x-from-where = "frp"

搭建HomeLab

Mon, 10 Aug 2026 00:00:00 GMT

顾名思义，就是家庭实验室。它可以理解为家庭版的云服务器，用来搭建各种服务，比如个人网盘、媒体服务器等等。

HomeLab 的硬件设备通常包括：

服务器：可以是物理服务器或虚拟机，用于搭建各类服务。
存储设备：如 NAS 和硬盘，用于存储数据。
网络设备：如软路由和硬路由，用于管理网络。
其他设备：如摄像头、传感器等，用于收集数据。

一个搭建好的homelab网络架构可能如下：

软路由

OpenWRT是主流的开源软路由方案，可以运行在非常多的路由器上。

ImmortalWrt是基于OpenWrt的优化版本，更适合在国内使用。

iStoreOS是另一个比较有名的软路由系统，主推路由+NAS功能。个人感觉该系统功能点繁多，稳定性上不如ImmortalWrt。

R3S是友善电子推出的开发版，非常适合运行软路由。

安装系统

参考R3S通过USB烧录教程，将FriendlyWrt烧录到R3S。
从ImmortalWrt固件下载指导选择FriendlyARM NanoPi R3S和适合的版本，下载EXT4映像。
参考R3S通过网页烧录教程，将下载的ImmortalWrt映像烧录到R3S。
R3S的WAN口连接光猫LAN口，R3S的LAN口连接路由器的WAN口。

科学上网

从passwall插件GitHub页面releases中下载类似xx.xx-_luci-passwall-x.x.x_all.ipk的安装包
打开immortalwrt后台-系统-软件包，点击上传软件包按钮，选择刚才的ipk文件上传并安装。安装后顶部菜单多出来“服务”，子菜单是passwall
点击服务-passwall-节点订阅，在下方找到添加订阅链接按钮，点击后填写机场信息、自动更新等，点击“保存并应用”。
点击节点列表可以看到从订阅链接获取到的所有节点，可以进行测速找出优质线路。
点击基本设置-主要，TCP节点选择网速较好的节点，UDP节点选择与TCP相同，选中主开关checkbox并点击保存并应用。
刷新页面应该能看到运行状态中TCP、UDP和DNS显示运行中，现在可以点击下方测速链接进行验证并上网。

路由器

一般来说，运营商光猫会自带WI-FI功能，该功能可以保留作为软路由异常时的容灾方案。

需要搭配中继模式的路由器将所有设备连接到软路由网络。

一般路由器都支持中继模式，以小米路由器为例，具体设置步骤如下：

路由器WAN口连接R3S的LAN口，连接电源并开机。
电脑连接小米WI-FI，一般是XIAOMI_XXXX的形式。连接后应该自动跳转到后台页面，未跳转可以访问192.168.31.1。
首次进入时会提示设置WI-FI名称、密码等信息，按照实际需求设置即可。
进入管理界面后，点击路由器设置-上网设置-工作模式切换-切换，选择有线中继并确认，等待设置完成即可。

交换机

如果路由器的LAN口不足以支撑需要有线连接的设备，可以考虑在LAN口接入交换机，推荐至少2.5G，接口数量可以根据实际需求而定。

PVE

既然是HomeLab，那肯定是要在家中部署一些服务，而PVE是虚拟机+LXC的最佳解决方案。

推荐将PVE安装在闲置台式机或工控机上。

安装

下载适合CPU架构的PVE安装器
利用etcher或rufus工具，将下载的ISO文件写入U盘制作启动盘
在台式机或工控机上插入U盘重启进入BIOS，选择U盘启动来安装系统
按照步骤安装系统，安装成功后会输出管理后台地址
重启台式机或工控机以完成安装，重启时需要拔掉U盘

设置Debian服务器

Mon, 10 Aug 2026 00:00:00 GMT

本教程中Debian系统默认为13，不建议使用以前的版本。更多debian相关资料推荐访问debian club

设置apt镜像源

默认的Debian官方源在国内下载可能会比较慢，建议配置中科大镜像源

一行命令替换官方源

sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources

或手动设置/etc/apt/sources.list.d/debian.sources文件内容如下

Types: deb
URIs: http://mirrors.ustc.edu.cn/debian
Suites: trixie trixie-updates
Components: main contrib non-free non-free-firmware
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg

Types: deb
URIs: http://mirrors.ustc.edu.cn/debian-security
Suites: trixie-security
Components: main contrib non-free non-free-firmware
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg

修改完成后需要执行apt update使新镜像源生效

安装VIM

一般系统自带VI，为了获得更好的编辑体验，建议安装VIM

apt install vim

设置SSH

一般云厂商提供的网页版终端并不好用，所以都会选择xshell等终端工具连接，这就需要修改sshd配置。

vim /etc/ssh/sshd_config

# 端口和IP配置。主要用来更换连接端口，注释就是默认值
#Port 22
#AddressFamily any
#ListenAddress 0.0.0.0
#ListenAddress ::

# 是否允许root用户远程登录。默认禁止，具体看企业安全要求
PermitRootLogin yes

# 是否启用密码登录。有些环境可能需要通过密钥登录
PasswordAuthentication yes

设置时区

系统默认时区可能不是东八区，这会导致应用部署时定时任务、日志等遇见一些问题，可通过下方命令调整

# 查看当前时间
date
# 修改时区
timedatectl set-timezone Asia/Shanghai

Nestjs基础使用

Wed, 01 Apr 2026 00:00:00 GMT

请求流程

Docker数据目录迁移

Mon, 02 Mar 2026 00:00:00 GMT

背景

docker安装后默认再/var/lib/docker目录下存储数据，随着容器、镜像增多以及日志文件变大，可能会出现var目录存储空间不足的问题。

迁移步骤

复制数据目录

# 停止docker服务
systemctl stop docker
# 按照原本权限复制数据，不然会影响已经启动的容器的重新运行
cp -arv /var/lib/docker /path/to/data/root

修改daemon配置

修改/etc/docker/daemon.json文件内容如下（不存在则创建）：

{
    // 数据目录
    "data-root": "/path/to/data/root",
    "log-driver": "json-file",
    // 日志配置
    "log-opts": {
        // 禁用缓存
        "cache-disabled": "false",
        // 最多缓存文件数量
        "cache-max-file": "5",
        // 每个缓存文件最大大小
        "cache-max-size": "20m",
        // 压缩缓存文件
        "cache-compress": "true",
        //
        "env": "os,customer",
        // 最多日志文件数量
        "max-file": "10",
        // 每个日志文件最大大小
        "max-size": "10m"
    }
}

重启服务

# 刷新配置
systemctl daemon-reload
# 启动docker
systemctl start docker
# 启动容器
systemctl start container1 ...

清理数据

充分测试没问题之后，可以将原先数据存储目录/var/lib/docker删除

Docker基础使用

Sun, 01 Mar 2026 00:00:00 GMT

基本概念

docker的使命

docker是为了解决跨环境迁移软件的时候由于环境不同出现的“水土不服”问题，保证软件在不同的环境中的运行环境是一致的。

镜像-image

是将程序与其运行所需的环境放在一起打的包。

容器-container

将image与其他image隔离开运行的环境。image与container的关系很像类与对象的关系。

仓库-Registry

有官方提供的仓库https://hub.docker.com，用于将一个个image分享出来，也可以创建私有仓库。

数据卷

基本概念

数据卷是宿主机中的一个目录或文件，一个容器可以挂载多个数据卷，一个数据卷也可以被多个容器同时挂载，从而实现容器数据持久化、外部机器与容器的间接通信、容器与容器的数据交换

配置数据卷

在创建容器时通过-v命令

数据卷容器

指用于在容器之间进行数据交换的容器

创建过程：

# 创建数据卷容器
docker run -itd --name DATA_CONTAINER_NAME -v /volume IMAGE_NAME:TAG
# 创建两个需要数据交换的容器并与数据卷容器连接
docker run -itd --name CONTAINER_NAME1 --volumes-from DATA_CONTAINER_NAME IMAGE_NAME:TAG
docker run -itd --name CONTAINER_NAME2 --volumes-from DATA_CONTAINER_NAME IMAGE_NAME:TAG

安装

以debian 13为例，其他的可以去docker官网安装指南查看。

apt update
apt install -y ca-certificates curl
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
apt update
# 设置docker镜像加速
tee /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": [
    "https://docker.1ms.run"
  ]
}
EOF
apt install -y docker-ce docker-ce-cli containerd.io
systemctl daemon-reload
systemctl start docker
systemctl status docker

命令

综合

启动docker

Systemctl start docker
停止docker

Systemctl stop docker
重新启动docker

systemctl restart docker
查看docker状态

Systemctl status docker
将docker设置为开机启动

systemctl enable docker

image

查看本地镜像列表

docker images
从网络中搜索镜像

docker search POSSIBLE_IMAGE_NAME
获取镜像

docker pull IMAGE_NAME:IMAGE_VERSION，例如docker pull mysql:5.7，如果不指定版本，则为latest。
获取镜像ID列表

docker images -q
删除一个镜像
- 根据镜像名称
  
  docker image rm IMAGE_NAME:IMAGE_VERSION
- 根据镜像ID
  
  docker image rm IMAGE_ID，如果某个镜像安装的特定版本和latest版本相同，则两者ID相同，此时可以通过名称删除。
删除所有镜像

docker image rm `docker images -q`

docker image rm快捷写法是docker rmi

container

查看正在运行的容器

docker ps
查看所有容器

docker ps -a
查看所有容器的ID

docker ps -aq
创建容器

docker run [COMMANDS] IMAGE_NAME:TAG /IMAGE_ID [OPTIONS]

COMMANDS包括：
- -i
  
  在没有客户端连接到容器时也保持容器运行
- -t
  
  给容器分配一个伪终端
- -d
  
  保持容器后台运行
- -v
  
  配置数据卷，例如：-v HOST_DIR/HOST_FILE:CONTAINER_DIR/CONTAINER_FILE，目录必须是绝对路径，目录不存在则会自动创建，可以挂载多个数据卷
- –name CONTAINER_NAME
  
  为容器起个名字
OPTIONS包括：
- /bin/bash
  
  进入到为容器分配的伪终端中
进入容器

docker exec [COMMANDS] CONTAINER_NAME

COMMANDS与创建容器时的类似
退出容器

exit
启动容器

docker start CONTAINER_NAME/CONTAINER_ID
停止容器

docker stop CONTAINER_NAME/CONTAINER_ID
删除容器

docker rm CONTAINER_NAME/CONTAINER_ID，不能删除正在运行的容器，删除之前需要先停止。
删除所有容器

docker rm 'docker ps -aq'
查看容器信息

docker inspect CONTAINER_NAME/CONTAINER_ID

Dockerfile

Docker镜像原理

镜像的本质

Linux文件文件系统有bootfs和rootfs两部分组成，不同的linux发行版bootfs基本一样，rootfs不同：

bootfs

包含bootloader（引导加载程序）和kernel（内核）
rootfs

root文件系统，/etc /root 等等。

Dcoker镜像是由特殊的文件系统叠加而成的。最底端是bootfs，第二层是rootfs，再往上可以叠加其他的镜像文件。

统一文件系统技术将不同的层整合在一起提供统一的视角，从用户的视角就是一个文件系统。

一个镜像可以放在另一个镜像上面，下面的成为父镜像。

![截屏2022-07-12 上午10.19.20](/Users/xyb/Desktop/notes/Docker教程.assets/截屏2022-07-12 上午10.19.20.png)

为什么有的镜像比安装包小很多？

最底端是bootfs，可以利用宿主系统的bootfs

为什么有的镜像比安装包大很多？

这种镜像内部很可能嵌套了多层镜像

制作镜像

值得注意的是，在将容器转为镜像的过程中，在宿主机与容器挂载的文件或目录中做的更改不会转化，但在容器中对目录或文件的修改则会转化。

容器转镜像

# 将容器转为镜像
docker commit CONTAINER_ID IMAGE_NAME:TAG
# 将镜像转为压缩文件，用于传输
docker save -o COMPRESSED_FILE_NAME IMAGE_NAME:TAG
# 获取压缩文件的机器可以加载压缩文件中的镜像
docker load -i COMPRESSED_FILE_NAME

dockerfile

就是一个普通的文本配置文件，docker根据配置创建镜像，下方是示例：

# 指定父镜像
FROM FATHER_IMAGE_NAME:TAG

# 作者信息
MAINTAINER AUTHER_NAME<AUTHER_EMAIL>

# 标签
# 可以按照如下方式写多个
#   LABEL "com.example.vendor"="ACME Incorporated"
#   LABEL com.example.label-with-value="foo"
#   LABEL version="1.0"
#   LABEL description="This text illustrates \
#   that label-values can span multiple lines."
# 也可以如下方式写
#   LABEL multi.label1="value1" \
#     multi.label2="value2" \
#     other="value3"
# 或者是
#   LABEL multi.label1="value1" multi.label2="value2" other="value3"
LABEL <key>=<value> <key>=<value> <key>=<value> ...

# 执行Linux命令，创建容器的时候执行
# 例如：RUN /bin/bash -c 'source $HOME/.bashrc; \
# echo $HOME'
# 或者：RUN ["/bin/bash", "-c", "echo hello"]
RUN DOMMAND/["command", "param1", "param2"]

# 挂载数据卷
VOLUME HOST_PATH CONTAINER_PATH

# 环境变量
ENV PARAM_NAME=PARAM_VALUE

# 工作目录，即容器启动后进入容器伪终端时的默认目录
WORKDIR /usr

# 暴露端口，即端口映射，可以指定协议
EXPOSE PORT/PROTOCAL?

# 执行Linux命令，在容器启动的时候执行
CMD ["command", "param1", "param2"]

# 复制文件到image中
COPY

# 添加文件
ADD

写好配置文件后就可以制作镜像了：

# 制作镜像
# -f 指定dockerfile的路径
# -t 指定构建后镜像的名称和版本
# 最后的点表示寻址的路径
docker build -f DOCKER_FILE_PATH -t IMAGE_NAME:TAG .

案例

制作springboot项目镜像dockerfile

FROM java:8
# 前面的是相对当前目录jar包的位置 后面的是容器内的路径
ADD XXXX.jar app.jar
CMD java -jar app.jar

daemon.json

这是docker的配置文件，存储在/etc/docker目录下，详细配置如下：

{
  // docker相关配置，启动对应配置时将注释去掉即可


  // "allow-nondistributable-artifacts": [],
  // "api-cors-header": "",
  // "authorization-plugins": [],
  // "bip": "",
  // "bridge": "",
  // "cgroup-parent": "",
  // "cluster-advertise": "",
  // "cluster-store": "",
  // "cluster-store-opts": {},
  // "containerd": "/run/containerd/containerd.sock",
  // "containerd-namespace": "docker",
  // "containerd-plugin-namespace": "docker-plugins",

  // 指定数据目录，docker产生的数据将在这里存储，默认是/var/lib/docker
  "data-root": "/data/docker",

  // "debug": true,
  // "default-address-pools": [
    // {
      // "base": "172.30.0.0/16",
      // "size": 24
    // },
    // {
    //   "base": "172.31.0.0/16",
    //   "size": 24
    // }
  // ],
  // "default-cgroupns-mode": "private",
  // "default-gateway": "",
  // "default-gateway-v6": "",
  // "default-runtime": "runc",
  // "default-shm-size": "64M",
  // "default-ulimits": {
  //   "nofile": {
  //     "Hard": 64000,
  //     "Name": "nofile",
  //     "Soft": 64000
  //   }
  // },
  // "dns": [],
  // "dns-opts": [],
  // "dns-search": [],
  // "exec-opts": [],
  // "exec-root": "",
  // "experimental": false,
  // "features": {},
  // "fixed-cidr": "",
  // "fixed-cidr-v6": "",
  // "group": "",
  // "hosts": [],
  // "icc": false,
  // "init": false,
  // "init-path": "/usr/libexec/docker-init",

  // 私有仓库位置
  "insecure-registries": [],

  // "ip": "0.0.0.0",
  // "ip-forward": false,
  // "ip-masq": false,
  // "iptables": false,
  // "ip6tables": false,
  // "ipv6": false,
  // "labels": [],
  // "live-restore": true,

  // 日志引擎，默认是json-file
  "log-driver": "json-file",
  // 日志级别
  // "log-level": "",
  // 日志配置
  "log-opts": {
    // 禁用缓存
    "cache-disabled": "false",
    // 最多缓存文件数量
    "cache-max-file": "5",
    // 每个缓存文件最大大小
    "cache-max-size": "20m",
    // 压缩缓存文件
    "cache-compress": "true",
    //
    "env": "os,customer",
    // "labels": "somelabel",
    // 最多日志文件数量
    "max-file": "10",
    // 每个日志文件最大大小
    "max-size": "10m"
  },

  // "max-concurrent-downloads": 3,
  // "max-concurrent-uploads": 5,
  // "max-download-attempts": 5,
  // "mtu": 0,
  // "no-new-privileges": false,
  // "node-generic-resources": [
  //   "NVIDIA-GPU=UUID1",
  //   "NVIDIA-GPU=UUID2"
  // ],
  // "oom-score-adjust": -500,
  // "pidfile": "",
  // "raw-logs": false,

  // 仓库镜像，可以加速下载镜像
  "registry-mirrors": [
    // docker官方镜像
    "https://registry.docker-cn.com",
    "https://docker.mirrors.ustc.edu.cn/",
    "https://hub-mirror.c.163.com/"
  ],

  // "runtimes": {
  //   "cc-runtime": {
  //     "path": "/usr/bin/cc-runtime"
  //   },
  //   "custom": {
  //     "path": "/usr/local/bin/my-runc-replacement",
  //     "runtimeArgs": [
  //       "--debug"
  //     ]
  //   }
  // },
  // "seccomp-profile": "",
  // "selinux-enabled": false,
  // "shutdown-timeout": 15,
  // "storage-driver": "",
  // "storage-opts": [],
  // "swarm-default-advertise-addr": "",
  // "tls": true,
  // "tlscacert": "",
  // "tlscert": "",
  // "tlskey": "",
  // "tlsverify": true,
  // "userland-proxy": false,
  // "userland-proxy-path": "/usr/libexec/docker-proxy",

  //
  // 不注释下面的行，这样能保证json语法正确
  "userns-remap": ""
}

更新完成之后需要重启docker服务才会生效：

# 加载配置文件
systemctl daemon-reload
# 重启docker生效
systemctl restart docker

Nginx实现正向代理

Mon, 02 Feb 2026 00:00:00 GMT

解释

安装

cd /root
# 从http://nginx.org/download下载合适的版本（1.25.3）
tar -xvzf nginx-1.25.3.tar.gz
cd nginx-1.25.3
mkdir modules
# 从https://github.com/chobits/ngx_http_proxy_connect_module下载文件夹
# patch版本需要根据README.md中的版本对应关系
patch -p1 < /root/nginx-1.25.3/modules/ngx_http_proxy_connect_module/patch/proxy_connect_rewrite_102101.patch
# 中途如果提示部分库不存在，补充安装即可。需要config过程不能出错
./configure --add-module=/root/nginx-1.25.3/modules/ngx_http_proxy_connect_module
# 编译并安装，需要解决编译安装过程中可能出现的问题
make && make install

配置

在nginx配置目录增加sites文件夹，创建proxy文件：

server {
    listen 7890;
    # DNS 解析器，用于正向代理
    # resolver <dns_ip> ipv6=off;
    # 对 CONNECT 请求的正向代理
    proxy_connect;
    proxy_connect_allow 443 563;
    proxy_connect_connect_timeout 10s;
    proxy_connect_data_timeout 10s;
    # 非 CONNECT 请求的自定义配置
    # 示例：非 CONNECT 请求的反向代理
    location / {
        proxy_pass http://$host;
        proxy_set_header Host $host;
    }
}

测试

在其他无法访问外网，但能访问代理主机的服务器上通过代理访问

curl --proxy <proxy_server_id>:<proxy_server_port> https://www.baidu.com

为方便起见，可将代理地址暴露在环境变量而无需再发起请求时指定代理地址：

# 增加bashrc内容
export http_proxy=http://<proxy_server_id>:<proxy_server_port>
export https_proxy=http://<proxy_server_id>:<proxy_server_port>
# 请求测试
curl https://wwww.baidu.com

使用keepalived实现nginx高可用部署

Sun, 01 Feb 2026 00:00:00 GMT

	服务器1	服务器2
系统	Red Hat Enterprise Linux release 8.6 (Ootpa)	Red Hat Enterprise Linux release 8.6 (Ootpa)
IP	192.168.12.11	192.168.12.12
nginx版本	nginx-1.14.1-9.module+el8.0.0+4108+af250afe.x86_64	nginx-1.14.1-9.module+el8.0.0+4108+af250afe.x86_64
keepalived版本	keepalived-2.1.5-8.el8.x86_64	keepalived-2.1.5-8.el8.x86_64
虚拟IP	192.168.12.10（需要保证该IP未被路由）

解决方案

双机主从模式：即前端使用两台服务器，一台主服务器和一台热备服务器，正常情况下，主服务器绑定一个公网虚拟IP，提供负载均衡服务，热备服务器处于空闲状态；当主服务器发生故障时，热备服务器接管主服务器的公网虚拟IP，提供负载均衡服务；但是热备服务器在主机器不出现故障的时候，永远处于浪费状态，对于服务器不多的网站，该方案不经济实惠。
双机主主模式：即前端使用两台负载均衡服务器，互为主备，且都处于活动状态，同时各自绑定一个公网虚拟IP，提供负载均衡服务; 当其中一台发生故障时，另一台接管发生故障服务器的公网虚拟IP（这时由非故障机器一台负担所有的请求）。

配置nginx

两台测试机都需要安装nginx：

yum install nginx -y

修改nginx配置增加server：

server {
   listen 80;
   server_name 192.168.12.10;
   location /nginx-test {
    return 200 "Hello from Nginx@XX"; # 为了区分两个服务器在这里可以加上IP
   }
}

为了更直观地看到高可用方案生效，将两台服务器nginx默认返回html做修改以区分。安装完成后启动nginx：

systemctl start nginx.service
#查看nginx运行状态，确保nginx已经正常启动
systemctl status nginx
#设置nginx服务开机自启动
systemctl enable nginx.service

配置keepalived

两台测试机都需要安装keepalived：

yum install keepalived -y

安装完成后修改/etc/keepalived/keepalived.conf文件，配置内容如下：

! Configuration File for keepalived

global_defs {
  router_id master # 集群中该主机的id，需要唯一
}

# 定时检查nginx状态
vrrp_script check_nginx {
   script "/etc/keepalived/check_nginx.sh" # 检查脚本位置
   interval 2 # 检查时间间隔2s
   weight -5 # 失败后权重减少5
   fall 3 # 三次失败后切换主备
   rise 2
}

vrrp_instance VI_1 {
   state MASTER # 标识主服务器
   interface ens192 # 这个网卡名称可以通过lshw -class net -businfo来查看
   virtual_router_id 51 # 同一个集群需要相同
   priority 100 # 权重，master要大于slave
   advert_int 1 # 主备通讯时间间隔
   # 源地址（只在组播不同的情况下配置）
   unicast_src_ip 192.168.12.11
   # 目标地址（只在组播不同的情况下配置）
   unicast_peer {
    192.168.12.12
   }
   authentication {
      auth_type PASS
      auth_pass 1111
   }
   virtual_ipaddress {
    192.168.12.10 #虚拟ip，随便写一个没有被用到的ip
   }
}

另外一台备份服务器也需要配置如下：

! Configuration File for keepalived

global_defs {
  router_id slave # 集群中该主机的id，需要唯一
}

# 定时检查nginx状态
vrrp_script check_nginx {
   script "/etc/keepalived/check_nginx.sh" # 检查脚本位置
   interval 2 # 检查时间间隔2s
   weight -5 # 失败后权重减少5
   fall 3 # 三次失败后切换主备
   rise 2
}

vrrp_instance VI_1 {
   state BACKUP # 标识主服务器
   interface ens192 # 这个网卡名称可以通过lshw -class net -businfo来查看
   virtual_router_id 51 # 同一个集群需要相同
   priority 90 # 权重，master要大于slave
   advert_int 1 # 主备通讯时间间隔
   # 源地址（只在组播不同的情况下配置）
   unicast_src_ip 192.168.12.12
   # 目标地址（只在组播不同的情况下配置）
   unicast_peer {
    192.168.12.11
   }
   authentication {
      auth_type PASS
      auth_pass 1111
   }
   virtual_ipaddress {
    192.168.12.10 #虚拟ip，随便写一个没有被用到的ip
   }
}

其中检查nginx状态的脚本/etc/keepalived/check_nginx.sh如下：

#!/bin/bash
counter=$(ps -C nginx --no-heading|wc -l)
if [ "${counter}" = "0" ]; then
   systemctl restart nginx.service
   sleep 2
   counter=$(ps -C nginx --no-heading|wc -l)
   if [ "${counter}" = "0" ]; then
    systemctl stop keepalived.service
   fi
fi

启动keepalived：

systemctl start keepalived.service
#查看keepalived服务状态，确保已经正常启动
systemctl status keepalived
#设置keepalived服务开机自启动
systemctl enable keepalived.service

配置防火墙

由于防火墙会导致主服务器异常时虚拟IP无法漂移到备份服务器，需要针对keepalived做出防火墙规则的调整。Keepalived使用vrrp组播，默认地址是224.0.0.18，因此要配置防火墙放过：

firewall-cmd --direct --permanent --add-rule ipv4 filter INPUT 0 --destination 224.0.0.18 --protocol vrrp -j ACCEPT
firewall-cmd --direct --permanent --add-rule ipv4 filter OUTPUT 0 --destination 224.0.0.18 --protocol vrrp -j ACCEPT

需要放过nginx端口：

firewall-cmd --zone=public --add-port=80/tcp --permanent

重载防火墙配置：

firewall-cmd --reload

配置SELinux

如果SELinux处于开启状态并且未放开http上游连接会导致nginx无法将请求转发到上游服务，所以需要关闭或配置SELinux。

关闭SELinux

setenforce 0

配置SELinux 如果不能关闭selinux，则需要配置一下相关规则：

semanage permissive -a httpd_t

测试验证

在域中的用户电脑上打开命令行请求虚拟IP：

curl http://192.168.12.10/nginx-test # 输出“Hello from Nginx@88”，该消息来自主服务器

在主服务器中停止keepalived服务模拟主服务器异常：

systemctl stop keepalived

再次在用户电脑中请求虚拟IP：

curl http://192.168.12.10/nginx-test # 输出“Hello from Nginx@114”，该消息来自备份服务器

说明已经实现了nginx的高可用。此时可以重新启动主服务器上的keepalived服务：

systemctl restart keepalived

再次在用户电脑上请求虚拟IP：

curl http://192.168.12.10/nginx-test # 输出“Hello from Nginx@88”，该消息来自主服务器

说明主服务器重新加入到集群中。

Linux常用命令

Thu, 01 Jan 2026 00:00:00 GMT

pwd

显示当前目录

ls

ls -a：显示所有文件（包括隐藏文件）
ls -l：显示详细信息
ls -R：递归显示子目录结构
ls -ld：显示目录和链接信息

rm

apt

cp

cp 源文件（文件夹）目标文件（文件夹）

常用参数：-r:递归复制整个目录树；-v：显示详细信息；复制文件夹时要在cp命令后面加一个-r参数：如：cp -r 源文件夹目标文件夹