← 返回首页
Docker 在 Linux 虚拟机上运行 MySQL 8.4

Docker 在 Linux 虚拟机上运行 MySQL 8.4

发布于 2026年11月17日 13:06⏱ 22 分钟阅读👁 8

记录一次完整过程:VMware 里的 Linux 虚拟机 → Docker → MySQL 8.4 LTS。

Docker 在 Linux 虚拟机上运行 MySQL 8.4 · 实战学习笔记

记录一次完整过程:VMware 里的 Linux 虚拟机 → Docker → MySQL 8.4 LTS。 中间经历了一次 InnoDB redo log 损坏导致容器无限重启 的事故,本文把它作为排障案例完整复盘。

环境:CentOS/RHEL 系 Linux(VMware 虚拟机)+ Docker 26.1.4 + MySQL 8.4.13 写作目的:以后自己再装一遍、或者遇到同类问题时能直接查。


目录

⚠️ 文中用了 Mermaid 画图。GitHub、Typora、Obsidian、VS Code(装 Markdown Preview Mermaid 插件)都能渲染; 如果你的编辑器不支持,关键图都配了 ASCII 版本,不影响阅读。


0. 环境与版本清单

项目 本次实际值 说明
宿主机 Windows 日常使用的物理机
虚拟化 VMware Workstation 虚拟机网络建议用 NAT 或桥接
虚拟机 OS CentOS/RHEL 系 提示符 [root@localhost ~]#
Docker Engine 26.1.4, build 5650f9b docker --version
MySQL 镜像 mysql:8.4 → 8.4.13 8.4 是 LTS 长期支持版
容器名 mysql --name mysql
数据卷 mysql-data 映射到容器 /var/lib/mysql
内存 1.8G(available 约 480M 起) 小内存机器,参数要调
磁盘 38G 总量,清理后 12G 用 / 27G 可用 df -h
端口 3306(经典协议)、33060(X Protocol)

1. 架构全景:从 Windows 到 mysqld

先建立一张"谁在哪一层"的地图,后面所有命令都能挂到这张图上。

graph TD
    A["Windows 宿主机<br/>物理机"] -->|"VMware Workstation"| B["Linux 虚拟机<br/>CentOS/RHEL"]
    B --> C["Docker Engine 26.1.4<br/>dockerd + containerd"]
    C --> D["容器 mysql<br/>MySQL 8.4.13 进程"]
    D --> E["命名卷 mysql-data<br/>挂到 /var/lib/mysql"]
    D --> F["端口映射<br/>3306:3306 / 33060:33060"]
    F --> G["宿主机 127.0.0.1:3306"]
    F --> H["局域网 / 其他机器"]

ASCII 版本:

┌─────────────────────────────────────────────────────────┐
│ Windows 宿主机                                           │
│  ┌───────────────────────────────────────────────────┐  │
│  │ VMware → Linux 虚拟机                              │  │
│  │  ┌─────────────────────────────────────────────┐  │  │
│  │  │ Docker Engine                               │  │  │
│  │  │  ┌───────────────────────────────────────┐  │  │  │
│  │  │  │ 容器 mysql(MySQL 8.4.13)             │  │  │  │
│  │  │  │  mysqld : 3306 / mysqlx : 33060        │  │  │  │
│  │  │  └───────────────┬───────────────────────┘  │  │  │
│  │  │                  │ 挂载                    │  │  │
│  │  │        ┌─────────▼──────────┐              │  │  │
│  │  │        │ 卷 mysql-data       │              │  │  │
│  │  │        │ /var/lib/mysql      │              │  │  │
│  │  │        └────────────────────┘              │  │  │
│  │  └─────────────────────────────────────────────┘  │  │
│  │        ▲ docker-proxy 转发 3306                    │  │
│  └────────┼───────────────────────────────────────────┘  │
│           │                                              │
│   localhost:3306         192.168.x.x:3306                │
└─────────────────────────────────────────────────────────┘

关键认知:

  1. 容器里的 mysqld 才是数据库进程,虚拟机上没有装 mysqld 本体。这就是后面 mysql -u root -p 会报 ERROR 2002 的根本原因。
  2. 端口映射由 docker-proxy 实现,ss -lntp | grep 3306 看到的是 docker-proxy,不是 mysqld —— 这是正常现象。
  3. 数据不在容器里,在卷里。容器删了数据还在,卷删了数据才真没了。

2. 为什么用 Docker 装 MySQL

维度 裸装(yum/apt) Docker
安装时间 5~15 分钟,依赖一堆 2 分钟,docker run 一条命令
版本管理 升级麻烦,容易和系统包冲突 换 tag 就是换版本,随时回滚
卸载干净度 残留配置、数据目录、用户 docker rm -f + docker volume rm 干净
多版本共存 很难(端口、socket 冲突) 每个容器独立,端口错开即可
迁移 要重新装一遍 docker commit 或导出卷
生产可用性 原生 官方镜像成熟,但要注意卷和资源限制
学习成本 低(但排障靠猜) 中(多一层抽象,排障要看日志)

结论:学习和中小项目,Docker 是明显更优解。生产环境用 Docker 也完全没问题,但必须把数据卷和资源限制做对。


3. 开工前的三分钟体检

装数据库之前,先确认三件事:Docker 在跑、磁盘够、内存够。

3.1 Docker 是否就绪

docker --version
# Docker version 26.1.4, build 5650f9b
 
docker info | head -20
docker ps

docker ps 不报 Cannot connect to the Docker daemon 就说明服务正常。

3.2 磁盘空间

df -h
df -i        # inode 也要看,小文件多会先耗尽 inode

本次结果:38G 总量,用了 18G(47%),inode 只用了 3% —— 磁盘不是瓶颈,但只剩 20G,需要留意。

MySQL 数据目录建议至少留 10G 以上,否则 redo log 都写不下。

3.3 内存

free -h

本次结果:

               total        used        free      shared  buff/cache   available
Mem:           1.8G        ...                                   486M
Swap:          2.0G        ...        334M used

available 只有 486M —— 这是致命信号。 MySQL 8.4 默认 innodb_buffer_pool_size 是 128M,加上连接开销、performance_schema,起步就要 400M~600M,1.8G 的机器还跑着一堆别的容器,必然 OOM 或初始化失败。

💡 教训:装数据库前先看一眼 free -h。这台机器上当时还跑着 opensearch×2、kafka、zookeeper、rabbitmq、prometheus、grafana 等 9 个容器 —— 全是压垮内存的元凶。

3.4 端口是否被占

ss -lntp | grep 3306
# 如果已有输出,说明 3306 被占,要么停掉,要么换端口

4. 镜像怎么选

docker pull mysql:8.4

本次拉到的 digest:sha256:a81d043930e51745522bd5c430961cf8286f0a23f0a9a2a6e0108f7ea71b0902

tag 选择对照

tag 含义 建议
mysql:latest 当前最新版(可能是 9.x) ❌ 不推荐,版本会漂移
mysql:9.4 创新版(Innovation) 新特性多,但生命周期短
mysql:8.4 LTS 长期支持版,支持到 2032 ✅ 推荐
mysql:8.0 上一个 LTS,支持到 2026-04 ⚠️ 还能用,但接近 EOL
mysql:8.0.31 2022 年的具体补丁版 ❌ 本次原有版本,已旧
mysql:5.7 早已 EOL ❌ 别用

LTS vs Innovation(8.4 之后 MySQL 改了发布模型):

  • LTS(8.4、后续的 9.7…):稳定性优先,bug 修复为主,支持周期长
  • Innovation(9.x):新特性,生命周期短,下一个 LTS 出来就停止维护

学习环境用 8.4 LTS 是当前最稳的选择。

关于 mysql:8.4 到底拉到哪个小版本

docker images mysql
# mysql   8.4   a81d043930e5   ...   8.4.13

mysql:8.4 是个"浮动 tag",每次 pull 可能拿到新的补丁版(8.4.13 → 8.4.14…)。生产环境建议钉死到 mysql:8.4.13,避免某次重启后悄悄升级。


5. 启动容器:一条命令的每个参数

本次实际执行的命令(可直接复用):

docker run -d \
  --name mysql \
  --restart unless-stopped \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD='123456' \
  -e TZ=Asia/Shanghai \
  -v mysql-data:/var/lib/mysql \
  --health-cmd='mysqladmin ping -h 127.0.0.1 -uroot -p$MYSQL_ROOT_PASSWORD' \
  --health-interval=30s \
  --health-retries=3 \
  mysql:8.4 \
  --innodb-buffer-pool-size=256M

逐参数拆解

参数 作用 注意点
-d 后台运行(detach) 不加的话会占住终端
--name mysql 容器名,后续 docker exec / docker logs 都用它 名字不能和已有容器重复
--restart unless-stopped 开机/崩溃后自动重启,除非你手动 stop 学习环境强烈建议加
-p 3306:3306 宿主机 3306 → 容器 3306 见下方"安全提示"
-e MYSQL_ROOT_PASSWORD 设置 root 密码 只在数据目录为空时生效
-e TZ=Asia/Shanghai 时区,让 NOW() 返回北京时间 不加的话容器里是 UTC,差 8 小时
-v mysql-data:/var/lib/mysql 命名卷,持久化数据 不挂卷 = 容器一删数据全没
--health-cmd 健康检查命令 用 $MYSQL_ROOT_PASSWORD 引用环境变量
--health-interval=30s 每 30 秒检查一次
--health-retries=3 连续失败 3 次标记 unhealthy
mysql:8.4 镜像名:tag 镜像名之后的所有参数都传给 mysqld
--innodb-buffer-pool-size=256M 调小 buffer pool 小内存机器必须调,默认 128M 其实也还行

两个容易忽略的细节

① 镜像名之后是 mysqld 的命令行参数

官方镜像的 entrypoint 是 docker-entrypoint.sh,它会把镜像名后面的内容拼到 mysqld 后面。所以 --innodb-buffer-pool-size=256M 等价于配置文件里写 innodb_buffer_pool_size=256M。

也可以完全用配置文件:

-v ./my.cnf:/etc/mysql/conf.d/my.cnf:ro

② MYSQL_ROOT_PASSWORD 只在"空数据目录"时生效

官方 entrypoint 的逻辑是:检测到 /var/lib/mysql/mysql 目录不存在 → 执行初始化 → 应用这些 MYSQL_* 环境变量。如果数据目录已经有数据,这些环境变量会被忽略。所以"改密码"不能靠改这个变量再重启,必须进容器执行 ALTER USER。

🔒 安全提示:端口发布的两种写法

-p 3306:3306              # 监听 0.0.0.0:3306,局域网都能连
-p 127.0.0.1:3306:3306    # 只监听本机回环,最安全

学习环境图方便用第一种没问题,但要知道:如果虚拟机是桥接网络,且密码是弱密码,等于把数据库暴露给整个局域网。

本次场景是纯学习 + 密码 123456,属于可接受的风险(用户明确决定不改密码)。真要上生产,务必换成 127.0.0.1 + 强密码 + 专用账号。

验证启动成功

docker ps
# STATUS 里应该显示 (healthy)
 
docker logs mysql | tail -20

成功的日志长这样:

[System] [MY-010116] [Server] mysqld (mysqld 8.4.13) starting as process 1
[System] [MY-013576] [InnoDB] InnoDB initialization has started.
[System] [MY-013577] [InnoDB] InnoDB initialization has ended.
[System] [MY-010931] [Server] ready for connections. Version: '8.4.13'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306
[System] [MY-011323] [Server] X Plugin ready for connections. Bind-address: '::' port: 33060

看到 ready for connections ... port: 3306 就是成功了。


6. 实战复盘:一次 InnoDB redo log 崩溃的完整排障

这是本文最有价值的部分。真实事故、真实报错、真实修复路径。

6.1 事故现象

某天登录虚拟机,发现:

docker ps -a
# b1fb8afa4221   mysql:8.0.31   Restarting (1)   一直在重启

容器状态是 Restarting (1) —— 启动、崩溃、退出码 1、被 --restart 策略拉起、再崩溃,无限循环。

同时 docker ps --filter publish=3306 是空的,说明端口根本没起来。

6.2 排障路径(决策树)

flowchart TD
    S["容器起不来 / 一直 Restarting"] --> A["docker ps -a<br/>看状态和退出码"]
    A --> B["docker logs mysql<br/>看报错"]
    B --> C{"日志关键词"}
    C -->|"MY-012960 redo log"| D["数据目录损坏<br/>→ 抢救或重建"]
    C -->|"MY-010334 DD Engine"| D
    C -->|"Access denied"| E["账号 / 密码 / host 问题"]
    C -->|"端口已被占用"| F["换端口或停占用进程"]
    C -->|"日志干净但退出"| G["docker inspect<br/>查 ExitCode 和 OOMKilled"]
    G --> H{"OOMKilled = true ?"}
    H -->|是| I["内存不足<br/>→ 加 swap / 调小参数"]
    H -->|否| J["按 ExitCode 查<br/>1=通用错误 137=被 kill 255=启动失败"]

💡 排障黄金顺序:docker ps -a → docker logs → docker inspect → 系统资源(df -h / free -h)。 不要一上来就 docker restart,日志会被冲掉。

6.3 关键日志

docker logs mysql

核心报错(这几行是本案的病根):

[ERROR] [MY-012960] [InnoDB] Cannot create redo log files because data files
        are corrupt or the database was not shut down cleanly after creating
        the data files.
[ERROR] [MY-010334] [Server] Failed to initialize DD Engine
[ERROR] [MY-010020] [Server] Data Dictionary initialization failed.
[ERROR] [MY-010119] [Server] Aborting

逐行翻译:

错误码 含义
MY-012960 redo log 建不出来——要么数据文件损坏,要么上次创建数据文件后没有干净关闭
MY-010334 数据字典引擎(Data Dictionary Engine)初始化失败
MY-010020 数据字典初始化失败(DD 是 MySQL 8 的元数据中心,它挂了整个服务就起不来)
MY-010119 放弃、退出进程

6.4 为什么会坏?五个常见原因

  1. 非正常关机 —— 虚拟机被强制断电、宿主机休眠、kill -9 掉 mysqld
  2. 磁盘写满 —— 写 redo log 时空间不足,文件残缺
  3. redo log 容量参数被改小 —— 比如把 innodb_redo_log_capacity 从 200M 改成 100M,已有的 32 个 redo 文件对不上
  4. 数据目录跨文件系统拷贝 —— 从别的机器直接 cp -r 过来,没做一致性处理
  5. 容器被 docker kill 或宿主 OOM killer 干掉

本次属于第 1 + 5 类:虚拟机重启前没干净关容器,加上内存严重不足。

6.5 进一步确认(别急着删)

docker inspect mysql --format '{{.State.ExitCode}} OOM={{.State.OOMKilled}}'
# 1 OOM=false        → 不是被 OOM 杀的,是 mysqld 自己退出的
 
docker inspect mysql --format '{{json .Mounts}}' | python3 -m json.tool
# 确认数据卷挂到哪

本次挂载情况:

卷 容器路径 用途
devsoft_mysql-data /var/lib/mysql 数据目录
devsoft_mysql-conf /etc/mysql/conf.d 自定义配置
bind: /etc/localtime /etc/localtime 时区

devsoft_ 前缀是 docker-compose 项目名生成的。首次用 compose 起的,后来用 docker run 起的,前缀不一致会导致"以为在用同一个卷、其实不是"。

6.6 抢救还是重建?决策

flowchart TD
    A["数据重要吗?"] -->|重要| B["先整卷备份<br/>docker run --rm -v VOL:/data -v $PWD:/backup alpine tar czf /backup/v.tgz /data"]
    B --> C["尝试 --innodb-force-recovery=1..6<br/>逐级提高"]
    C --> D{"能起来吗?"}
    D -->|能| E["立刻 mysqldump 导出"]
    D -->|不能| F["移走 #innodb_redo 目录重建<br/>再不行就认命"]
    A -->|不重要| G["直接删卷重建<br/>2 分钟搞定"]
    E --> H["新卷导入"]

本次选择:重建。 用户明确表示"MySQL 的数据不重要,可以直接重来"。

⚠️ 这是最省事的路径,但只有在确认数据可丢时才能走。生产环境绝对不允许。

6.7 抢救方案(数据重要时用)

按代价从小到大排列:

方案 1:调整缓冲区,让它自己恢复

docker run ... mysql:8.4 --innodb-force-recovery=1

1~6 逐级提高。级别越高越能起来,但数据一致性越差。能起来就立刻 mysqldump 导出,别在上面跑业务。

方案 2:移走 redo 目录重建

# 先整卷备份!
docker run --rm -v mysql-data:/data -v $PWD:/backup alpine \
  tar czf /backup/mysql-data-$(date +%F).tar.gz -C /data .
 
# 进容器把 #innodb_redo 挪走
docker run --rm -v mysql-data:/data alpine \
  mv /data/#innodb_redo /data/#innodb_redo.bak

MySQL 8.0.30+ 的 redo log 在 #innodb_redo 目录下,共 32 个文件,默认每个 3.125M。

方案 3:innodb_force_recovery=6 + dump

docker exec mysql mysqldump -uroot -p --all-databases \
  --single-transaction --routines --triggers > all.sql

方案 4:认命重来 —— 本次的选择。

6.8 重建流程(实际执行的)

# 1. 先停掉疯狂重启的容器,释放端口
docker stop mysql
docker update --restart=no mysql    # 防止它又被拉起来
 
# 2. 删除旧容器
docker rm -f mysql
 
# 3. 删除旧数据卷(数据不要了)
docker volume rm devsoft_mysql-data
docker volume rm devsoft_mysql-conf
 
# 4. 重新拉 8.4 镜像并启动(见第 5 节)

⚠️ 本次实际执行时把 devsoft_mysql-data 打成了 devsoft_musql-data(y→u), 结果两条 docker volume rm 各删掉了一个卷——歪打正着。但这是个危险信号: docker volume rm 是不可撤销的,手滑打错可能删错东西。删之前先用 docker volume ls 核对。

6.9 事故总结

环节 教训
预防 --restart unless-stopped 是双刃剑:能自动恢复,也会让坏容器无限重启刷日志
预防 小内存机器要限制 MySQL 内存,别和其他重服务挤在一起
预防 关机前 docker stop mysql,让它干净落盘
诊断 先看 docker logs,再看 docker inspect,最后看系统资源
处置 数据重要 → 先备份再抢救;数据不重要 → 果断重建

7. 资源清理:内存超卖与磁盘回收

7.1 病情:9 个容器挤 1.8G 内存

事故发生时的 docker ps 列表:

容器 状态 说明
mysql (8.0.31) Restarting (1) 崩溃循环
opensearch ×2 Exited (255) 各占 1G+ 内存
opensearch-dashboards Exited
kafka-ui Up
zookeeper Up
kafka Created 从没起来过
rabbitmq Up
prometheus Up
grafana Up
redis Created 从没起来过

这些是之前学习时随手装的,互相之间没有真实业务依赖,全部可以删。

7.2 清理容器

docker stop $(docker ps -q)          # 先全停
docker rm opensearch1 opensearch2 opensearch-dashboards \
          kafka-ui zookeeper kafka rabbitmq prometheus grafana redis
docker ps -a                        # 确认清空

清理后 available 从 480M → 867M,翻了近一倍。

7.3 磁盘回收

docker system df      # 看谁在占空间
docker system df -v   # 更详细,按镜像/容器/卷分别列

本次结果:

TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          22        4         8.041GB   2.799GB (34%)
Containers      0         0         0B        0B
Local Volumes   16        0         174.6MB   174.6MB (100%)
Build Cache     0         0         0B        0B

关键认知:Images 那行 22 个只用了 4 个,2.8GB 是可回收的。

7.4 四个 prune 命令的区别(别用错)

命令 删什么 危险度
docker container prune 所有已停止的容器 低
docker image prune 悬空镜像(<none> tag) 低
docker image prune -a 所有未被容器使用的镜像 ⚠️ 中,会把不用的镜像全删
docker volume prune 所有未被容器使用的卷 🔴 高!数据卷会被删!
docker builder prune 构建缓存 低
docker system prune 停止的容器 + 悬空镜像 + 悬空网络 + 构建缓存 中
docker system prune -a --volumes 上面全部 + 所有未用卷 🔴 极高,慎用

本次操作踩的坑:用户把 docker builder prune 当成了 docker volume prune 的确认输入(看到 y/N 提示就输入了 builder prune),结果 prune 没有执行——反而避免了一次误删。这是典型的"看提示就乱敲"。

💡 铁律:docker volume prune 之前,先 docker volume ls 看一眼里面有没有你要留的卷。 加 -f 不会确认,不会给你后悔的机会。

7.5 本次清理结果

docker image prune -a    # 删掉 18 个没用的镜像
df -h

磁盘从 18G 用 / 20G 可用 → 12G 用 / 27G 可用(31%),回收约 6GB。


8. 数据持久化:卷的设计

8.1 三种挂载方式对比

方式 写法 数据存在哪 适用场景
命名卷(named volume) -v mysql-data:/var/lib/mysql /var/lib/docker/volumes/mysql-data/_data ✅ 数据库首选
绑定挂载(bind mount) -v /opt/mysql:/var/lib/mysql 你自己指定的宿主机目录 需要直接看文件、或用 NFS
匿名卷 -v /var/lib/mysql 随机名字的目录 ❌ 别用,很难追踪

为什么数据库优先用命名卷?

  • Docker 管理生命周期,docker volume ls 能列出来
  • 不依赖宿主机路径,可移植性好
  • 在 macOS/Windows 上有性能优化(虽然 Linux 上区别不大)
  • 避免 SELinux 权限问题(bind mount 常见坑)

8.2 卷放在宿主机哪

docker volume inspect mysql-data
[
  {
    "CreatedAt": "2026-...",
    "Driver": "local",
    "Mountpoint": "/var/lib/docker/volumes/mysql-data/_data",
    "Name": "mysql-data",
    "Scope": "local"
  }
]

⚠️ 不要直接 vim 这个目录里的文件。容器运行中直接改文件 = 数据损坏。备份可以,编辑不行。

8.3 卷的备份与恢复

备份(利用一个临时 alpine 容器,把卷打包):

docker run --rm \
  -v mysql-data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/mysql-data-$(date +%F).tar.gz -C /data .

恢复:

docker run --rm \
  -v mysql-data:/data \
  -v $(pwd):/backup \
  alpine sh -c "rm -rf /data/* && tar xzf /backup/mysql-data-2026-01-01.tar.gz -C /data"

迁移到另一台机器:

# A 机器
docker run --rm -v mysql-data:/data -v $(pwd):/backup alpine \
  tar czf /backup/mysql-data.tar.gz -C /data .
scp mysql-data.tar.gz user@B:/tmp/
 
# B 机器
docker volume create mysql-data
docker run --rm -v mysql-data:/data -v /tmp:/backup alpine \
  tar xzf /backup/mysql-data.tar.gz -C /data

💡 卷备份是"冷备份"(文件级),要求容器已停止,否则可能拷到不一致状态。 逻辑备份(mysqldump)可以热备,见第 13 节。


9. 账号、主机与认证插件

这一节是 MySQL 最容易踩坑的地方,务必看懂。

9.1 账号 = 用户名 + 主机名

MySQL 的账号标识是 'user'@'host' 两部分,同名不同 host 是两个独立账号:

'root'@'localhost'   -- 只能从本机(socket)登录
'root'@'127.0.0.1'   -- 只能从本机回环(TCP)登录
'root'@'%'           -- 从任意主机登录
'root'@'192.168.1.%' -- 只能从 192.168.1.0/24 网段登录
graph TD
    U1["root@localhost<br/>容器内 socket"] --> P1["ALL PRIVILEGES ON *.*"]
    U2["root@%<br/>镜像自动创建"] --> P1
    U3["app@%<br/>手动创建"] --> P2["ALL PRIVILEGES ON appdb.*"]
    P2 --> DB["库 appdb"]
    style U1 fill:#e8f4ff
    style U2 fill:#fff3e0
    style U3 fill:#e8f5e9

9.2 host 的匹配规则

host 值 含义
% 任意主机(不匹配 localhost 的 socket 连接,但匹配 127.0.0.1 的 TCP 连接)
localhost 只匹配 Unix socket 连接(Linux 上)
_ 匹配任意单个字符
192.168.1.% 匹配该网段
空字符串 '' 匹配任意主机(危险,等同于 % 但更隐蔽)

关键点:mysql -h localhost 在 Linux 上会走 Unix socket,而不是 TCP。所以它匹配的是 localhost 这个 host,不是 %。这就是为什么有些人建了 root@'%' 却发现"本机反而连不上"。

9.3 认证插件:从 mysql_native_password 到 caching_sha2_password

这是本次最大的认知更新点。

版本 默认插件 mysql_native_password 状态
5.7 mysql_native_password 默认
8.0 caching_sha2_password 仍可用(需显式指定)
8.0.34+ caching_sha2_password 标记为废弃(deprecated)
8.4 caching_sha2_password 🔴 默认禁用(disabled)
9.0+ caching_sha2_password ❌ 彻底移除(removed)

在 8.4 上执行这条老教程里的命令会直接失败:

CREATE USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
ERROR 1524 (HY000): Plugin 'mysql_native_password' is not loaded

为什么要禁用? mysql_native_password 用的是 SHA1,早就不安全了。caching_sha2_password 用 SHA256 + RSA 密钥交换,安全性高得多。

为什么老教程都写 mysql_native_password? 因为 2019 年前后的客户端(Navicat 12 及更早、JDBC 5.x、老版 PHP mysqlnd)不认 caching_sha2_password,连上去会报:

Authentication plugin 'caching_sha2_password' cannot be loaded

正确解法(按推荐度排序):

  1. ✅ 升级客户端:Navicat 15+、JDBC 8.x、mysql 命令行 8.x
  2. ✅ JDBC 加参数:?useSSL=false&allowPublicKeyRetrieval=true
  3. ⚠️ 真要用旧插件:启动时加参数
    docker run ... mysql:8.4 --mysql-native-password=ON

9.4 这条命令到底在干什么

CREATE USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
片段 作用
CREATE USER 只建账号,不给任何权限
'root' 用户名
@'%' 从任意主机登录
IDENTIFIED WITH mysql_native_password 用旧版认证插件
BY '123456' 密码

三个坑:

  1. 它不授权。建完只有 USAGE(能登录,啥也干不了)。必须再 GRANT。
  2. 已存在会报错:
    ERROR 1396 (HY000): Operation CREATE USER failed for 'root'@'%'
    因为 -e MYSQL_ROOT_PASSWORD 已经自动创建了 root@'%'。改用 ALTER USER。
  3. 全角引号会语法错误:‘%’(U+2018/2019)不是合法 SQL 定界符,会报 ERROR 1064。从网页复制时极易带入,肉眼几乎看不出。

9.5 正确的建号方式

场景 A:给应用建专用账号(推荐)

CREATE USER 'app'@'%' IDENTIFIED BY 'App@2026#Pwd';
GRANT ALL PRIVILEGES ON appdb.* TO 'app'@'%';

不写 IDENTIFIED WITH,让它用默认的 caching_sha2_password。

场景 B:真的需要远程 root(不推荐)

ALTER USER 'root'@'%' IDENTIFIED BY '一个强密码';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;

9.6 关于 FLUSH PRIVILEGES

老教程在 CREATE USER / GRANT 后面总跟一句 FLUSH PRIVILEGES;。

其实不需要。 这两条语句会自动刷新权限缓存。只有在直接改 mysql.user 表(INSERT/UPDATE)时才必须执行。加了不会报错,但属于冗余。


10. 连接 MySQL 的四条路径

flowchart LR
    A["① docker exec -it mysql mysql -uroot -p<br/>容器内 · Unix socket"] --> S["mysqld<br/>:3306"]
    B["② mysql -h 127.0.0.1 -P 3306<br/>宿主机 · TCP"] --> P["docker-proxy<br/>端口映射"] --> S
    C["③ mysql -h 192.168.x.x -P 3306<br/>局域网 · TCP"] --> N["VM 网卡 eth0"] --> P
    D["④ 图形工具 / JDBC / Navicat"] --> N

① 容器内直连(最稳,永远可用)

docker exec -it mysql mysql -uroot -p123456

走的是容器内的 Unix socket /var/run/mysqld/mysqld.sock。任何排障都应该先用这条,它能排除掉网络和端口的一切问题。

② 宿主机 TCP 连接

mysql -h 127.0.0.1 -P 3306 -uroot -p

⚠️ 必须用 -h 127.0.0.1,不能用 -h localhost。

因为 Linux 上 -h localhost 会强制走 Unix socket,而虚拟机上没有本地 mysqld,于是:

ERROR 2002 (HY000): Can't connect to local MySQL server through socket
             '/var/lib/mysql/mysql.sock' (2)

这个错误是本次实际遇到的。不是密码错、不是服务没起,纯粹是客户端走了 socket 而不是 TCP。 注意报错里的路径 /var/lib/mysql/mysql.sock —— 这是宿主机的路径,容器里的 socket 在 /var/run/mysqld/mysqld.sock,两者根本不是一个东西。

③ 局域网远程连接

mysql -h 192.168.1.100 -P 3306 -uapp -p

需要三个条件同时满足:

  1. 账号的 host 允许(% 或对应网段)
  2. 端口发布到了 0.0.0.0(-p 3306:3306 而不是 -p 127.0.0.1:3306:3306)
  3. 防火墙放行 3306

④ 图形化工具

工具 Host Port 备注
Navicat VM IP 3306 15+ 才支持 caching_sha2_password
DBeaver VM IP 3306 免费,推荐
DataGrip VM IP 3306 JetBrains 出品
MySQL Workbench VM IP 3306 官方工具

JDBC URL 写法:

jdbc:mysql://192.168.1.100:3306/appdb?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai&characterEncoding=utf8
  • useSSL=false —— 内网省得配证书
  • allowPublicKeyRetrieval=true —— 配合 caching_sha2_password 必需的
  • serverTimezone=Asia/Shanghai —— 防时间差 8 小时
  • characterEncoding=utf8 —— 防中文乱码

11. 建库与最小权限

11.1 一个必须知道的坑:GRANT 不会建库

GRANT ALL PRIVILEGES ON appdb.* TO 'app'@'%';
-- Query OK, 0 rows affected     ← 看起来成功了

但 SHOW DATABASES 里没有 appdb,只有四个系统库:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

MySQL 允许给不存在的库授权(授权信息存在 mysql.db 表里,不校验库是否存在)。库不存在,账号登录后依然什么都看不到。

必须先建库:

CREATE DATABASE appdb CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;

11.2 字符集怎么选

字符集 说明 建议
utf8 MySQL 的别名,实为 utf8mb3(最多 3 字节) ❌ 不能存 emoji
utf8mb3 3 字节 UTF-8 ❌ 已废弃
utf8mb4 真正的 4 字节 UTF-8 ✅ 唯一正确选择
latin1 西欧字符 ❌
gbk / gb2312 中文老字符集 ❌ 除非对接老系统

排序规则(collation):

  • utf8mb4_0900_ai_ci —— MySQL 8.0+ 默认,推荐(ai = accent insensitive 忽略重音,ci = case insensitive 不区分大小写)
  • utf8mb4_general_ci —— 5.7 时代的老默认,性能略好但排序不准
  • utf8mb4_unicode_ci —— Unicode 标准排序,比 general 准

11.3 最小权限实践

-- 1. 建库
CREATE DATABASE appdb CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
 
-- 2. 建用户
CREATE USER 'app'@'%' IDENTIFIED BY 'App@2026#Pwd';
 
-- 3. 只授这个库
GRANT ALL PRIVILEGES ON appdb.* TO 'app'@'%';
 
-- 4. 验证
SHOW GRANTS FOR 'app'@'%';

期望输出:

GRANT USAGE ON *.* TO `app`@`%`
GRANT ALL PRIVILEGES ON `appdb`.* TO `app`@`%`

第一行的 USAGE ON *.* 只是占位(证明账号存在),真正的权限只在 appdb。

11.4 权限粒度

-- 全局(最危险)
GRANT ALL PRIVILEGES ON *.* TO 'app'@'%';
 
-- 库级(推荐,够用)
GRANT ALL PRIVILEGES ON appdb.* TO 'app'@'%';
 
-- 表级
GRANT SELECT, INSERT, UPDATE ON appdb.orders TO 'app'@'%';
 
-- 列级(极细,很少用)
GRANT SELECT (id, name) ON appdb.users TO 'app'@'%';

生产环境建议:应用账号只给 SELECT, INSERT, UPDATE, DELETE,DROP/ALTER 交给单独的运维账号。

11.5 验收测试

docker exec -it mysql mysql -uapp -p'App@2026#Pwd'
SHOW DATABASES;                          -- 只应看到 appdb + information_schema
USE appdb;
CREATE TABLE t1(id INT PRIMARY KEY, name VARCHAR(20));
INSERT INTO t1 VALUES (1, '测试中文');
SELECT * FROM t1;                        -- 中文不乱码才算过
DROP TABLE t1;
EXIT;

12. 日常运维速查

12.1 容器生命周期

操作 命令
启动 docker start mysql
停止 docker stop mysql
重启 docker restart mysql
查看状态 docker ps / docker ps -a
看日志(实时) docker logs -f mysql
看日志(最近 50 行) docker logs --tail 50 mysql
进容器 bash docker exec -it mysql bash
进 MySQL 命令行 docker exec -it mysql mysql -uroot -p
查看容器详情 docker inspect mysql
看资源占用 docker stats mysql
删除容器 docker rm -f mysql
开机自启开关 docker update --restart=unless-stopped mysql

12.2 MySQL 内部

操作 命令
看版本 SELECT VERSION();
看当前用户 SELECT CURRENT_USER(), USER();
看所有账号 SELECT user, host, plugin FROM mysql.user;
看某账号权限 SHOW GRANTS FOR 'app'@'%';
看所有库 SHOW DATABASES;
看当前库的表 SHOW TABLES;
看表结构 DESC tablename; / SHOW CREATE TABLE tablename\G
看连接数 SHOW STATUS LIKE 'Threads_connected';
看最大连接 SHOW VARIABLES LIKE 'max_connections';
看运行中的 SQL SHOW PROCESSLIST;
看 buffer pool SHOW VARIABLES LIKE 'innodb_buffer_pool_size';
看字符集 SHOW VARIABLES LIKE 'character_set%';
杀连接 KILL <id>;
看引擎状态 SHOW ENGINE INNODB STATUS\G

12.3 改密码

-- 8.0+ / 8.4 正确写法
ALTER USER 'root'@'%' IDENTIFIED BY '新密码';
FLUSH PRIVILEGES;
 
-- 或者用官方工具
docker exec -it mysql mysqladmin -uroot -p旧密码 password '新密码'

⚠️ 改完记得同步更新 docker run 命令里记录的密码,否则下次重建容器会懵。


13. 备份与恢复

13.1 逻辑备份(mysqldump,推荐日常用)

备份单个库:

docker exec mysql mysqldump -uroot -p123456 \
  --single-transaction --routines --triggers \
  appdb > appdb-$(date +%F).sql

备份所有库(含账号权限):

docker exec mysql mysqldump -uroot -p123456 \
  --all-databases --single-transaction --routines --triggers --events \
  > all-$(date +%F).sql

参数说明:

参数 作用
--single-transaction InnoDB 下用事务保证一致性快照,不锁表,可热备
--routines 包含存储过程和函数
--triggers 包含触发器
--events 包含定时事件
--all-databases 所有库
--no-data 只要结构,不要数据
--where="..." 条件导出部分数据

13.2 恢复

docker exec -i mysql mysql -uroot -p123456 appdb < appdb-2026-01-01.sql

⚠️ 注意 -i(保持 stdin 打开),否则重定向不生效。

13.3 物理备份(直接拷数据目录)

必须停容器:

docker stop mysql
docker run --rm -v mysql-data:/data -v $(pwd):/backup alpine \
  tar czf /backup/mysql-physical-$(date +%F).tar.gz -C /data .
docker start mysql

体积小、恢复快,但不能跨大版本用(8.0 的数据目录不能直接给 8.4)。

13.4 备份策略建议

场景 方案 频率
学习环境 重建就行 不用备
小项目 mysqldump 全库 每天
中等项目 mysqldump + binlog 每天全备 + 实时 binlog
生产 Percona XtraBackup / 主从 按 RPO 要求

13.5 定时备份脚本

#!/bin/bash
# /opt/backup-mysql.sh
BACKUP_DIR=/opt/mysql-backup
mkdir -p $BACKUP_DIR
docker exec mysql mysqldump -uroot -p123456 \
  --all-databases --single-transaction --routines --triggers \
  | gzip > $BACKUP_DIR/all-$(date +%F-%H%M).sql.gz
# 只保留 7 天
find $BACKUP_DIR -name "*.sql.gz" -mtime +7 -delete
chmod +x /opt/backup-mysql.sh
crontab -e
# 每天凌晨 3 点
0 3 * * * /opt/backup-mysql.sh

14. 慢查询日志:配置、验证与分析

本节来自一次真实踩坑:改完 slow_query_log = 1、long_query_time = 2, SHOW VARIABLES LIKE 'slow_query_log' 却依然显示 OFF。

14.1 现象

docker exec mysql mysql -uroot -p123456 -e "SHOW VARIABLES LIKE 'slow_query_log';"
Variable_name   Value
slow_query_log  OFF          ← 明明改过配置文件

14.2 根因:配置文件只在启动时读一次

SHOW VARIABLES 显示的是运行时值,而 my.cnf 只在 mysqld 启动的那一刻被读取。

于是只有两种可能:

  1. 改对了文件,但没重启 → 运行值还是旧的
  2. 重启了,但文件根本不在 mysqld 的搜索路径里 → 改了等于没改

在 Docker 环境里,第二种更常见。

14.3 三步诊断

第 1 步:文件在不在容器里(最快,也最致命)

docker exec mysql ls -l /etc/mysql/conf.d/

本次实际输出:

total 0

空目录。 说明配置文件写在宿主机上,从来没进过容器。

背景很关键 —— 这个 8.4 容器是用下面这条命令起的,没有挂载任何配置目录:

docker run ... -v mysql-data:/var/lib/mysql ... mysql:8.4 --innodb-buffer-pool-size=256M

/etc/mysql/conf.d/ 在容器里只是镜像自带的空目录。宿主机上改文件,容器完全看不到。

顺手确认加载链是否完整:

docker exec mysql cat /etc/mysql/my.cnf

官方镜像里应该有:

!includedir /etc/mysql/conf.d/
!includedir /etc/mysql/mysql.conf.d/

没有这两行,conf.d 目录里的任何东西都不会生效。

第 2 步:mysqld 到底读到了什么(最权威)

docker exec mysql mysqld --print-defaults

它打印从所有配置文件加载到的参数,是判断"文件有没有被读到"最直接的方式。

本次输出:

/usr/sbin/mysqld would have been started with the following arguments:
--host-cache-size=0 --skip-name-resolve --datadir=/var/lib/mysql
--socket=/var/run/mysqld/mysqld.sock --secure-file-priv=/var/lib/mysql-files
--user=mysql --pid-file=/var/run/mysqld/mysqld.pid

没有 --slow-query-log —— 确认文件没被读到。

💡 两个易错点

① --print-defaults 只读配置文件,不包含容器启动时命令行传的参数。 所以它看不到 docker run 后面跟的 --innodb-buffer-pool-size=256M——那属于 Config.Cmd, 用 docker inspect mysql --format '{{json .Config.Cmd}}' 查。

② 输出里那些 --datadir、--user=mysql、--pid-file 是镜像自带配置文件的内容。 它们出现说明配置加载链路本身是通的,只是 conf.d 目录空着、没东西可加载。

第 3 步:日志里有没有"被忽略"的警告

docker logs mysql 2>&1 | grep -i "config\|ignored\|world-writable"

两个经典警告:

Warning: World-writable config file '/etc/mysql/conf.d/my.cnf' is ignored

文件权限 666/777 会被 MySQL 直接忽略(安全机制),必须 chmod 644。

⚠️ 但要注意:MySQL 成功读取配置文件时不打日志,只在出问题时报警。 所以"没有警告"不等于"文件被读到了"——这一步只能排除权限问题,不能证明配置生效。

14.4 排查决策树

flowchart TD
    A["SHOW VARIABLES 显示 slow_query_log = OFF"] --> B["docker exec mysql ls -l /etc/mysql/conf.d/"]
    B --> C{"目录里有 .cnf 文件吗?"}
    C -->|"没有"| D["配置在宿主机<br/>没挂进容器<br/>→ SET PERSIST 或重建挂载"]
    C -->|"有"| E["docker exec mysql mysqld --print-defaults"]
    E --> F{"输出里有 --slow-query-log 吗?"}
    F -->|"没有"| G["文件存在但被忽略<br/>查 [mysqld] 段头 / 权限 644 / 加载顺序"]
    F -->|"有"| H["配置读到了<br/>只是没重启<br/>→ docker restart mysql"]

ASCII 版本:

改完配置 → SHOW VARIABLES 还是 OFF
              │
              ▼
   /etc/mysql/conf.d/ 里有 .cnf 吗?
        │                  │
       没有                有
        │                  │
        ▼                  ▼
  配置在宿主机        mysqld --print-defaults
  没挂进容器            里有 --slow-query-log 吗?
  → SET PERSIST          │            │
  → 或重建挂载          没有          有
                         │            │
                         ▼            ▼
                  文件被忽略      只是没重启
                  查段头/权限     docker restart

14.5 四个让配置"改了不生效"的写法错误

# 错误 说明
① 缺 [mysqld] 段头 文件顶层直接写 slow_query_log = 1,mysqld 不认
② 追加到错误的段后面 用 echo >> 往文件末尾加,而最后一个段是 [client],参数就进了客户端组
③ 多个文件互相覆盖 !includedir 按文件名字母序加载,后面的覆盖前面的
④ 会话级 SET 当成全局 SET long_query_time = 2 只影响当前连接;必须 SET GLOBAL

正确的写法:

[mysqld]
slow_query_log = 1
slow_query_log_file = /var/lib/mysql/slow.log
long_query_time = 2

long_query_time 同时有全局和会话两个作用域,SHOW VARIABLES 显示的是当前会话的值。 所以可能出现"我这个窗口是 2,别的连接还是 10"的诡异现象。 slow_query_log 只有全局作用域,不受这个问题影响。

14.6 参数在哪一层生效(一张表记住)

层次 写法 生效时机 重启后保留 容器重建后保留
会话级 SET x = v 立即 ❌ ❌
全局级 SET GLOBAL x = v 立即 ❌ ❌
持久化 SET PERSIST x = v 立即 ✅ ✅(卷在就行)
配置文件 my.cnf 重启 ✅ ✅(宿主机文件)
命令行 docker run ... mysql:8.4 --x=v 启动 ✅ ✅(写在 run 命令里)

Docker 环境下,SET PERSIST 是性价比最高的那一层——它写进数据卷里的 mysqld-auto.cnf, 跟着数据走,既不用改 docker run 命令,也不用重建容器。

14.7 方案 A:SET PERSIST(推荐,不用重建容器)

docker exec mysql mysql -uroot -p123456 -e "
SET PERSIST slow_query_log = ON;
SET PERSIST slow_query_log_file = '/var/lib/mysql/slow.log';
SET PERSIST long_query_time = 2;
"

验证:

docker exec mysql mysql -uroot -p123456 -e "
SHOW VARIABLES LIKE 'slow_query_log';
SHOW VARIABLES LIKE 'slow_query_log_file';
SHOW VARIABLES LIKE 'long_query_time';
SHOW VARIABLES LIKE 'log_output';
SELECT * FROM performance_schema.persisted_variables;
"

本次实际输出(全部正确):

Variable_name          Value
slow_query_log         ON
slow_query_log_file    /var/lib/mysql/slow.log
long_query_time        2.000000          ← 浮点数,6 位小数是正常显示
log_output             FILE              ← 必须是 FILE,否则慢日志不写成文件
 
VARIABLE_NAME          VARIABLE_VALUE
long_query_time        2.000000
slow_query_log_file    /var/lib/mysql/slow.log
slow_query_log         ON

撤销持久化:

RESET PERSIST slow_query_log;   -- 撤销单项
RESET PERSIST;                  -- 撤销全部

mysqld-auto.cnf 的位置:/var/lib/mysql/mysqld-auto.cnf(在数据卷里)。

14.8 方案 B:配置文件 + 挂载(要重建容器)

需要版本管理、多环境部署时用这个。

1. 在宿主机建配置文件

mkdir -p /opt/mysql/conf
cat > /opt/mysql/conf/my.cnf <<'EOF'
[mysqld]
slow_query_log = 1
slow_query_log_file = /var/lib/mysql/slow.log
long_query_time = 2
log_queries_not_using_indexes = 0
EOF
chmod 644 /opt/mysql/conf/my.cnf

chmod 644 不能省。权限 666/777 的文件会被 MySQL 静默忽略。

2. 删掉容器重建(挂载参数无法热改)

docker rm -f mysql
 
docker run -d \
  --name mysql \
  --restart unless-stopped \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD='123456' \
  -e TZ=Asia/Shanghai \
  -v mysql-data:/var/lib/mysql \
  -v /opt/mysql/conf:/etc/mysql/conf.d:ro \
  --health-cmd='mysqladmin ping -h 127.0.0.1 -uroot -p$MYSQL_ROOT_PASSWORD' \
  --health-interval=30s \
  --health-retries=3 \
  mysql:8.4 \
  --innodb-buffer-pool-size=256M

数据卷 mysql-data 原封不动,数据不会丢。

3. 验证

docker exec mysql ls -l /etc/mysql/conf.d/
docker exec mysql mysqld --print-defaults | tr ' ' '\n' | grep -i slow

14.9 验证:制造一条慢查询

变量是 ON 不算数,得让它真记一条:

docker exec mysql mysql -uroot -p123456 -e "SELECT SLEEP(3);"
docker exec mysql cat /var/lib/mysql/slow.log

日志长这样:

# Time: 2026-11-17T08:15:22.123456Z
# User@Host: root[root] @ localhost []  Id:  12
# Query_time: 3.000123  Lock_time: 0.000000 Rows_sent: 1  Rows_examined: 1
SET timestamp=1763367322;
SELECT SLEEP(3);

三个关键字段:

字段 含义 数值高了说明什么
Query_time 总耗时 超过 long_query_time 才会被记录
Lock_time 等锁时间 高 → 并发冲突、事务太长
Rows_examined 扫描行数 高 → 索引没走对、全表扫描

14.10 四个进阶参数

默认配置有时"记太多"或"记太少",按需加:

-- ① 记录没走索引的查询(默认 OFF,调试期用,别长期开,日志会暴涨)
SET PERSIST log_queries_not_using_indexes = ON;
 
-- ② 扫描行数少于 N 的不记(过滤噪音)
SET PERSIST min_examined_row_limit = 100;
 
-- ③ 记录 ALTER TABLE / ANALYZE TABLE 这类管理语句(默认 OFF)
SET PERSIST log_slow_admin_statements = ON;
 
-- ④ 记录更详细的执行信息(8.0.14+,强烈建议开)
SET PERSIST log_slow_extra = ON;

log_slow_extra 打开后,日志会多出这些字段:

Bytes_sent: 123  Tmp_tables: 0  Tmp_disk_tables: 0  Tmp_table_sizes: 0
Full_scan: No  Full_join: No  Tmp_table: No  Tmp_table_on_disk: No
Filesort: No  Filesort_on_disk: No  Merge_passes: 0
InnoDB_IO_r_ops: 0  InnoDB_IO_r_bytes: 0  InnoDB_IO_r_wait: 0.000000
InnoDB_rec_lock_wait: 0.000000  InnoDB_queue_wait: 0.000000
InnoDB_pages_distinct: 1

排障价值极高:能直接看出是全表扫描(Full_scan: Yes)、 临时表落盘(Tmp_table_on_disk: Yes)、还是文件排序(Filesort: Yes)导致的慢。

14.11 日志轮转、清理与分析

日志在数据卷里,会一直长。

docker exec mysql ls -lh /var/lib/mysql/slow.log

清空(MySQL 以 append 模式打开,truncate 不影响运行):

docker exec mysql truncate -s 0 /var/lib/mysql/slow.log

轮转(改名 + 让 MySQL 重开新文件):

docker exec mysql mv /var/lib/mysql/slow.log /var/lib/mysql/slow.log.1
docker exec mysql mysql -uroot -p123456 -e "FLUSH SLOW LOGS;"

⚠️ FLUSH SLOW LOGS 只关闭并重新打开日志文件,不会清空内容。想清空必须 truncate。

参考量级:long_query_time = 2 时,普通业务一天几 MB ~ 几十 MB。 一天几百 MB 说明阈值定得太严,或者有大量缺索引的查询。

三个分析工具:

工具 用法 说明
mysqldumpslow docker exec mysql mysqldumpslow -s t /var/lib/mysql/slow.log MySQL 自带(Perl 脚本),简单统计
pt-query-digest 见下 Percona 出品,输出最专业
grep / awk grep "Query_time" slow.log | sort -t: -k2 -rn | head 应急用
docker run --rm \
  -v mysql-data:/data:ro \
  percona/percona-toolkit \
  pt-query-digest /data/slow.log

输出按"总耗时占比"排序,直接告诉你哪条 SQL 最值得优化。

mysqldumpslow 依赖 Perl,官方镜像里不一定有。 跑之前先 docker exec mysql which mysqldumpslow 确认。

14.12 小结

"改配置不生效"这个问题,90% 是这两个原因之一:文件没进容器、改了没重启。

养成一个习惯——调 MySQL 参数前先问三句:

  1. 这个文件在容器里吗?—— docker exec mysql ls -l /etc/mysql/conf.d/
  2. mysqld 读到了吗?—— docker exec mysql mysqld --print-defaults
  3. 改完重启了吗?—— docker restart mysql

不想折腾这三步,就直接用 SET PERSIST:立刻生效、重启还在、容器重建也不丢。


15. 小内存机器的参数调优

本次机器只有 1.8G 内存,必须调。默认配置下 MySQL 8.4 起步就要 400~600M。

15.1 关键参数

参数 默认值 小内存建议 说明
innodb_buffer_pool_size 128M 128M~256M 最重要的参数,缓存数据和索引
performance_schema ON OFF(省 100~200M) 性能监控,学习环境不需要
max_connections 151 50 每个连接约占 1M+
innodb_log_buffer_size 16M 8M redo log 缓冲
mysqlx ON OFF(省几十 M) X Protocol,用不到就关
table_open_cache 4000 400
tmp_table_size 16M 16M

15.2 怎么改

方式 A:命令行参数(本次用的)

docker run ... mysql:8.4 \
  --innodb-buffer-pool-size=256M \
  --performance-schema=OFF \
  --max-connections=50 \
  --mysqlx=OFF

方式 B:配置文件(更清晰,推荐)

mkdir -p /opt/mysql/conf
cat > /opt/mysql/conf/my.cnf <<'EOF'
[mysqld]
innodb_buffer_pool_size = 256M
performance_schema = OFF
max_connections = 50
mysqlx = OFF
character-set-server = utf8mb4
collation-server = utf8mb4_0900_ai_ci
default-time-zone = '+08:00'
EOF
 
docker run ... -v /opt/mysql/conf:/etc/mysql/conf.d:ro ... mysql:8.4

官方镜像的 /etc/mysql/my.cnf 里有 !includedir /etc/mysql/conf.d/,所以放这个目录的文件会被自动加载。

15.3 加 swap(内存实在不够时)

# 创建 2G swap 文件
fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
 
# 永久生效
echo '/swapfile none swap sw 0 0' >> /etc/fstab
 
# 确认
free -h

⚠️ swap 会让数据库变慢(尤其 redo log 刷盘时),只是防 OOM 的兜底,不是解决方案。真正的解法是加内存或减少容器数量。

15.4 查看实际占用

docker stats mysql --no-stream
CONTAINER   CPU %   MEM USAGE / LIMIT     MEM %
mysql       0.5%    310MiB / 1.8GiB       17%

15.5 给容器加内存上限(防它吃光宿主)

docker run ... --memory=512m --memory-swap=1g mysql:8.4

⚠️ 设太小会导致 MySQL 启动就 OOM,至少给 512M。


16. 跨机连接:虚拟机 ↔ Windows

16.1 两个方向先分清

方向 谁连谁 配置重点
Windows → VM Windows 上的客户端连虚拟机的 MySQL VM 端口发布 + VM 防火墙 + 账号 host
VM → Windows 虚拟机的客户端连 Windows 上的 MySQL Windows 监听地址 + Windows 防火墙 + 账号 host

本次实际做的是第二种(VM → Windows),但配置逻辑是镜像的。

16.2 网络拓扑

graph LR
    subgraph WIN["Windows 宿主机"]
        W1["MySQL 8.x<br/>监听 0.0.0.0:3306"]
        W2["VMnet8 虚拟网卡<br/>192.168.x.1"]
        W3["防火墙入站规则<br/>放行 3306"]
    end
    subgraph VM["Linux 虚拟机"]
        V1["eth0<br/>192.168.x.128"]
        V2["mysql 客户端 / 容器"]
    end
    V2 -->|"TCP 3306"| W3 --> W1
    W2 -.->|"NAT 网关"| V1

16.3 VM → Windows 四步走

Step 1:在 Windows 上看虚拟网卡 IP

ipconfig

找 VMware Network Adapter VMnet8(NAT 模式)或 VMnet1(仅主机模式)的 IPv4 地址,典型是 192.168.x.1。

Step 2:确认 Windows 的 MySQL 监听在 0.0.0.0

netstat -ano | findstr :3306
TCP    0.0.0.0:3306    0.0.0.0:0    LISTENING    12345

如果是 127.0.0.1:3306,说明只监听本机,虚拟机连不进来。改 my.ini:

[mysqld]
bind-address = 0.0.0.0

Step 3:Windows 防火墙放行 3306

New-NetFirewallRule -DisplayName "MySQL 3306 for VMware" `
  -Direction Inbound -Protocol TCP -LocalPort 3306 `
  -RemoteAddress 192.168.0.0/16 -Action Allow

⚠️ 一定要加 -RemoteAddress 限制网段,否则等于对公网开放。 更简单的做法:Windows 安全中心 → 高级设置 → 入站规则 → 新建规则 → 端口 → 3306。

Step 4:Windows 的 MySQL 建一个允许远程登录的账号

-- 在 Windows 的 MySQL 里执行
CREATE USER 'vmuser'@'192.168.%' IDENTIFIED BY '强密码';
GRANT ALL PRIVILEGES ON 目标库.* TO 'vmuser'@'192.168.%';

16.4 在虚拟机上测试连通性

方法 1:nc(最轻量)

nc -zv 192.168.x.1 3306

方法 2:bash 内置 /dev/tcp(无需装任何东西)

timeout 3 bash -c "cat < /dev/null > /dev/tcp/192.168.x.1/3306" && echo "通" || echo "不通"

方法 3:借用 Docker 里的 mysql 客户端(推荐,规避客户端版本问题)

docker run --rm -it mysql:8.4 mysql -h 192.168.x.1 -P 3306 -uvmuser -p

好处:客户端和服务器都是 8.4,不会遇到 caching_sha2_password 兼容问题。虚拟机本身不用装 mysql 客户端。

方法 4:telnet

telnet 192.168.x.1 3306

16.5 连不上怎么排

现象 原因 解法
Connection refused 端口没监听 / 防火墙拒绝 查 netstat、查防火墙规则
Connection timed out 网络不通 / 被防火墙 DROP ping 通不通,查路由
Host 'xxx' is not allowed to connect 账号 host 不匹配 建 % 或对应网段账号
Access denied for user 密码错,或账号不存在 SELECT user,host FROM mysql.user;
Authentication plugin ... cannot be loaded 客户端太老 升级客户端或加 allowPublicKeyRetrieval
Public Key Retrieval is not allowed JDBC 缺参数 URL 加 allowPublicKeyRetrieval=true

17. 踩坑清单

本次实战中真实踩到的坑,按出现顺序:

# 坑 现象 解法
1 内存严重超卖 容器起不来 / 频繁 OOM 删掉不用的容器,free -h 确认 available
2 脏关机导致 redo log 损坏 MY-012960,无限重启 备份后重建数据卷
3 旧镜像 8.0.31 安全补丁缺失 换 mysql:8.4 LTS
4 打错卷名 devsoft_musql-data 以为删除失败,其实删了两个卷 删卷前 docker volume ls 核对
5 把 docker builder prune 当 y/N 回答 prune 没执行 看提示再敲
6 docker system dnf 拼错 command not found 注意 df 不是 dnf
7 mysql -u root -p 报 ERROR 2002 客户端走 socket,宿主没 mysqld 用 -h 127.0.0.1 走 TCP
8 以为 GRANT ... ON appdb.* 会建库 SHOW DATABASES 没有 appdb 先 CREATE DATABASE
9 全角引号 ‘%’ ERROR 1064 语法错误 用 ASCII 单引号
10 抄 mysql_native_password ERROR 1524 插件未加载 8.4 已禁用,改用默认插件
11 以为 CREATE USER 就给了权限 登录后什么都干不了 还要 GRANT
12 重复创建 root@'%' ERROR 1396 已存在 用 ALTER USER
13 改了 /etc/mysql/conf.d/ 里的配置,但容器没挂载这个目录 SHOW VARIABLES 死活不变 docker exec mysql ls -l /etc/mysql/conf.d/ 验证;改用 SET PERSIST(见第 14 节)

通用排障口诀

起不来 → docker ps -a 看状态 → docker logs 看报错
                ↓
         docker inspect 看 ExitCode / OOMKilled / Mounts
                ↓
         df -h 看磁盘 / free -h 看内存
                ↓
         日志有明确错误码 → 查错误码 → 对症处理
         日志干净但退出   → 资源问题(OOM / 权限)

三个"反直觉"的知识点

  1. -h localhost 和 -h 127.0.0.1 不是一回事 Linux 上前者走 Unix socket,后者走 TCP。容器化后宿主机没有 localhost 的 socket,所以前者必失败。

  2. GRANT 不校验库是否存在 可以给一个不存在的库授权,返回 Query OK,但没有任何实际效果。

  3. MYSQL_ROOT_PASSWORD 只在首次初始化生效 数据目录已有数据时,改这个环境变量重启不会改密码。必须 ALTER USER。

  4. 配置文件只读一次,SHOW VARIABLES 是运行时值 my.cnf 只在 mysqld 启动时读。改了文件不重启、或者文件根本不在容器里, SHOW VARIABLES 都不会变。想立刻生效又不怕重启,用 SET PERSIST。


18. 附录

18.1 一键安装脚本

#!/bin/bash
# install-mysql-docker.sh —— 在 Linux 虚拟机上一条命令装好 MySQL 8.4
set -e
 
echo "==> 检查 Docker"
command -v docker >/dev/null || { echo "Docker 未安装"; exit 1; }
 
echo "==> 检查资源"
free -h
df -h /
 
echo "==> 拉取镜像"
docker pull mysql:8.4
 
echo "==> 启动容器"
docker run -d \
  --name mysql \
  --restart unless-stopped \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD='123456' \
  -e TZ=Asia/Shanghai \
  -v mysql-data:/var/lib/mysql \
  --health-cmd='mysqladmin ping -h 127.0.0.1 -uroot -p$MYSQL_ROOT_PASSWORD' \
  --health-interval=30s \
  --health-retries=3 \
  mysql:8.4 \
  --innodb-buffer-pool-size=256M
 
echo "==> 等待就绪"
for i in $(seq 1 30); do
  if docker exec mysql mysqladmin ping -uroot -p123456 --silent 2>/dev/null; then
    echo "MySQL 已就绪"
    break
  fi
  sleep 2
done
 
docker ps | grep mysql

18.2 docker-compose 版本

# docker-compose.yml
services:
  mysql:
    image: mysql:8.4.13
    container_name: mysql
    restart: unless-stopped
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: "123456"
      TZ: Asia/Shanghai
    volumes:
      - mysql-data:/var/lib/mysql
      - ./conf:/etc/mysql/conf.d:ro
      - ./init:/docker-entrypoint-initdb.d:ro
    command:
      - --innodb-buffer-pool-size=256M
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_0900_ai_ci
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-uroot", "-p$$MYSQL_ROOT_PASSWORD"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 30s
 
volumes:
  mysql-data:

启动:docker compose up -d

💡 docker-entrypoint-initdb.d 目录里的 .sql / .sh 文件会在首次初始化时自动执行,适合建库建表。 注意:只在数据目录为空时执行。

18.3 初始化 SQL 示例

./init/01-init.sql:

CREATE DATABASE IF NOT EXISTS appdb
  CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
 
CREATE USER IF NOT EXISTS 'app'@'%' IDENTIFIED BY 'App@2026#Pwd';
GRANT ALL PRIVILEGES ON appdb.* TO 'app'@'%';
FLUSH PRIVILEGES;
 
USE appdb;
CREATE TABLE IF NOT EXISTS demo (
  id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(64) NOT NULL COMMENT '名称',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

18.4 常用 SQL 速查

-- 账号
SELECT user, host, plugin FROM mysql.user;
SHOW GRANTS FOR 'app'@'%';
ALTER USER 'app'@'%' IDENTIFIED BY '新密码';
DROP USER 'app'@'%';
 
-- 库
CREATE DATABASE dbname CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
SHOW CREATE DATABASE dbname;
DROP DATABASE dbname;
 
-- 表
SHOW TABLES;
DESC tablename;
SHOW CREATE TABLE tablename\G
SHOW INDEX FROM tablename;
SELECT COUNT(*) FROM tablename;
 
-- 空间占用
SELECT table_schema,
       ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'MB'
FROM information_schema.tables
GROUP BY table_schema
ORDER BY 2 DESC;
 
-- 运行状态
SHOW STATUS LIKE 'Threads_connected';
SHOW STATUS LIKE 'Uptime';
SHOW VARIABLES LIKE 'max_connections';
SHOW PROCESSLIST;
SHOW ENGINE INNODB STATUS\G

18.5 错误码速查

错误码 含义 常见原因
2002 连不上 socket 客户端走 socket 但服务不在本机
2003 连不上 TCP 端口没开 / 防火墙 / 服务没起
1045 Access denied 密码错 / 账号不存在 / host 不匹配
1064 语法错误 全角标点、缺分号
1130 Host not allowed 账号 host 不允许
1396 CREATE USER 失败 账号已存在
1524 插件未加载 8.4 禁用了 mysql_native_password
1820 必须改密码 MYSQL_ONETIME_PASSWORD 遗留
2059 认证插件不兼容 客户端太老

18.6 MySQL 8.4 与 8.0 的主要差异(升级前必读)

变化 影响
mysql_native_password 默认禁用 老客户端连不上,需升级或加参数
mysql_native_password 在 9.0 移除 必须迁移到 caching_sha2_password
默认认证插件 caching_sha2_password JDBC 需 allowPublicKeyRetrieval=true
--skip-host-cache 等参数移除 启动脚本要改
expire_logs_days 移除 改用 binlog_expire_logs_seconds
默认 binlog_expire_logs_seconds = 2592000(30 天) 从 8.0 的 8 天变了
部分 INFORMATION_SCHEMA 表变更 监控脚本要适配

18.7 参考资料


结语

这次从"装不上"到"跑起来",真正学到的东西不是那几条命令,而是三件事:

  1. 排障要有顺序:ps -a → logs → inspect → 系统资源。乱试只会把现场破坏掉。
  2. 数据可丢与不可丢,是两条完全不同的路径。可丢 → 重建 2 分钟;不可丢 → 先备份再抢救,可能几小时。动手前必须先问自己这个问题。
  3. 教程会过期。mysql_native_password 这种写法在 2019 年是对的,在 8.4 上直接报错。遇到老教程,先查一下当前版本的默认行为。

最后,1.8G 内存跑 MySQL 虽然能跑,但只是"能用"级别。真要做项目,内存是最该先加的东西。


文档版本:2026-11 · 基于 MySQL 8.4.13 + Docker 26.1.4 实测

评论 (0)

还没有评论,来写第一条吧~

写评论