数据库 on heyaohua's Blog

MySQL→PostgreSQL 主从架构迁移方案（读写分离版）

Thu, 09 Oct 2025 12:15:00 +0800

目标：用 PostgreSQL 的 WAL + Streaming Replication 实现“写走主、读走从”，并提供生产可用的高可用与连接层方案，附配置模板与运维脚本示例。适配 PostgreSQL 16/17/18。

1. 架构总览

1.1 基础拓扑（最小可用）

App(写) ─────────►  Primary(主)
                ╲
                 ╲ WAL Stream
                  ╲
App(读) ───────────► Standby1(从)
                   ► Standby2(从)

写请求：直连主库。
读请求：直连从库（或通过中间层，见 §4）。
主从：物理复制（Streaming Replication），异步或半同步可选。

1.2 生产级拓扑（推荐）

               +-------------------+
               |    pgbouncer      |  连接池（减少连接抖动）
               +-------------------+
                        │
                 +--------------+
                 |   Pgpool-II  |  SQL解析级读写分离/健康检查/故障转移脚本
                 +--------------+
                     │     │
                (Write)   (Read)
                     │     │
                   Primary  ──┬── Standby1
                              └── Standby2

        +-------------------+
        | Patroni + etcd    |  主从编排/自动故障切换/仲裁
        +-------------------+

可替换 Pgpool-II 为 HAProxy（协议层转发）+ 应用侧读写分离（双 DSN）。
可替换 Patroni 为 repmgr 或手工脚本（风险更高）。

2. 版本与参数基线

推荐版本：PostgreSQL 17（当前成熟稳定）或 18（新项目/前瞻特性）。
最小参数：
wal_level = replica（或 logical 若需逻辑复制）
max_wal_senders ≥ 从库数 + 维护冗余（例如 10）
wal_keep_size：按网络/故障时间留足（例如 512MB~2GB）
archive_mode = on + archive_command（若做增量备份/回放）
半同步：synchronous_commit = on + synchronous_standby_names = 'FIRST 1 (standby1, standby2)'

3. 数据层：主从复制配置模板（物理复制）

3.1 主库 `postgresql.conf`

# 基础
listen_addresses = '*'
port = 5432

# 复制/WAL
wal_level = replica
max_wal_senders = 10
max_wal_size = 4GB
min_wal_size = 1GB
wal_keep_size = 1024MB

# 半同步（可选）
# synchronous_commit = on
# synchronous_standby_names = 'FIRST 1 (standby1, standby2)'

# 性能观测（推荐开启）
shared_preload_libraries = 'pg_stat_statements'
pg_stat_statements.max = 10000
pg_stat_statements.track = all

# 归档（如采用 pgBackRest 则由其接管）
# archive_mode = on
# archive_command = 'test ! -f /var/backup/%f && cp %p /var/backup/%f'

3.2 主库 `pg_hba.conf`

# 允许业务访问
host    all             appuser         10.0.0.0/16           scram-sha-256

# 允许复制连接（repl 角色）
host    replication     repl            10.0.0.0/16           scram-sha-256

3.3 创建复制用户

CREATE ROLE repl WITH REPLICATION LOGIN PASSWORD 'REPLACE_WITH_REPL_PASSWORD';

3.4 从库基线拉起（pg_basebackup）

在 Standby 节点执行：

pg_basebackup -h 10.0.0.10 -p 5432 -U repl \
  -D /var/lib/postgresql/17/data -X stream -C -S standby1_slot -R -P

-R：自动写入 standby.signal 与 primary_conninfo。
-C -S standby1_slot：自动创建复制槽，防止 WAL 丢失。
多个从库请使用不同 slot 名称：standby2_slot 等。

3.5 启动与验证

启动从库后，在主库查看：

SELECT pid, application_name, client_addr, state, sync_state, sent_lsn, write_lsn, flush_lsn, replay_lsn
FROM pg_stat_replication;

从库延迟：

SELECT now() - pg_last_xact_replay_timestamp() AS standby_delay;

3.6 延迟从库（防误删回滚保护，可选）

从库 postgresql.auto.conf 增加：

recovery_min_apply_delay = '5min'

4. 连接层：读写分离方案

4.1 Pgpool-II（SQL 解析级，自动区分读/写）

核心优点

会解析 SQL 并将 SELECT 分发到从库，将写语句路由到主库；
内置健康检查、自动跟随主库（follow_primary_command），可脚本化故障切换；
与 pgbouncer 叠加实现“连接池 + 读写分离”。

4.1.1 `pgpool.conf` 样例（核心片段）

# 监听
listen_addresses = '0.0.0.0'
port = 9999

# 后端节点（node_id 从 0 开始）
backend_hostname0 = '10.0.0.10'   # primary
backend_port0     = 5432
backend_weight0   = 1
backend_flag0     = 'ALWAYS_PRIMARY'

backend_hostname1 = '10.0.0.11'   # standby1
backend_port1     = 5432
backend_weight1   = 1
backend_flag1     = 'ALLOW_TO_FAILOVER'

backend_hostname2 = '10.0.0.12'   # standby2
backend_port2     = 5432
backend_weight2   = 1
backend_flag2     = 'ALLOW_TO_FAILOVER'

# 读写分离与负载
load_balance_mode = on                 # 允许 SELECT 负载到从库
statement_level_load_balance = on      # 语句级平衡（谨慎与事务特性）
replication_mode = off                 # 非多主
master_slave_mode = on
master_slave_sub_mode = 'stream'       # Streaming Replication

# 健康检查
health_check_period = 5
health_check_timeout = 3
health_check_user = 'pgpool'           # 仅用于健康检查的低权账号
health_check_password = '***'

# 主从跟随（当主切换时，更新路由）
follow_primary_command = '/usr/local/bin/pgpool-follow-primary %d %h %p %D %m %H %M %P %r %R'

# 会话保持与函数黑名单（避免副作用语句被当作读）
black_function_list = 'nextval,setval'
white_function_list = ''

# 日志
log_per_node_statement = off
log_statement = off

4.1.2 `pool_hba.conf`

host    all     all     10.0.0.0/16     scram-sha-256

4.1.3 `pcp.conf`

admin:SCRAM-SHA-256$

4.1.4 典型运维脚本占位

pgpool-follow-primary：当检测到新主库后，自动调整后端主从角色并重载。
failover_streaming：在主库失效时，触发预设的 Promote（若未用 Patroni）。

注：Pgpool-II 与 prepared statements / 长事务叠加时需评估；对强一致读，可将关键读强制走主（应用层或 app_name 路由）。

4.2 HAProxy + pgbouncer（轻量级）

策略：对应用提供两个 DSN：
写：haproxy-write:5432（仅指向主库或 Patroni 的主 VIP）
读：haproxy-read:5432（轮询多个从库）
HAProxy 核心示例：

frontend pg_write
  bind *:5000
  default_backend pg_primary

backend pg_primary
  option tcp-check
  server primary 10.0.0.10:5432 check

frontend pg_read
  bind *:5001
  default_backend pg_standbys

backend pg_standbys
  balance roundrobin
  option tcp-check
  server s1 10.0.0.11:5432 check
  server s2 10.0.0.12:5432 check

pgbouncer：建议 transaction 池化模式，注意与 server_reset_query 配置，避免事务泄漏。

5. 高可用：Patroni + etcd（推荐）

5.1 部署要点

各节点运行 Patroni，使用 etcd（或 Consul）存储集群状态；
Patroni 负责：
主从编排、健康检查、自动 promote；
维护 postgresql.conf 与复制参数；
提供 REST API（供 HAProxy/keepalived 识别主）。

5.2 Patroni 样例配置（`/etc/patroni/pg01.yml`）

scope: pg-cluster
name: pg01

restapi:
  listen: 0.0.0.0:8008
  connect_address: 10.0.0.10:8008

etcd:
  hosts: 10.0.0.20:2379,10.0.0.21:2379,10.0.0.22:2379

postgresql:
  listen: 0.0.0.0:5432
  connect_address: 10.0.0.10:5432
  data_dir: /var/lib/postgresql/17/data
  bin_dir: /usr/lib/postgresql/17/bin
  parameters:
    wal_level: replica
    max_wal_senders: 10
    wal_keep_size: 1024MB
    shared_preload_libraries: pg_stat_statements
  authentication:
    replication:
      username: repl
      password: REPLACE_WITH_REPL_PASSWORD
    superuser:
      username: postgres
      password: REPLACE_WITH_SUPERUSER_PASSWORD
  pg_hba:
  - host all all 0.0.0.0/0 scram-sha-256
  - host replication repl 0.0.0.0/0 scram-sha-256

synchronous_mode: false   # 如需半同步置 true，并配置 standby 优先级

其他节点将 name 与 connect_address 对应修改即可。

5.3 与 HAProxy 集成（识别主）

HAProxy 可基于 Patroni REST 的 /master endpoint 进行后端切换，或以 tag 端口代理当前主。

6. 运维脚本与常见操作

6.1 手工主从切换（无 Patroni 场景）

在待升主的从库执行 Promote：

pg_ctl -D /var/lib/postgresql/17/data promote

调整应用/中间件连接到新主。
原主修复后以从库身份重拉：

pg_ctl -D /var/lib/postgresql/17/data stop
rm -rf /var/lib/postgresql/17/data/*
pg_basebackup -h NEW_PRIMARY -U repl -D /var/lib/postgresql/17/data -X stream -R -P -C -S oldprimary_slot
pg_ctl -D /var/lib/postgresql/17/data start

6.2 创建/查看复制槽

-- 创建逻辑槽（如需逻辑复制）
SELECT * FROM pg_create_logical_replication_slot('app_slot', 'pgoutput');

-- 查看复制槽
SELECT slot_name, slot_type, active, restart_lsn FROM pg_replication_slots;

6.3 只读事务（强一致读在主库）

BEGIN READ ONLY;  -- 强制在主库读（通过路由或角色策略）
SELECT ...;
COMMIT;

7. 监控与告警

7.1 关键视图

-- 主库查看复制
SELECT * FROM pg_stat_replication;

-- WAL 生成量
SELECT date_trunc('hour', now()) AS ts,
       pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0')/1024/1024/1024 AS wal_gb;

-- 从库延迟
SELECT now() - pg_last_xact_replay_timestamp() AS standby_delay;

7.2 Prometheus Exporter（建议）

postgres_exporter：抓取一般指标
pgbouncer_exporter、pgpool2_exporter（若使用）
告警建议：
standby_delay > 5s/30s/60s 分级；
replication_state != streaming
replication_slot_inactive & WAL 堆积

8. 备份与恢复

8.1 工具选型

pgBackRest（推荐）：全量/增量/差异、并行、校验、保留策略、S3 对接；
pg_basebackup + WAL 归档：适合轻量场景。

8.2 pgBackRest 最小配置示例（片段）

/etc/pgbackrest/pgbackrest.conf

[global]
repo1-path=/var/lib/pgbackrest
repo1-retention-full=7
start-fast=y

[pg]
pg1-path=/var/lib/postgresql/17/data
pg1-port=5432

调度：pgbackrest backup --type=full|diff|incr
恢复：pgbackrest restore --type=time --target='2025-10-08 12:00:00'

9. 逻辑复制（可选：按表级/跨版本）

9.1 主库发布（publication）

CREATE PUBLICATION mypub FOR TABLE public.users, public.orders;

9.2 从库订阅（subscription）

CREATE SUBSCRIPTION mysub
  CONNECTION 'host=10.0.0.10 dbname=app user=repl password=REPLACE_WITH_REPL_PASSWORD'
  PUBLICATION mypub;

适用：选择性同步、跨版本/异构聚合、CDC 下游（Kafka/ETL）。

10. 应用侧改造要点（从 MySQL 迁移）

自增主键：改为 GENERATED BY DEFAULT AS IDENTITY；
UPSERT：INSERT ... ON CONFLICT (key) DO UPDATE；
读写分离：强一致读上主（关键交易/下单等），弱一致读走从；
事务隔离：PostgreSQL 默认 READ COMMITTED，必要时用 REPEATABLE READ；
SQL 差异：LIMIT/OFFSET、BOOLEAN、text/varchar、ILIKE 等；
连接池：强烈建议使用 pgbouncer（transaction 模式）。

11. 交付清单（可直接使用/改造）

数据层：postgresql.conf、pg_hba.conf 基线模板（§3）
初始化：pg_basebackup 命令（§3.4）
验证脚本：pg_stat_replication/延迟检查 SQL（§3.5、§7）
中间层：Pgpool-II 样例（§4.1）或 HAProxy 样例（§4.2）
高可用：Patroni 示例（§5.2）
故障切换：Promote/重拉流程（§6.1）
备份：pgBackRest 样例（§8.2）

12. 风险与最佳实践

WAL 保留不足：务必使用复制槽或足够的 wal_keep_size，防止从库追不上；
读写错路由：关键读务必走主；Pgpool 解析有边界，建议灰度与压测；
长事务：阻塞 VACUUM，导致膨胀与复制延迟；监控 pg_stat_activity；
半同步权衡：开启会增加写延迟；金融交易强一致可 FIRST 1 策略；
备份演练：每季度至少一次异地恢复演练；
版本升级：用 pg_upgrade --check 预检测，读 release notes。

13. 附：Docker Compose（演示用）

仅供演示，生产请改为有状态存储 + 独立网络与安全策略。

version: '3.8'
services:
  primary:
    image: postgres:17
    environment:
      POSTGRES_PASSWORD: REPLACE_WITH_SUPERUSER_PASSWORD
    ports:
      - '5432:5432'
    volumes:
      - primary_data:/var/lib/postgresql/data

  standby1:
    image: postgres:17
    depends_on:
      - primary
    environment:
      POSTGRES_PASSWORD: REPLACE_WITH_SUPERUSER_PASSWORD
    command: >
      bash -lc "pg_basebackup -h primary -U postgres -D /var/lib/postgresql/data -R -P && docker-entrypoint.sh postgres"
    volumes:
      - standby1_data:/var/lib/postgresql/data

volumes:
  primary_data: {}
  standby1_data: {}

结语

本方案覆盖“写主读从”的完整链路：复制 → 连接层 → 高可用 → 备份 → 监控。可按你现网规模裁剪。如需，我可以基于你的主机清单/网段/端口策略，生成一套可直接上线的配置包（含脚本与 Ansible 角色）。

PostgreSQL Docker 部署常见问题与解决方案

Thu, 09 Oct 2025 12:05:00 +0800

汇总在使用 Docker 部署 PostgreSQL（含 PostGIS、pgvector、TimescaleDB）过程中常见的问题及可操作的解决方案，涵盖构建、扩展、连接、权限、性能与数据等方面。

构建问题

Q1: Docker 构建时出现 “lsb_release: command not found”

问题描述：

/bin/sh: 1: lsb_release: command not found
/bin/sh: 1: apt-key: command not found

原因分析：在 Debian/Ubuntu 基础镜像中，lsb_release 和 apt-key 命令可能不存在或已被弃用。

解决方案：改用从源码编译的方式安装 TimescaleDB：

# 不使用包管理器安装，改为源码编译
RUN cd /tmp && \
    git clone https://github.com/timescale/timescaledb.git && \
    cd timescaledb && \
    git checkout 2.13.0 && \
    ./bootstrap && \
    cd build && \
    make && \
    make install

Q2: 编译时出现 “gssapi/gssapi.h: No such file or directory”

问题描述：

fatal error: gssapi/gssapi.h: No such file or directory

原因分析：缺少 GSSAPI 开发库，TimescaleDB 编译需要 Kerberos 相关依赖。

解决方案：在 Dockerfile 中添加必要的依赖包：

RUN apt-get update && apt-get install -y \
    build-essential \
    postgresql-server-dev-15 \
    cmake \
    git \
    wget \
    ca-certificates \
    libkrb5-dev \
    libgssapi-krb5-2 \
    && rm -rf /var/lib/apt/lists/*

扩展问题

Q3: pgvector 出现段错误 (Segmentation Fault)

问题描述：

server closed the connection unexpectedly
This probably means the server terminated abnormally
before or while processing the request.

原因分析：

pgvector 最新版本可能与 PostgreSQL 15 存在兼容性问题
编译环境或依赖版本不匹配

解决方案：使用稳定的预编译版本：

# 使用 pgvector 0.5.1 版本，避免段错误
RUN cd /tmp && \
    wget https://github.com/pgvector/pgvector/archive/v0.5.1.tar.gz && \
    tar -xzf v0.5.1.tar.gz && \
    cd pgvector-0.5.1 && \
    make && \
    make install

Q4: TimescaleDB 扩展创建失败

问题描述：

ERROR: could not load library "timescaledb":
shared_preload_libraries not configured

原因分析：TimescaleDB 需要在 PostgreSQL 启动时预加载。

解决方案：在 Dockerfile 中配置预加载库：

RUN echo "shared_preload_libraries = 'timescaledb'" >> /usr/share/postgresql/postgresql.conf.sample

Q5: PostGIS 扩展版本不匹配

问题描述：

ERROR: extension "postgis" has no installation candidate

原因分析：PostgreSQL 版本与 PostGIS 包版本不匹配。

解决方案：明确指定对应版本的包：

RUN apt-get install -y \
    postgresql-15-postgis-3 \
    postgresql-15-postgis-3-scripts

连接问题

Q6: IDE 连接提示 “Connection refused”

问题描述：

connection to server at "localhost" (::1), port 5432 failed: Connection refused

原因分析：

端口映射不正确
服务未完全启动
防火墙阻止连接

解决方案：

检查端口映射：

docker port postgres-all-extensions
# 应该显示: 5432/tcp -> 0.0.0.0:5432

确认服务状态：

docker ps
# 检查容器是否正常运行

等待服务完全启动：

docker logs postgres-all-extensions
# 查看启动日志，确认数据库已就绪

Q7: 密码认证失败

问题描述：

FATAL: password authentication failed for user "postgres"

原因分析：

数据目录已存在，使用了旧密码初始化
环境变量未正确加载
pg_hba.conf 配置问题

解决方案：

清理旧数据重新初始化：

docker-compose down
sudo rm -rf ./data/pgdata/*
docker-compose up -d

检查环境变量：

docker exec postgres-all-extensions env | grep POSTGRES

验证 .env 文件格式：

# 确保 .env 文件在正确位置且格式正确
POSTGRES_PASSWORD=your_password

权限问题

Q8: 数据目录权限错误

问题描述：

initdb: error: could not create directory "/var/lib/postgresql/data": Permission denied

原因分析：宿主机目录权限不正确，PostgreSQL 容器无法写入。

解决方案：

# 修改目录权限
sudo chown -R 999:999 ./data/pgdata
# 或者删除目录让 Docker 自动创建
sudo rm -rf ./data/pgdata

Q9: 配置文件权限问题

问题描述：容器启动时无法读取配置文件。

解决方案：

# 确保配置文件可读
chmod 644 config/postgresql.conf
chmod 644 config/pg_hba.conf

性能问题

Q10: 容器启动缓慢

问题描述：Docker 容器启动时间过长。

原因分析：

数据库初始化需要时间
扩展安装和配置耗时
系统资源不足

解决方案：

增加启动等待时间：

# 等待更长时间再进行连接测试
sleep 15 && docker exec postgres-all-extensions psql -U postgres -c "SELECT 1;"

优化 Docker 资源分配：

# 在 docker-compose.yml 中添加资源限制
deploy:
  resources:
    limits:
      memory: 2G
    reservations:
      memory: 1G

Q11: 查询性能差

问题描述：数据库查询响应缓慢。

解决方案：

调整 PostgreSQL 配置：

-- 增加共享缓冲区
ALTER SYSTEM SET shared_buffers = '256MB';
-- 调整工作内存
ALTER SYSTEM SET work_mem = '4MB';
-- 重载配置
SELECT pg_reload_conf();

创建适当的索引：

-- 为向量查询创建索引
CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops);
-- 为时序数据创建索引
CREATE INDEX ON sensor_data (time DESC);

数据问题

Q12: 数据持久化失败

问题描述：容器重启后数据丢失。

原因分析：

卷映射配置错误
数据目录路径不正确

解决方案：确认 docker-compose.yml 中的卷配置：

volumes:
  - ./data/pgdata:/var/lib/postgresql/data

Q13: 数据库版本不兼容

问题描述：

FATAL: database files are incompatible with server

原因分析：数据目录由不同版本的 PostgreSQL 创建。

解决方案：

备份数据：

docker exec postgres-old pg_dumpall -U postgres > backup.sql

sudo rm -rf ./data/pgdata/*

重新启动并恢复：

docker-compose up -d
# 等待启动完成后
docker exec -i postgres-all-extensions psql -U postgres < backup.sql

调试技巧

查看详细日志

# 查看容器日志
docker logs postgres-all-extensions -f

# 查看 PostgreSQL 日志
docker exec postgres-all-extensions tail -f /var/log/postgresql/postgresql.log

进入容器调试

# 进入容器
docker exec -it postgres-all-extensions bash

# 查看进程状态
ps aux | grep postgres

# 检查扩展安装
psql -U postgres -c "\dx"

网络连接测试

# 测试端口连通性
telnet localhost 5432

# 使用 Docker 网络测试
docker run --rm --network host postgres:15 pg_isready -h localhost -p 5432

预防措施

定期备份：建立自动化备份策略
监控日志：定期检查错误日志
版本管理：记录使用的具体版本号
测试环境：在生产部署前充分测试
文档更新：及时更新配置和问题解决方案

获取帮助

如遇到本文未涵盖的问题：

查看官方文档：
PostgreSQL 官方文档
PostGIS 文档
pgvector GitHub

TimescaleDB 文档

社区支持：

PostgreSQL 邮件列表
Stack Overflow

GitHub Issues

日志分析：

详细记录错误信息
提供完整的错误日志
说明环境配置信息

PostgreSQL Docker 部署指南

Thu, 09 Oct 2025 12:00:00 +0800

本指南详细介绍如何使用 Docker 部署一个包含 PostGIS、pgvector 和 TimescaleDB 扩展的 PostgreSQL 15 数据库。该方案解决了扩展兼容性问题，特别是 pgvector 的段错误问题。

项目结构

PgSQL/
├── .env                          # 环境变量配置
├── Dockerfile                    # PostgreSQL 镜像构建文件
├── docker-compose.yml            # Docker Compose 配置
├── README.md                     # 项目说明
├── config/                       # 配置文件目录
│   ├── pg_hba.conf              # 客户端认证配置
│   └── postgresql.conf          # PostgreSQL 主配置
├── data/                        # 数据持久化目录
│   └── pgdata/                  # PostgreSQL 数据目录
├── init-scripts/                # 初始化脚本
│   └── 01-install-extensions.sql # 扩展安装脚本
├── logs/                        # 日志目录
└── test-examples.sql            # 测试示例

快速开始

1. 环境准备

确保系统已安装：

Docker
Docker Compose

2. 克隆或创建项目目录

mkdir -p ~/Server/PgSQL
cd ~/Server/PgSQL

3. 配置环境变量

创建 .env 文件：

# PostgreSQL 数据库配置
POSTGRES_DB=devdb
POSTGRES_USER=postgres
POSTGRES_PASSWORD=your_secure_password
POSTGRES_PORT=5432

# 注意：请修改 POSTGRES_PASSWORD 为您的实际密码
# 建议使用强密码，包含大小写字母、数字和特殊字符

4. 构建镜像

docker build -t postgres-all-extensions:latest .

5. 启动服务

docker-compose up -d

6. 验证安装

# 检查容器状态
docker ps

# 连接数据库验证扩展
docker exec postgres-all-extensions psql -U postgres -d devdb -c "SELECT extname, extversion FROM pg_extension WHERE extname IN ('timescaledb', 'postgis', 'vector') ORDER BY extname;"

详细配置说明

Dockerfile 解析

FROM postgres:15

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    build-essential \
    postgresql-server-dev-15 \
    cmake \
    git \
    wget \
    ca-certificates \
    postgresql-15-postgis-3 \
    postgresql-15-postgis-3-scripts \
    libkrb5-dev \
    libgssapi-krb5-2 \
    && rm -rf /var/lib/apt/lists/*

# 安装 pgvector (预编译版本，避免段错误)
RUN cd /tmp && \
    wget https://github.com/pgvector/pgvector/archive/v0.5.1.tar.gz && \
    tar -xzf v0.5.1.tar.gz && \
    cd pgvector-0.5.1 && \
    make && \
    make install

# 安装 TimescaleDB (从源码编译)
RUN cd /tmp && \
    git clone https://github.com/timescale/timescaledb.git && \
    cd timescaledb && \
    git checkout 2.13.0 && \
    ./bootstrap && \
    cd build && \
    make && \
    make install

# 配置 PostgreSQL
RUN echo "shared_preload_libraries = 'timescaledb'" >> /usr/share/postgresql/postgresql.conf.sample

# 复制初始化脚本
COPY init-scripts/ /docker-entrypoint-initdb.d/

EXPOSE 5432

Docker Compose 配置

version: '3.8'

services:
  postgres-all-extensions:
    image: postgres-all-extensions:latest
    container_name: postgres-all-extensions
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    ports:
      - "5432:5432"
    volumes:
      - ./data/pgdata:/var/lib/postgresql/data
      - ./config/postgresql.conf:/etc/postgresql/postgresql.conf
      - ./config/pg_hba.conf:/etc/postgresql/pg_hba.conf
      - ./logs:/var/log/postgresql
    networks:
      - postgres-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 30s
      timeout: 10s
      retries: 3

networks:
  postgres-network:
    driver: bridge

扩展功能测试

PostGIS 测试

-- 创建几何数据
SELECT ST_AsText(ST_MakePoint(-71.064544, 42.28787));

-- 空间查询示例
CREATE TABLE locations (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    geom GEOMETRY(POINT, 4326)
);

INSERT INTO locations (name, geom) VALUES
('Boston', ST_SetSRID(ST_MakePoint(-71.0589, 42.3601), 4326));

pgvector 测试

-- 创建向量表
CREATE TABLE items (
    id SERIAL PRIMARY KEY,
    embedding VECTOR(3)
);

-- 插入向量数据
INSERT INTO items (embedding) VALUES
('[1,2,3]'),
('[4,5,6]');

-- 向量相似度查询
SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

TimescaleDB 测试

-- 创建时序表
CREATE TABLE sensor_data (
    time TIMESTAMPTZ NOT NULL,
    sensor_id INTEGER,
    temperature DOUBLE PRECISION,
    humidity DOUBLE PRECISION
);

-- 转换为超表
SELECT create_hypertable('sensor_data', 'time');

-- 插入时序数据
INSERT INTO sensor_data VALUES
(NOW(), 1, 23.5, 65.2),
(NOW() - INTERVAL '1 hour', 1, 22.8, 64.1);

连接配置

IDE 连接参数

Host: localhost
Port: 5432
Database: devdb (或 postgres)
Username: postgres
Password: [您在.env中设置的密码]

命令行连接

# 使用 Docker 容器内的 psql
docker exec -it postgres-all-extensions psql -U postgres -d devdb

# 使用外部 psql (需要安装 PostgreSQL 客户端)
PGPASSWORD=your_password psql -h localhost -p 5432 -U postgres -d devdb

管理命令

启动/停止服务

# 启动服务
docker-compose up -d

# 停止服务
docker-compose down

# 重启服务
docker-compose restart

# 查看日志
docker-compose logs -f

数据备份与恢复

# 备份数据库
docker exec postgres-all-extensions pg_dump -U postgres devdb > backup.sql

# 恢复数据库
docker exec -i postgres-all-extensions psql -U postgres devdb < backup.sql

性能监控

# 查看容器资源使用
docker stats postgres-all-extensions

# 查看数据库连接
docker exec postgres-all-extensions psql -U postgres -c "SELECT * FROM pg_stat_activity;"

安全建议

修改默认密码：确保在 .env 文件中设置强密码
网络安全：生产环境中限制 pg_hba.conf 的访问范围
数据加密：考虑启用 SSL/TLS 连接
定期备份：建立自动化备份策略
更新维护：定期更新 PostgreSQL 和扩展版本

版本信息

PostgreSQL: 15.14
PostGIS: 3.6.0
pgvector: 0.5.1
TimescaleDB: 2.13.0

许可证

本项目遵循 MIT 许可证。各个扩展遵循其各自的许可证条款。

WordPress 密码重置指南

Mon, 08 Sep 2025 13:00:00 +0800

🔑 方法1：通过数据库直接重置（最快）

如果您有数据库访问权限，这是最快的方法：

# 进入MySQL容器
docker exec mysql_server mysql -u wordpress_user -p你的密码

# 在MySQL中执行以下命令
USE wordpress_db;

# 查看所有用户
SELECT ID, user_login, user_email FROM wp_users;

# 重置指定用户密码（这里以用户名 heyaohua 为例）
UPDATE wp_users SET user_pass = MD5('新密码') WHERE user_login = 'heyaohua';

# 或者使用更安全的WordPress密码哈希
UPDATE wp_users SET user_pass = '$P$B7TBaFiTTExKUX8aWA.HyNEHKvZQ5P0' WHERE user_login = 'heyaohua';
# 上面的哈希对应密码: REPLACE_WITH_NEW_PASSWORD

🔑 方法2：通过WordPress文件重置

在WordPress根目录创建重置脚本：

php
// 创建文件: reset_password.php
require_once('wp-config.php');
require_once('wp-includes/wp-db.php');

$user_login = 'heyaohua';  // 替换为您的用户名
$new_password = 'REPLACE_WITH_NEW_PASSWORD';  // 替换为新密码

$user = get_user_by('login', $user_login);
if ($user) {
    wp_set_password($new_password, $user->ID);
    echo "密码重置成功！用户: $user_login, 新密码: $new_password";
} else {
    echo "用户不存在！";
}
?>

使用方法：

# 在WordPress容器中创建文件
docker exec wordpress_app bash -c "cat > /var/www/html/reset_password.php << 'EOF'
require_once('wp-config.php');
require_once('wp-includes/wp-db.php');
\$user_login = 'heyaohua';
\$new_password = 'REPLACE_WITH_NEW_PASSWORD';
\$user = get_user_by('login', \$user_login);
if (\$user) {
    wp_set_password(\$new_password, \$user->ID);
    echo '密码重置成功！用户: ' . \$user_login . ', 新密码: ' . \$new_password;
} else {
    echo '用户不存在！';
}
EOF"

# 通过浏览器访问执行
# http://localhost:8080/reset_password.php

# 执行完成后删除文件（重要！）
docker exec wordpress_app rm /var/www/html/reset_password.php

🔑 方法3：通过functions.php临时添加管理员

在当前主题的 functions.php 文件末尾添加：

function add_temp_admin(){
    $user = 'temp_admin';
    $pass = 'REPLACE_WITH_TEMP_PASSWORD';
    $email = 'temp@example.com';
    if (username_exists($user) == null && email_exists($email) == false) {
        $user_id = wp_create_user($user, $pass, $email);
        $user = new WP_User($user_id);
        $user->set_role('administrator');
    }
}
add_action('init','add_temp_admin');

执行方法：

# 编辑当前主题的functions.php
docker exec wordpress_app bash -c "echo "
function add_temp_admin(){
    \\\$user = 'temp_admin';
    \\\$pass = 'tempREPLACE_WITH_NEW_PASSWORD';
    \\\$email = 'temp@example.com';
    if (username_exists(\\\$user) == null && email_exists(\\\$email) == false) {
        \\\$user_id = wp_create_user(\\\$user, \\\$pass, \\\$email);
        \\\$user = new WP_User(\\\$user_id);
        \\\$user->set_role('administrator');
    }
}
add_action('init','add_temp_admin');" >> /var/www/html/wp-content/themes/twentytwentyfour/functions.php"

# 访问网站前台任意页面触发函数执行
# 然后用 temp_admin / tempREPLACE_WITH_NEW_PASSWORD 登录后台

# 登录后立即删除这段代码！

🔑 方法4：通过邮箱重置（需要邮件配置）

如果WordPress配置了邮件发送功能：

访问 http://localhost:8080/wp-login.php
点击"忘记密码？"
输入用户名或邮箱
检查邮箱中的重置链接

🔑 方法5：通过WP-CLI（推荐给开发者）

如果容器中安装了WP-CLI：

# 安装WP-CLI（如果没有）
docker exec wordpress_app bash -c "
curl -O https://raw.githubusercontent.com/wp-cli/wp-cli/v2.8.1/bin/wp-cli.phar
chmod +x wp-cli.phar
mv wp-cli.phar /usr/local/bin/wp
"

# 重置密码
docker exec wordpress_app wp user update heyaohua --user_pass=REPLACE_WITH_NEW_PASSWORD --path=/var/www/html --allow-root

# 列出所有用户
docker exec wordpress_app wp user list --path=/var/www/html --allow-root

🛡️ 安全建议

及时删除重置脚本：使用方法2后务必删除PHP重置文件
更改默认密码：重置后立即登录并更改为强密码
删除临时用户：使用方法3后删除临时管理员账户
使用强密码：包含大小写字母、数字和特殊字符，至少8位

📱 快速重置命令

最简单的数据库重置命令：

# 重置为密码: REPLACE_WITH_NEW_PASSWORD
docker exec mysql_server mysql -u wordpress_user -p你的密码 -e "
USE wordpress_db;
UPDATE wp_users SET user_pass = MD5('REPLACE_WITH_NEW_PASSWORD') WHERE user_login = 'heyaohua';
"

# 重置为密码: REPLACE_WITH_NEW_PASSWORD
docker exec mysql_server mysql -u wordpress_user -p你的密码 -e "
USE wordpress_db;
UPDATE wp_users SET user_pass = MD5('REPLACE_WITH_NEW_PASSWORD') WHERE user_login = 'heyaohua';
"

⚠️ 注意事项

备份数据：重置前建议备份数据库
检查用户名：确认用户名正确（区分大小写）
清除缓存：重置后可能需要清除浏览器缓存
安全性：生产环境中请使用更安全的密码哈希方法

🔧 高级密码哈希

WordPress密码哈希生成

php
// 生成WordPress兼容的密码哈希
require_once('wp-includes/class-phpass.php');
$wp_hasher = new PasswordHash(8, true);
$password_hash = $wp_hasher->HashPassword('your_new_password');
echo $password_hash;
?>

在线密码哈希工具

如果您需要生成WordPress兼容的密码哈希：

访问 WordPress密码哈希生成器
输入新密码
复制生成的哈希值
在数据库中更新 user_pass 字段

🚨 紧急情况处理

完全锁定时的处理方法

如果所有管理员账户都无法访问：

# 1. 创建新的管理员用户
docker exec mysql_server mysql -u wordpress_user -p你的密码 -e "
USE wordpress_db;
INSERT INTO wp_users (user_login, user_pass, user_nicename, user_email, user_status)
VALUES ('emergency_admin', MD5('emergency123'), 'emergency_admin', 'emergency@example.com', 0);
"

# 2. 获取新用户的ID
docker exec mysql_server mysql -u wordpress_user -p你的密码 -e "
USE wordpress_db;
SELECT ID FROM wp_users WHERE user_login = 'emergency_admin';
"

# 3. 设置管理员权限（假设用户ID为5）
docker exec mysql_server mysql -u wordpress_user -p你的密码 -e "
USE wordpress_db;
INSERT INTO wp_usermeta (user_id, meta_key, meta_value)
VALUES (5, 'wp_capabilities', 'a:1:{s:13:\"administrator\";b:1;}');
INSERT INTO wp_usermeta (user_id, meta_key, meta_value)
VALUES (5, 'wp_user_level', '10');
"

📊 密码安全最佳实践

强密码要求

长度：至少12个字符
复杂性：包含大小写字母、数字、特殊字符
唯一性：不要重复使用其他账户的密码
定期更换：建议每3-6个月更换一次

MySQL与PostgreSQL全面对比与压测方案

Sun, 15 Dec 2024 10:00:00 +0800

一、MySQL与PostgreSQL对比分析

背景与概述

MySQL长期因轻量和高性能占市场主导，PostgreSQL凭借先进特性和稳定性近年快速崛起，尤其在云原生和复杂业务需求场景中表现出色。

核心技术对比

特性	MySQL	PostgreSQL
数据一致性	MVCC，读已提交隔离，异步复制	完备MVCC，默认可重复读，逻辑/流复制
SQL标准兼容与扩展	支持有限，扩展围绕存储引擎	几乎完整支持SQL标准，支持丰富扩展
性能优化	读写分离，高并发读优势	并行查询，分区表，分布式支持日益完善

PostgreSQL使用度超MySQL原因

业务需求提升，复杂事务、分析需求增多
社区活跃，插件和扩展丰富
云服务快速支持，官方生态发展强劲
大型企业和专业领域采用增多

未来前景

数据库	优势场景	未来发展方向
MySQL	简单高并发读写，Web应用	高可用分布式，云原生集成
PostgreSQL	复杂事务，BI报表，地理空间	原生分布式，多模扩展，SQL标准领先

二、Python数据库操作用例

原生驱动

MySQL (PyMySQL)

import pymysql

conn = pymysql.connect(host='localhost', user='user', password='password', database='testdb')
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100), email VARCHAR(100) UNIQUE)")
cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s)", ('Alice', 'alice@example.com'))
conn.commit()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()

PostgreSQL (psycopg2)

import psycopg2

conn = psycopg2.connect(host='localhost', user='user', password='password', dbname='testdb')
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT, email TEXT UNIQUE)")
cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s)", ('Bob', 'bob@example.com'))
conn.commit()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()

ORM 示例：SQLAlchemy

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    email = Column(String(100), unique=True)

DATABASE_URL = 'postgresql+psycopg2://user:password@localhost:5432/testdb'

engine = create_engine(DATABASE_URL)
Session = sessionmaker(bind=engine)
session = Session()

Base.metadata.create_all(engine)

new_user = User(name='Carol', email='carol@example.com')
session.add(new_user)
session.commit()

users = session.query(User).all()
for u in users:
    print(u.id, u.name, u.email)

session.close()

三、数据库压测方案

压测总体流程

环境准备：部署数据库和测试客户端
场景设计：包含OLTP、高并发读写、复杂查询等
基线测试：默认配置性能测量
参数调优：调整配置重复测试
结果分析：整理吞吐、延迟和资源利用数据
自动化脚本：支持快速复用

主要压测工具与命令示例

Sysbench（MySQL）

sysbench oltp_read_write \
  --db-driver=mysql \
  --mysql-host=DB_HOST \
  --mysql-user=testuser \
  --mysql-password=secret \
  --mysql-db=testdb \
  --tables=10 \
  --table-size=1000000 \
  prepare

sysbench oltp_read_write --threads=100 --time=300 run

sysbench oltp_read_write cleanup

pgbench（PostgreSQL）

pgbench -h DB_HOST -U testuser -d testdb -i -s 1000

pgbench -h DB_HOST -U testuser -d testdb -c 100 -T 300 -j 4

自定义Python异步压测示例

import asyncio
import aiomysql

DB_CONFIG = dict(host='DB_HOST', user='testuser', password='secret', db='testdb', minsize=10, maxsize=100)

async def task(pool):
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            await cur.execute("SELECT COUNT(*) FROM orders WHERE status='pending'")
            await cur.fetchone()
            await cur.execute("UPDATE users SET last_login=NOW() WHERE id=%s", (1,))

async def run_load(concurrency, duration):
    pool = await aiomysql.create_pool(**DB_CONFIG)
    end_time = asyncio.get_event_loop().time() + duration
    sem = asyncio.Semaphore(concurrency)

    async def worker():
        async with sem:
            while asyncio.get_event_loop().time() < end_time:
                await task(pool)

    await asyncio.gather(*[worker() for _ in range(concurrency)])
    pool.close()
    await pool.wait_closed()

asyncio.run(run_load(concurrency=50, duration=300))

四、一体化压测脚本模板

#!/bin/bash
DB_TYPE=${1:-mysql}
DB_HOST="127.0.0.1"
DB_PORT_MYSQL=3306
DB_PORT_PG=5432
DB_USER="testuser"
DB_PASS="secret"
DB_NAME="testdb"
CONCURRENCY=(10 50 100)
DURATION=120
SCALE=100

function bench_mysql() {
    sysbench oltp_read_write \
        --threads=$1 \
        --time=$DURATION \
        --db-driver=mysql \
        --mysql-host=$DB_HOST \
        --mysql-port=$DB_PORT_MYSQL \
        --mysql-user=$DB_USER \
        --mysql-password=$DB_PASS \
        --mysql-db=$DB_NAME run | tee mysql_${1}c.log
}

function bench_pgsql() {
    pgbench -h $DB_HOST -p $DB_PORT_PG -U $DB_USER -d $DB_NAME -c $1 -T $DURATION -j $(nproc) | tee pg_${1}c.log
}

if [[ $DB_TYPE == "pgsql" ]]; then
    pgbench -h $DB_HOST -p $DB_PORT_PG -U $DB_USER -d $DB_NAME -i -s $SCALE
fi

for c in "${CONCURRENCY[@]}"; do
    if [[ $DB_TYPE == "mysql" ]]; then
        bench_mysql $c
    else
        bench_pgsql $c
    fi
done

echo "压测完成，查看 *_c.log 文件"

五、压测结果分析与扩展建议

提取日志中的TPS、延迟等数据，生成CSV
使用图表工具（Excel，Grafana，Matplotlib）绘制性能曲线
根据业务需求调整读写比、复杂查询和分布式架构测试
可集成监控系统，实现实时资源指标采样

以上内容系统梳理了MySQL与PostgreSQL的技术对比，Python数据库操作示例，以及一整套可执行的数据库压测方案与脚本，便于用户快速搭建测试环境，评估性能，指导优化与选型。

Redis Docker开发环境配置指南

Tue, 19 Mar 2024 12:00:00 +0800

Redis Docker开发环境配置指南

本文档详细介绍如何使用Docker搭建Redis开发环境，包括环境配置、启动方式、维护方法等内容。

目录结构

Redis_Docker/
├── .env                # 环境变量配置文件
├── README.md          # 项目说明文档
├── config/            # 配置文件目录
│   └── redis.conf    # Redis配置文件
├── data/             # 数据存储目录
└── logs/             # 日志文件目录

配置文件说明

1. docker-compose.yml

version: '3.8'

services:
  redis:
    container_name: redis-server
    image: redis:7.2
    ports:
      - "${REDIS_PORT}:6379"
    volumes:
      - ./data:/data
      - ./logs:/var/log/redis
      - ./config/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    environment:
      - TZ=Asia/Shanghai
    networks:
      - redis-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 5s

networks:
  redis-network:
    driver: bridge

2. .env 环境变量配置

# Redis 配置环境变量
REDIS_PORT=6379           # Redis端口映射
REDIS_PASSWORD=your_password  # Redis访问密码

3. redis.conf 主要配置

# 网络设置
bind 0.0.0.0
port 6379
protected-mode yes
tcp-keepalive 300

# 基本设置
databases 16
loglevel notice
logfile "/var/log/redis/redis.log"

# 内存设置
maxmemory 256mb
maxmemory-policy allkeys-lru
maxmemory-samples 5

# 持久化设置
save 900 1      # 900秒内至少1个键被修改
save 300 10     # 300秒内至少10个键被修改
save 60 10000   # 60秒内至少10000个键被修改

# AOF设置
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec

使用说明

1. 启动服务

# 启动服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs redis

2. 连接Redis

# 使用容器内的redis-cli
docker-compose exec redis redis-cli -a your_password

# 使用主机的redis-cli（如果已安装）
redis-cli -h localhost -p 6379 -a your_password

# 测试连接
redis-cli -h localhost -p 6379 -a your_password ping

3. 停止服务

# 停止服务
docker-compose down

数据持久化

Redis配置了双重持久化机制：

1. RDB持久化

文件位置：data/dump.rdb
自动保存策略：
900秒内至少1个键被修改
300秒内至少10个键被修改
60秒内至少10000个键被修改

2. AOF持久化

文件位置：data/appendonly.aof
同步策略：everysec（每秒同步）
重写策略：auto-aof-rewrite-percentage 100

性能优化

1. 内存配置

maxmemory：设置为256MB
maxmemory-policy：使用allkeys-lru策略
maxmemory-samples：设置为5

2. 网络优化

tcp-keepalive：300秒
tcp-backlog：511

3. 持久化优化

appendfsync：everysec
no-appendfsync-on-rewrite：no

安全配置

1. 网络安全

protected-mode：启用
bind：0.0.0.0（允许所有IP访问）
requirepass：设置访问密码

2. 客户端限制

maxclients：10000
timeout：0（不自动断开空闲连接）

监控和维护

1. 性能监控

# 查看服务器信息
redis-cli -a your_password INFO

# 监控命令执行
redis-cli -a your_password MONITOR

# 查看慢查询日志
redis-cli -a your_password SLOWLOG GET

2. 内存分析

# 查看内存使用情况
redis-cli -a your_password INFO memory

# 查看大键
redis-cli -a your_password --bigkeys

3. 数据备份

# 手动触发RDB备份
redis-cli -a your_password SAVE

# 异步触发RDB备份
redis-cli -a your_password BGSAVE

常见问题处理

1. 连接失败

检查密码是否正确
确认端口映射是否正确
验证Redis服务是否正常运行

2. 内存问题

检查maxmemory设置
查看内存使用情况
考虑调整内存策略

3. 持久化问题

检查磁盘空间
查看AOF/RDB文件状态
确认写入权限

最佳实践

1. 安全建议

使用强密码
限制可访问的IP
定期更新Redis版本

2. 性能建议

合理设置内存上限
选择适当的持久化策略
监控慢查询

3. 运维建议

定期备份数据
监控系统资源
保持日志分析

PostgreSQL Docker开发环境配置指南

Tue, 19 Mar 2024 11:30:00 +0800

PostgreSQL Docker开发环境配置指南

本文档详细介绍如何使用Docker搭建PostgreSQL开发环境，包括环境配置、启动方式、维护方法等内容。

目录结构

PgSQL_Docker/
├── .env                  # 环境变量配置文件
├── README.md            # 项目说明文档
├── config/              # 配置文件目录
│   ├── pg_hba.conf     # 访问控制配置
│   └── postgresql.conf  # PostgreSQL主配置文件
├── data/               # 数据存储目录
└── logs/               # 日志文件目录

配置文件说明

1. docker-compose.yml

version: '3.8'

services:
  postgres:
    container_name: postgres-server
    image: postgres:15
    environment:
      - POSTGRES_DB=${POSTGRES_DB}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    ports:
      - "${POSTGRES_PORT}:5432"
    volumes:
      - ./data:/var/lib/postgresql/data
      - ./logs:/var/log/postgresql
      - ./config/postgresql.conf:/etc/postgresql/postgresql.conf
      - ./config/pg_hba.conf:/etc/postgresql/pg_hba.conf
    command: postgres -c 'config_file=/etc/postgresql/postgresql.conf'
    networks:
      - postgres-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s

networks:
  postgres-network:
    driver: bridge

2. .env 环境变量配置

# PostgreSQL 配置环境变量
POSTGRES_DB=test_db           # 数据库名称
POSTGRES_USER=data           # 默认超级用户
POSTGRES_PASSWORD=your_password  # 用户密码
POSTGRES_PORT=5432          # 端口映射

3. postgresql.conf 主要配置

# 连接设置
listen_addresses = '*'
port = 5432
max_connections = 100

# 内存设置
shared_buffers = 128MB
work_mem = 4MB
maintenance_work_mem = 64MB
effective_cache_size = 512MB

# 写入设置
wal_level = replica
max_wal_size = 1GB
min_wal_size = 80MB

# 日志设置
log_destination = 'stderr'
logging_collector = on
log_directory = '/var/log/postgresql'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_rotation_age = 1d
log_rotation_size = 10MB

# 区域设置
datestyle = 'iso, mdy'
timezone = 'UTC'
lc_messages = 'en_US.utf8'

4. pg_hba.conf 访问控制配置

# TYPE  DATABASE        USER            ADDRESS                 METHOD
local   all            all                                     trust
host    all            all             127.0.0.1/32           scram-sha-256
host    all            all             ::1/128                scram-sha-256
host    all            all             0.0.0.0/0              scram-sha-256

使用说明

1. 启动服务

# 启动服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs postgres

2. 连接数据库

# 使用超级用户连接
docker-compose exec postgres psql -U data -d test_db

# 查看用户列表和权限
\du

# 查看数据库列表
\l

# 退出psql
\q

3. 停止服务

# 停止服务
docker-compose down

用户和权限管理

PostgreSQL使用角色（Role）概念来管理用户权限。在我们的配置中：

通过POSTGRES_USER环境变量创建的用户（本例中为"data"）是超级用户，具有所有权限：
Superuser（超级用户权限）
Create role（创建角色权限）
Create DB（创建数据库权限）
Replication（复制权限）

Bypass RLS（绕过行级安全性）

创建新用户示例：

CREATE ROLE username WITH LOGIN PASSWORD 'password';

授予权限示例：

GRANT ALL PRIVILEGES ON DATABASE dbname TO username;

数据备份和恢复

备份数据

# 备份整个数据库
docker-compose exec postgres pg_dump -U data test_db > backup.sql

# 备份特定表
docker-compose exec postgres pg_dump -U data -t table_name test_db > table_backup.sql

恢复数据

# 恢复数据
docker-compose exec -T postgres psql -U data test_db < backup.sql

性能优化建议

内存配置
shared_buffers: 建议设置为系统内存的25%
effective_cache_size: 建议设置为系统内存的50%

work_mem: 根据并发连接数调整

写入性能

wal_buffers: 建议设置为16MB
checkpoint_timeout: 可根据写入压力调整

max_wal_size: 根据磁盘空间调整

连接池

建议使用pgBouncer等连接池管理工具
避免频繁创建新连接

常见问题处理

容器无法启动
检查端口占用：lsof -i :5432
检查配置文件权限

查看错误日志：docker-compose logs postgres

连接失败

确认用户名和密码正确
检查pg_hba.conf配置

验证网络连接

性能问题

检查慢查询日志
使用EXPLAIN分析查询计划
优化索引和查询语句

安全建议

密码安全
使用强密码
定期更换密码

避免在命令行中明文输入密码

网络安全

限制访问IP
使用SSL连接

定期更新PostgreSQL版本

权限控制

遵循最小权限原则
使用角色管理权限
启用行级安全性（RLS）

维护建议

定期维护
执行VACUUM操作
更新统计信息

检查日志文件大小

监控

监控连接数
监控磁盘使用

监控查询性能

备份策略

定期备份
测试恢复流程

MySQL Docker开发环境配置指南

Tue, 19 Mar 2024 11:00:00 +0800

如何使用Docker启动MySQL开发环境

目录结构

MySQL_Docker/
├── docker-compose.yml    # Docker Compose 配置文件
├── .env                 # 环境变量配置
├── config/
│   └── my.cnf          # MySQL 配置文件
├── data/               # MySQL 数据目录 (挂载)
└── logs/               # MySQL 日志目录 (挂载)

配置文件说明

1. docker-compose.yml 配置要点

version: '3.8'
services:
  mysql:
    image: mysql:8.0
    container_name: mysql-server
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-root123}
      MYSQL_DATABASE: ${MYSQL_DATABASE:-testdb}
      MYSQL_USER: ${MYSQL_USER:-testuser}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-testpass}
    ports:
      - "${MYSQL_PORT:-3306}:3306"
    volumes:
      - ./data:/var/lib/mysql
      - ./logs:/var/log/mysql
      - ./config/my.cnf:/etc/mysql/conf.d/my.cnf

重要配置说明：

restart: unless-stopped - 容器异常退出时自动重启
environment - 环境变量配置，支持从.env文件读取
volumes - 数据持久化配置，确保数据安全
ports - 端口映射，允许外部访问

2. MySQL配置文件 (my.cnf) 要点

[mysqld]
# 基本设置
port = 3306
bind-address = 0.0.0.0
default-storage-engine = InnoDB

# 字符集设置（重要）
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

# 连接设置
max_connections = 200
max_connect_errors = 10

# 缓冲区设置
innodb_buffer_pool_size = 256M
innodb_log_file_size = 64M
innodb_log_buffer_size = 16M

# 日志设置
log-error = /var/log/mysql/error.log
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2

配置注意事项：

字符集必须设置为utf8mb4，以支持完整的Unicode字符集
根据服务器内存调整缓冲区大小
开启慢查询日志便于性能优化
MySQL 8.0已不支持查询缓存（query_cache）相关配置

3. 环境变量配置 (.env)

MYSQL_ROOT_PASSWORD=your_root_password
MYSQL_DATABASE=your_database
MYSQL_USER=your_user
MYSQL_PASSWORD=your_password
MYSQL_PORT=3306

安全注意事项：

生产环境必须修改默认密码
.env文件不要提交到版本控制系统
定期更换密码
避免使用弱密码

启动和维护

启动服务

docker-compose up -d

查看服务状态

docker-compose ps

查看日志

# 查看容器日志
docker-compose logs mysql

# 查看错误日志
tail -f logs/error.log

# 查看慢查询日志
tail -f logs/slow.log

停止服务

docker-compose down

常见问题处理

1. 容器无法启动或反复重启

检查数据目录权限
查看错误日志（logs/error.log）
确认配置文件语法正确
验证端口是否被占用

2. 连接失败

确认容器运行状态
检查端口映射
验证用户名密码
检查防火墙设置

3. 性能问题

检查慢查询日志
调整缓冲区大小
优化索引
监控资源使用情况

数据备份建议

1. 使用docker-compose执行备份

docker-compose exec mysql mysqldump -u root -p database_name > backup.sql

2. 自动备份脚本示例

#!/bin/bash
backup_dir="backups"
date_format=$(date +%Y%m%d_%H%M%S)
docker-compose exec -T mysql mysqldump -u root -p database_name > "${backup_dir}/backup_${date_format}.sql"

安全建议

网络安全
限制端口访问
使用专用网络

启用SSL/TLS加密

账户安全

定期更换密码
限制用户权限

删除未使用的账户

数据安全

定期备份
加密敏感数据
监控异常访问

性能优化建议

硬件资源
适当分配内存
使用SSD存储

监控CPU使用率

配置优化

调整缓冲池大小
优化日志设置

配置合适的连接数

查询优化

建立合适的索引
优化SQL语句
定期维护统计信息

数据库 on heyaohua's Blog

MySQL→PostgreSQL 主从架构迁移方案（读写分离版）

1. 架构总览

1.1 基础拓扑（最小可用）

1.2 生产级拓扑（推荐）

2. 版本与参数基线

3. 数据层：主从复制配置模板（物理复制）

3.1 主库 postgresql.conf

3.2 主库 pg_hba.conf

3.3 创建复制用户

3.4 从库基线拉起（pg_basebackup）

3.5 启动与验证

3.6 延迟从库（防误删回滚保护，可选）

4. 连接层：读写分离方案

4.1 Pgpool-II（SQL 解析级，自动区分读/写）

核心优点

4.1.1 pgpool.conf 样例（核心片段）

4.1.2 pool_hba.conf

4.1.3 pcp.conf

4.1.4 典型运维脚本占位

4.2 HAProxy + pgbouncer（轻量级）

5. 高可用：Patroni + etcd（推荐）

5.1 部署要点

5.2 Patroni 样例配置（/etc/patroni/pg01.yml）

5.3 与 HAProxy 集成（识别主）

6. 运维脚本与常见操作

6.1 手工主从切换（无 Patroni 场景）

6.2 创建/查看复制槽

6.3 只读事务（强一致读在主库）

7. 监控与告警

7.1 关键视图

7.2 Prometheus Exporter（建议）

8. 备份与恢复

8.1 工具选型

8.2 pgBackRest 最小配置示例（片段）

9. 逻辑复制（可选：按表级/跨版本）

9.1 主库发布（publication）

9.2 从库订阅（subscription）

10. 应用侧改造要点（从 MySQL 迁移）

11. 交付清单（可直接使用/改造）

12. 风险与最佳实践

13. 附：Docker Compose（演示用）

结语

PostgreSQL Docker 部署常见问题与解决方案

目录

构建问题

Q1: Docker 构建时出现 “lsb_release: command not found”

Q2: 编译时出现 “gssapi/gssapi.h: No such file or directory”

扩展问题

Q3: pgvector 出现段错误 (Segmentation Fault)

Q4: TimescaleDB 扩展创建失败

Q5: PostGIS 扩展版本不匹配

连接问题

Q6: IDE 连接提示 “Connection refused”

Q7: 密码认证失败

权限问题

Q8: 数据目录权限错误

Q9: 配置文件权限问题

性能问题

Q10: 容器启动缓慢

Q11: 查询性能差

数据问题

Q12: 数据持久化失败

Q13: 数据库版本不兼容

调试技巧

查看详细日志

进入容器调试

网络连接测试

预防措施

获取帮助

PostgreSQL Docker 部署指南

项目结构

快速开始

1. 环境准备

2. 克隆或创建项目目录

3. 配置环境变量

4. 构建镜像

5. 启动服务

6. 验证安装

详细配置说明

3.1 主库 `postgresql.conf`

3.2 主库 `pg_hba.conf`

4.1.1 `pgpool.conf` 样例（核心片段）

4.1.2 `pool_hba.conf`

4.1.3 `pcp.conf`

5.2 Patroni 样例配置（`/etc/patroni/pg01.yml`）