运维派

Redis教程（4）数据持久化配置

Wed, 01 Apr 2026 16:11:01 +0800

一、Redis的持久化介绍

Redis支持将缓存数据持久化到硬盘中保存，避免内存中的数据在服务重启后或者服务器断电等情况下发生丢失。Redis的数据持久化支持rdb快照持久化和aof日志持久化两种方式。在生产环境中如果要考虑Redis数据持久化，建议将两种方式都同时配置，并且是在从库上执行数据的持久化，减少对主库性能的影响

· RDB快照持久化

每隔一段时间或者操作次数达到一定量后，从内存Dump数据形成rdb文件，RDB文件是经过压缩的二进制数据，文件会比较小，恢复速度快。RDB持久化的缺点是如果当前写入的数据还无法触发持久化操作，此时发生宕机，那么会丢失这部分数据

· AOF日志持久化

类似MySQL的Binlog，可以实现每次操作的持久化，数据最为安全，但是影响性能

二、手动保存Redis数据

在配置RDB和AOF前还需要了解下保存Redis数据的命令——save和bgsave，在生产环境中建议使用bgsave进行保存数据，它会fork出一个子进程来读取内存中的数据并写入到文件中，除了fork期间会有短暂的阻塞，后续的操作都不会阻塞客户端的读写请求。但是由于fork出来了新进程，在保存数据的时候内存的消耗也会double，要小心OOM风险

三、RDB持久化配置方法

编辑redis.conf配置文件，主要修改以下内容

save 900 1  #在900秒内，key值发生变化次数超过1次则进行持久化，生产环境通常默认这个值即可 
save 300 10  #在300秒内，key值发生变化次数超过10次则进行持久化，生产环境通常默认这个值即可 
save 60 10000  #在60秒内，key值发生变化次数超过10000次则进行持久化，生产环境通常默认这个值即可  
stop-write-on-bgsave-error yes  # 如果rdb文件在导出过程中出错则让Redis停止任何写数据请求，避免数据不一致 
rdbcompression yes  #压缩rdb数据，消耗CPU性能来节约磁盘空间 
rdbchecksum yes  #服务启动时检查rdb文件的完整性，如果不完整则不启动
dbfilename dump.rdb  #rdb文件名
dir /data/redis/rdb/ #rdb文件保存路径，启动时会从该目录寻找rdb文件

当设置完后重启Redis服务，然后在工作中只要达到了save条件，key就会被保存。并且日志中也会有“xx changes in xx seconds. Saving”这样的记录。如果要关闭rdb功能的话将save选项改为save ""，引号里为空即可

四、AOF持久化配置方法

编辑redis.conf配置文件，主要修改以下内容

appendonly yes  #打开aof功能
#appendfsync  no  #让系统决定持久化时机，Linux默认30秒写入一次数据到磁盘
#appendfsync always  #每个命令都写入磁盘，最多丢失一条命令的数据
appendfsync  everysec  #每秒写一次数据到磁盘，最多丢失一秒数据，满足大部分应用场景，推荐使用
no-appendfsync-on-rewrite  yes  #如果正在导出rdb数据，停止aof的写入（aof将保存在一个队列中，rdb备份完成后执行队列，不会丢失数据）
auto-aof-rewrite-percentage 100  #aof文件体积与上次相比增长率达到100%就进行重写（重写相当于记总账，比如对同一个key做了100次操作，我们只需要最后一次的操作，重写就会把多余的操作给忽略掉）
auto-aof-rewrite-min-size 64m  #和上一项组合使用，aof文件达到64M时进行重写（重写会节省掉空间，因为多余的操作被删除了）
appendfilename  "appendonly.aof"  #aof文件名
dir /data/redis6379

当Redis服务启动后需要进行数据恢复时，如果同时开启了rdb和aof持久化，Redis只会加载aof文件（因为aof即时性高于rdb），如果rdb有数据时，再开启aof选项会把已经存储过的数据清空

当AOF写入文件时如果服务器崩溃或AOF存储已满的情况下，最后一条命令可能会被截断并产生异常的AOF文件。在AOF文件异常的情况下，如果Redis配置文件中指定了aof-load-truncated为yes，那么Redis在启动时会忽略最后一条命令并顺利启动 Redis，否则启动会失败。而如果AOF文件中间命令被破坏的话则需要使用redis-check-aof命令跳转到出现问题的命令行然后尝试手动修复此文件。如果无法手动修复，可以使用redis-check-aof --fix 自动修复AOF 异常文件，不过可能会导致异常部分至文件末尾的数据全部被丢弃。

Redis教程（3）使用info命令分析Redis服务状态

Wed, 01 Apr 2026 16:01:49 +0800

一、Redis info命令介绍

Redis 内置了info命令用于查看服务状态，该命令包含了Redis主要性能指标，支持全局信息和指定模块信息的查看。该命令是进行Redis性能分析和问题排查的关键工具

redis > info  #查看所有模块信息
redis > info keyspace  #查看keyspace模块的信息

二、Redis info命令执行结果说明

# Server 服务端信息
redis_version:3.2.12                        #redis版本号
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:de5f1daa3afe8b6a
redis_mode:standalone
os:Linux 3.10.0-862.el7.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
gcc_version:4.8.5
process_id:42421
run_id:3bfe4f5404c9259beee035f89bb57dc0f1708d5b
tcp_port:6379                              #redis监听端口
uptime_in_seconds:76959                    #redis服务运行了多少秒
uptime_in_days:0
hz:10
lru_clock:9055374
executable:/usr/local/redis/redis-server   #执行的启动脚本
config_file:/usr/local/redis/redis.conf    #配置文件路径

# Clients  客户端信息
connected_clients:1                        #有几个客户端连接
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0                          #因为BLPOP、BRPOP、BRPOPLPUSH命令被阻塞的客户端

# Memory  内存使用情况
used_memory:1947112
used_memory_human:1.86M                    #Redis为了保存数据实际申请使用的空间，不包含碎片占用的内存
used_memory_rss:2211840
used_memory_rss_human:2.11M                #操作系统实际分配给 Redis 的物理内存空间，里面就包含了碎片
used_memory_peak:1947112
used_memory_peak_human:1.86M
total_system_memory:1021906944
total_system_memory_human:974.57M
used_memory_lua:37888
used_memory_lua_human:37.00K
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
mem_fragmentation_ratio:1.14               #内存碎片化，如果碎片化的值达到了2，最好重启redis服务，计算方式是实际内存除以理论内存
mem_allocator:libc                         #redis使用的内存分配器，新版本中使用的是jemalloc，碎片化更少

# Persistence  持久化存储信息
loading:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1535705992
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:0
rdb_current_bgsave_time_sec:-1
aof_enabled:0  #0代表没有开启
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok

# Stats  状态信息
total_connections_received:6               #redis从启动到现在接受到的连接总数
total_commands_processed:76141             #redis从启动到现在接受到的命令总数，当客户端响应过慢时可通过监控每秒命令执行数来判断服务是否响应延迟
instantaneous_ops_per_sec:1                #每秒执行命令数
total_net_input_bytes:2890573              #入站流量
total_net_output_bytes:113930              #出站流量
instantaneous_input_kbps:0.05
instantaneous_output_kbps:0.00
rejected_connections:0                     #由于达到maxclient的限制而被拒绝的客户端数
sync_full:1
sync_partial_ok:0
sync_partial_err:0
expired_keys:0                             #过期的key数量
evicted_keys:0                             #因为达到max_memory而被淘汰的key数量
keyspace_hits:0                            #缓存命中数
keyspace_misses:0                          #缓存未命中数，结合缓存命中数可以算出命中率
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:615
migrate_cached_sockets:0

# Replication 主从信息
role:master                                 #当前节点的角色，master是主，slave是从
connected_slaves:1                          #有几个从节点
slave0:ip=192.168.145.69,port=6379,state=online,offset=106797,lag=0  #从节点的信息
master_repl_offset:106797                   #主库接收写命令的进度信息，可以计算主从复制差值，配合监控进行告警，让业务代码不走延迟过多的从库
slave_repl_offset：105121                   #从库复制写命令的进度信息，可以计算主从复制差值，配合监控进行告警，让业务代码不走延迟过多的从库
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:106796

# CPU
used_cpu_sys:94.37
used_cpu_user:41.88
used_cpu_sys_children:0.01
used_cpu_user_children:0.00

# Cluster 集群信息
cluster_enabled:0                          #0代表没有开启集群

# Keyspace
db3:keys=2,expires=2,avg_ttl=99950282       #db3中有2个key，有2个key设置了过期时间，平均过期时间是99950282秒（0为不过期）

三、Redis info命令主要关注信息

1、memory模块

该模块输出了内存相关信息，可用于分析内存与碎片问题，比如Redis占用了多少内存、最大可用内存以及内存碎片率等信息

· used_memory_human：把Redis使用的内存总量进行了统计，包含了实际缓存占用的内存和Redis自身运行所占用的内存(如元数据、lua)，但是不包含内存碎片

· used_memory_rss_human：这一项在上一项的基础上包含了内存碎片的统计。如果该值的统计数据大于了maxmemory所设置的值，说明Redis当前有使用swap虚拟内存，效率必然很低。为了避免Redis使用到swap交换内存，建议设置好Key的过期淘汰策略。如果key都有设置TTL过期时间，使用volatile-ttl回收策略最合适；如果没有设置过期时间，使用allkeys-lru比较合适，它会从所有key中挑选最近最少使用的key进行删除(LRU淘汰算法)。

· mem_fragmentation_ratio：内存碎片率由use_memory_rss除以user_memory所得到，内存碎片率越高，说明未回收的内存越多，意味着浪费的内存空间也就越大。通常来说内存碎片率稍大于1是合理的，如果超过1.5表Redis消耗了实际需要物理内存的150%，有50%都是碎片。若是内存碎片率低于1的话，说明Redis能申请的内存已经达不到期望值，有可能是系统内存不够用了使用了SWAP分区。Redis 4之后可以使用动态碎片整理，而之前的版本中如果要清理碎片只能进行重启操作，这样会导致数据丢失（通过RDB进行数据恢复的话也有额外的时间成本）。除了上面提到的方法，修改redis内存分配器也能带来一定的优化效果。Redis支持glibc、jemalloc、tcmalloc几种不同的内存分配器，每个分配器在内存分配和碎片上都有不同的实现。通常使用redis默认的jemalloc内存分配器即可。

· mem_allocator：Redis使用的内存分配器，可以是libc、jemalloc、tcmalloc。libc的性能最次。

· maxmemory_human：Redis最大可使用的内存限制。虽然used_memory_human的值会受到它的限制（比如配置了maxmemory_human为2G，used_memory_human会限制在2G内），但是因为碎片问题used_memory_rss_human会突破限制。带来的直接问题就是如果maxmemory_human配置的和系统最大内存接近容易发生OOM

2、stats模块

排查复杂度过高的命令带来的慢查询问题

· total_commands_processed：对Redis服务处理命令的数量进行统计，这是排查延迟问题的关键值，因为Redis是在单线程模型下工作，会把接收到的客户端命令按顺序执行，如果执行命令过多或者存在很多慢命令就会让整个队列阻塞而导致延迟。由于total_commands_processed的值是递增的，所以要使用Zabbix做监控的话需要统计的是每秒的差值，这样才能知道每秒处理总数是上升还是下降，以便排查

Docker运维教程（2）镜像与容器管理

Fri, 27 Mar 2026 10:44:54 +0800

一、Docker 镜像管理

自从Docker分为CE版和EE版后，命令行也发生了变化。在CE版本中对命令进行了分组，并且支持命令补全，包括版本号都可以自动补全。通过docker --help命令可以看到 Management Commands 包含多个组，这些组都是被操作的对象。不同的组有不同的子命令，所以目前通常都是使用"docker+对象名+子命令"的命令格式（老版本是“docker+子命令”）。虽然以前的命令格式也可以继续使用，但是更推荐使用新的命令格式进行管理

docker container create  #新格式
docker create  #老格式
docker container --help  #查看指定组所支持的子命令

1、查看镜像

使用docker images命令查看当前系统中已下载的镜像信息，包含镜像名称（REPOSITORY）、标签（TAG）、镜像ID（IMAGE_ID）、创建时间（CREATED）、镜像大小（SIZE）等

docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
nginx        latest    0cf1d6af5ca7   17 hours ago   161MB

2、搜索镜像

使用docker search命令可以在默认的镜像仓库中进行镜像搜索，搜索结果中没有带用户名信息的镜像通常是官方镜像

docker search nginx
# INDEX代表了镜像来源于哪个仓库，默认是docker.io
# NAMES：镜像名，如果名字没有用/分割代表是顶级仓库，通常是官方提供的镜像。带/的前面是用户名，后面才是镜像名，后续安装和启动都需要用到这个名字
# DESCRIPTION：镜像的描述信息 
# STARS：是获得的星数，也就是评分或热门程度
# OFFICIAL：官方认证

3、下载镜像

使用docker pull或docker image pull从指定的公网仓库中下载指定的Docker镜像，如果一个镜像存在多个版本，需要先到Docker Hub中确认每个版本的标签才能正确的下载

# registry默认为dockerhub；镜像名格式是<用户名>/<镜像名>，用户名不写的话默认使用官方镜像；镜像标签默认为latest
# docker pull [registry地址[:端口]/]镜像名:标签 
docker pull nginx  #从dockerhub中下载官方nginx镜像
docker pull bitname/wordpress  #从dockerhub下载bitname所提供的wordpress镜像
docker pull quay.io/coreos/flannel:v1.1  #从quay.io这个公网仓库的coreos名称空间中下载镜像flannel镜像，标签为v1.1

4、删除镜像

使用docker rmi或docker image rmi命令可以通过镜像名字或者ID来删除已下载的Docker镜像，ID可以只输入前缀，保持唯一即可

[root@centos1 ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
nginx        latest    0cf1d6af5ca7   18 hours ago   161MB

[root@centos1 ~]# docker rmi 0cf1d
Untagged: nginx:latest
Untagged: nginx@sha256:7150b3a39203cb5bee612ff4a9d18774f8c7caf6399d6e8985e97e28eb751c18
Deleted: sha256:0cf1d6af5ca72e2ca196afdbdbe26d96f141bd3dc14d70210707cf89032ea217
Deleted: sha256:61633ce66c62a864471c8b5378d9ffa3f81c766a960a3590211f3221c1ab4a59
Deleted: sha256:41b747d79cc454963fb711facd1ece56107a1cea116f91f9f2226a8ad2f6aa7a
Deleted: sha256:5517b4dad484d2bd81693cb01c59de8d731101babc8f4e25af94839b01cb8101
Deleted: sha256:97ee1d7582029102147c004b04f96d5bca5bdd9142a91c2164f8d86069a430c3
Deleted: sha256:995b22525898b5afc8b76051e02d5f4ffd7fde6aae7d2098545978c4768b73d2
Deleted: sha256:d56d0c05af74d3308643ed2eb1c57c8a56ebe1922068720f393b30a285072b93
Deleted: sha256:188c9b34dfbe022075d01fc4f5a305412909ef97de440783c15043e68e1b1913

5、查看镜像构建

使用docker history命令可以查看镜像构建过程

docker histrosy image_name

6、镜像标签

使用docker tag命令实现为镜像打标签，通常在需要上传镜像到仓库中时就需要标记好镜像所属仓库地址和用户（也可以直接用 docker build -t 在创建镜像的时候就起好名字）

docker tag 38baaxh26s6661 tanglu/centos:v1.1  #给一个没有标签的镜像打上标签，这里没有写仓库地址，默认是dockerhub，完整格式是dockerhub/tanglu/centos:v1.1
docker tag tanglu/centos:v1.1 tanglu/centos:v1.2  #修改标签
docker tag ngx-app tanglu/ngx-app:1.0  #将镜像ngx-app改名为tanglu/ngx-app:1.0：

二、Docker 容器管理

1、运行容器

docker run命令用于运行镜像成为容器，如果运行的镜像并不存在于本地则会自动去仓库拉取。该选项包含以下子选项：

docker run -d：以后台方式运行容器，该选项需要配合-i、-t选项一起使用，使用该选项后exit退出容器也不影响里面运行的程序

docker run -it：这里包含了i和t两个选项，代表使用交互方式打开一个容器的终端以便执行命令

docker run -e：定义容器启动后的环境变量

docker run --dns：自定义容器的DNS地址

docker run --name：定义容器本身的名字

docker run --hostname：定义容器运行后的主机名，否则会使用容器的ID作为主机名

docker run --network：指定容器的网络，常用于容器跨主机通信

docker run --add-host：为容器的hosts文件增加记录

docker run --rename ：修改容器名字

docker run --rm：当容器退出后会自动被删除掉，常用于进行容器测试或者云主机环境，需要短期且大量的Docker虚拟机工作，工作完成后自动销毁

docker run -d -it --rm --name web01 nginx  #后台启动了一个名为web01的nginx镜像
docker stop web01  #这个容器停止后就会被自动删除

docker run -p：将宿主机中指定的端口与Docker容器中的端口进行映射，可以实现将容器中的端口暴露到宿主机上的效果，方便宿主机访问。比如在容器中安装Nginx后需要把80端口映射到宿主机上，然后通过宿主机就可以访问到容器中的服务。使用netstat命令或者docker ps命令、docker port命令都可以查看到端口映射关系，使用iptables命令还可以看到自动创建好的转发规则

# 不写宿主机端口则是一个随机端口
docker run --name test_nginx --rm -p 80 nginx
# 指定宿主端口
docker run --name test_nginx --rm -p 8080:80 nginx
#宿主机端口为8000，网络接口为ALL
docker run --name test_nginx --rm -p 8000:80 -p 3306:3306 nginx
#指定了网络接口  
docker run --name test_nginx --rm -p 192.168.1.100:8000:80 nginx 
docker port nginx #查看nginx容器的端口映射关系

docker run --restart：Docker容器的自启动，使用该选项后容器会跟随宿主机的启动而自我启动。该选项默认值是no，改为yes即可

docker run -itd --restart=yes  -name=centos_docker1 docker.io/ansible/centos7-ansible /bin/bash

docker run --link：会在hosts文件中为指定的容器做一个解析记录，常用于不同容器之间的互通，免去手动配置IP

docker run -it --link nginx:web nginx:lastert /bin/bash  #nginx为另一个容器的名字，web为这个容器的别名，ping web这个名字可以看到nginx这个容器的IP
#nginx容器和mysql、zabbix互通
docker run --name zabbix-web-nginx-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix" \
      -e MYSQL_ROOT_PASSWORD="zabbix" \
      --link mysql-server:mysql \
      --link zabbix-server-mysql:zabbix-server \
      -p 8080:80 \
      -d zabbix/zabbix-web-nginx-mysql:latest

2、查看容器运行情况

#下面两条命令等效，用于查看系统中正在运行的容器 
docker container ls -a  #加-a可以看到已经停止的容器
docker container ps -a

3、启动与停止容器

启动容器：docker container start

停止容器：docker container stop

重启容器：docker container restart

强制停止容器：docker container kill

docker container stop nginx
docker container restart nginx
docker container kill nginx
docker container stop `docker container ps -qa`  #批量停止容器

4、暂停容器

有时候需要暂停容器工作一段时间，比如进行快照、暂时释放宿主机资源，暂停的容器不消耗资源

docker pause centos:v1    #暂停指定的容器
docker unpause centos:v1  #恢复被暂停的指定容器

5、查看容器元信息

docker container port命令可以查看容器端口的映射信息；docker container inspect命令可以查看容器更详细的底层信息，如容器运行后默认执行什么命令（cmd）、每个容器的IP信息（这就是为什么能通过宿主机访问容器中服务的原因，在安装了Docker后网卡配置里多了一个docker0的网卡，之后建立的容器都是跟该网卡在一个网段内，默认是172.段）

docker container inspect -f {{.NetworkSettings.IPAddress}} nginx  #获取nginx容器下的IP信息,可以精确到小类
docker port test_nginx  #查看端口映射情况

6、登录容器

使用docker container attach、docker container exec两个命令都可以进入运行中的容器，attach是直接进入容器正在运行的命令中，不会启动新的进程。如果容器是在执行一个无限循环进行输出，那attach进入后则会看到这些输出信息。而exec是开启一个新的终端进入容器，之后可以对容器进行各种操作，并且执行exit退出容器时不会让容器停止运行

7、退出容器

容器运行后如果要退出的话，不要使用exit命令或者Ctrl+C来退出终端，这样容器状态会成为exitd状态，里面的服务也就无法正常使用了。需要使用ctrl+p+q这样的组合键进行退出，这样可以保持容器状态是UP。如果容器已经是exitd状态，通过docker start命令启动来恢复运行

8、删除容器

如果要删除已经停止的容器则使用docker rm或者docker container rm命令，跟上镜像名称或者ID都可以删除。如容器没有停止的话是无法直接删除的，需要加上-f选项或者先停止掉容器，使用命令是docker stop或者docker kill，然后跟上ID或者镜像名称，停止后再执行删除就可以了

9、宿主与容器的文件复制

使用docker cp命令可以将文件进行互相复制

docker cp index.html 770fbbsagi:/usr/local/nginx/html/  #复制本地文件index.html到容器/usr/local/nginx/html/中

10、查看容器运行日志

使用docker logs -f可以查看容器的日志，类似于tailf命令

Docker运维教程（1）Docker的基本概念与安装

Wed, 25 Mar 2026 17:37:18 +0800

一、Docker简介

Docker本身并不是容器，而是对容器进行了一种封装，是容器技术的一种简化实现方式。容器技术可以快速将不同版本的应用或者不同应用打包到容器中实现服务快速部署，减少环境不一致带来的问题，而且每个容器之间相互隔离互不影响，并且可以快速移植到其他环境中。通过Docker的Logo也可以看出，它就像是一个集装箱，如果某个装水果的集装箱出了问题，也不会影响到装酒水的集装箱。

二、Docker名词解释

Docker底层是Linux内核所自带的LXC技术，主要包含以下核心：

· CGROUP

负责对Docker各容器之间资源占用进行分配管理。相比传统虚拟化来说Docker容器会共享宿主机的内核资源，而且少了系统层面的开销，不需要为每个容器去虚拟化一个完整的系统，而且即使是下载一个Centos系统镜像也才200M（底层会使用宿主机的内核，也因此容器的内核是无法升级的，必须和宿主机一致）

· Namespace

负责容器之间资源隔离的实现。不同的Namespace隔离的资源不同。UTS用于隔离主机名和域名，要求系统内核版本2.6；IPC用于隔离消息队列、共享内存、信号量，要求系统内核版本2.6；PID用于隔离进程编号，要求系统内核版本2.6；NETWORK用于隔离网络设备和端口等，要求系统内核版本2.6；MOUNT用于隔离文件系统与挂载点，要求系统内核版本2.4；USER用于隔离用户和用户组，要求系统内核版本3.8，这也是为什么要在Centos 7使用Docker的原因。需要注意的是登陆容器后看到的root通常不是真正的root，比如要用那个用户去cat /etc/passwd，那一样会报出权限错误。UTS、NET、IPC这三个名称空间通常是共享给各容器使用，这样可以更方便的实现多容器使用同端口的需求。否则需要DNAT、SNAT两次网络转换才可以

· Docker镜像

可以理解为模板文件，也可以想象成平时装系统用的.iso文件

· Docker容器

镜像运行之后成为docker容器，就像程序运行后变成进程
· Docker仓库（registry）

镜像仓库，就像github一样可以存放很多做好的镜像。比如需要LAMP环境可以去公有仓库里看看有没有合适的镜像，有的话直接下载就可以使用，无需配置。也可以自建仓库，存放适合内部使用的镜像。Docker采用分层构建机制，最底层为bootfs，上层为rootfs。在bootfs中包含了bootloader和kernel，它的作用就是用于引导和启动容器，在容器启动完成后就会卸掉bootfs节约内存，rootfs则是容器的根文件系统。而且不同的镜像如果使用到了相同的内容，只会存一份，节约了磁盘空间。Aufs是Docker最初使用的容器文件系统，而现在最主流的则是overlay2（已经从3.18版本开始被Linux内核合并）、devicemapper（CentOS7早期所使用）

三、安装Docker

1、安装新版本之前清理旧版本及其依赖组件

yum remove docker  docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine

2、配置Docker的官方YUM源

官方仓库可以通过安装手册（https://docs.docker.com/engine/install/）查看，此外还有很多像阿里云、清华大学第三方仓库也可以安装Docker。Docker从V1.13之后分为了CE和EE两个分支，其中docker-ce为社区免费版，docker-ee为商业收费版

#安装yum-utils包后可以通过yum-config-manager来快捷设置仓库地址
yum install -y yum-utils  

#配置仓库地址
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

#安装docker-ce
yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3、启动Docker，如果使用过程中提示"Is the docker daemon running on this host"都说明是服务没有启动

systemctl start docker

4、通过docker version和docker info命令可以查看版本和详细信息。如启动了多少个容器、默认的仓库地址、下载了多少镜像、文件系统等

[root@centos1 ~]# docker version
Client: Docker Engine - Community
 Version:           26.1.4
 API version:       1.45
 Go version:        go1.21.11
 Git commit:        5650f9b
 Built:             Wed Jun  5 11:32:04 2024
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          26.1.4
  API version:      1.45 (minimum version 1.24)
  Go version:       go1.21.11
  Git commit:       de5c9cf
  Built:            Wed Jun  5 11:31:02 2024
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.33
  GitCommit:        d2d58213f83a351ca8f528a95fbd145f5654e957
 runc:
  Version:          1.1.12
  GitCommit:        v1.1.12-0-g51d5e94
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

5、由于安全问题，非root用户默认是无法执行docker相关命令的，可以通过修改用户组的方式进行授权

groupadd docker
usermod -G docker tanglu

四、Docker镜像仓库加速

Dcoker镜像仓库的作用和操作系统YUM仓库类似，只不过里面存放的是各种镜像而不是系统软件。如系统镜像、Redis镜像、MySQL镜像等。由于Docker默认使用的镜像仓库是国外的docker hub，在拉取镜像的时候会存在过慢的问题，所以建议配置镜像加速服务。配置方法也很简单，只需要在Docker服务端配置文件/etc/docker/daemon.json（该文件默认不存在，需自行创建）并自定义仓库地址即可，仓库地址可以通过https://github.com/DaoCloud/public-image-mirror进行查找

cat /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io"
  ]
}


systemctl daemon-reload
systemctl restart docker
docker info  #关注Registry Mirrors输出是否生效

【系统运维】Linux软件防火墙firewalld/iptable配置教程

Fri, 27 Feb 2026 15:10:59 +0800

一、iptables与firewalld区别

Linux系统通过内核netfilter模块对数据包进行过滤，以此实现软件防火墙功能。在 CentOS7 前一般使用iptables作为管理工具，从CentOS7 之后则更多使用firewalld作为管理工具。两者本质上都是netfilter模块的管理工具，但是 firewalld 在使用配置上比 iptables 更为易懂，并且提供了区域（zone）、服务等更高级的概念，更适合需要动态调整防火墙策略的环境

二、iptables 结构

iptables由表和链构成，在表中去定义链的规则

· filter表(默认表)：最常用的表，用于过滤数据包的进出，其中又包含了3个规则链：

INPUT：负责过滤进入主机的数据包

OUTPUT：负责过滤主机发出的数据包

FORWARD：负责转发该主机的数据包到其他目标地址

· nat表（网络地址转换）：多用于内外网地址转换，包含了3个链：

PREROUTING：实现DNAT功能，改变数据包的目的地址，多用于局域网接收公网数据时将目标的地址转换为局域网的一个地址，实现内网跳板机的功能

POSTROUTING：实现SNAT功能，改变数据包的源地址，多用于局域网向公网发送数据时将地址转换为公网地址

OUTPUT：同filter表OUTPUT

· mangle表（不常用）：拆解、修改、重新封装数据包

· raw表（不常用）：对数据包进行状态跟踪

三、iptables 用法介绍

# 表名不写的话默认为filter表
# iptables [-t 表名] 选项 [链名] 条件匹配 -j 执行动作  
# 为filter表的INPUT链增加规则，当目标端口为80并且为tcp协议则放行
iptables -t filter -A INPUT -p tcp --dport 80 -j ACCEPT

1、Firewalld（iptables）常用选项

-A |-D |-I [CHAINS]：给指定的链增加或者删除或者插入一个规则

iptables -A INPUT -p tcp --dport 80 -j DROP    #增加一条规则用于测试  
iptables -L --line-numbers    #加上--line-numbers参数可以显示规则的编号，可以看到之前设置的编号为1
iptables -D INPUT 1    #删除编号为1的规则

-L：显示所有链下的所有规则，默认是filter表，可以用-t选项指定其他表。还可以跟上-n选项，对主机或端口信息不做反向解析；-v显示更详细信息；--line-numbers显示行号

iptables -t filter -L -n   
Chain INPUT (policy ACCEPT)    #INPUT链下的规则
target     prot opt source               destination         

Chain FORWARD (policy ACCEPT)    #FORWARD链下的规则
target     prot opt source               destination         

Chain OUTPUT (policy ACCEPT)    #OUTPUT链下的规则
target     prot opt source               destination

-N：创建自定义链，针对不同的场景创造不同的链，方便管理

iptables -I INPUT -p tcp --dport 80 -j IN_WEB  #将80请求转发给自定义链IN_WEB
iptables -N IN_WEB  #创建自定义链
iptables -I IN_WEB -s 192.168.1.0/24 -j ACCEPT #定义自定义链的具体规则

-X：清空用户自定义链

-Z：计数器归零

-F：清空所有规则或者指定规则

iptables -F  #清空所有规则
iptables -F INPUT  #清空filter表INPUT链中的规则
iptables -t nat -F PREROUTING  #清空nat表PREROUTING中的规则

-p（小写）：指定协议，如tcp、udp、icmp、all

-i：指定网络设备，如eth0

-P（大写）：指定默认的规则。在生产环境中可以把默认规则设置为拒绝，然后对需要放行的服务设置允许规则，不过做这个设置时要注意把22端口放行，不然自己就无法远程上服务器了

iptables -P INPUT DROP    #把INPUT链的默认规则改为DROP

-s：指定客户端源地址，通常是对访问来源做限制

-s 192.168.0.1  #匹配来自192.168.0.1的数据包
-s 192.168.1.0/24  #匹配来自192.168.1.0/24的数据包

--dport：指定目标端口，需配合-p选项。通常是对访问的端口做限制，可以指定连续的端口

iptables -A INPUT -p tcp --dport 80 -j DROP  
iptables -I INPUT -p tcp --dport 10000:10010 -j DROP

--sport：指定源端口，需配合-p选项

--dport 80
--dport 1000:2000
--dport :3000

· -m multiport：可以定义多个端口或者范围，最多指定15个

[!] --sports port[,port|,port:port]...：指定多个源端口
[!] --dports port[,port|,port:port]...：指定多个目标端口
[!] --ports port[,port|,port:port]...：同时指定源端口和目标端口

iptables -t filter -A INPUT -s 192.168.100.10 -d 192.168.100.20 -p tcp -m multiport --dports 22,80 -j ACCEPT

· -m iprange：指明连续的IP地址范围
[!] --src-range from[-to]：源IP地址
[!] --dst-range from[-to]：目标IP地址

iptables -A INPUT -p tcp --dport 80 -m iprange --src-range 192.168.100.50-192.168.100.60 -j DROP #拒绝192.168.100.50-60这几个IP对80端口的访问

· -m connlimit：根据客户端IP并发连接数做限制
--connlimit-upto n：连接的数量小于等于n时匹配
--connlimit-above n：连接的数量大于n时匹配

iptables -A INPUT -p tcp --dport 80 -m connlimit --connlimit-above 10 -j DROP #对80端口连接数大于10个就拒绝

· -m limit：基于速率做限制
--limit N[/second|/minute|/hour|/day]：平均速率，比如每分钟允许N个请求
--limit-burst number：初始放行数量

iptables -I INPUT -d 192.168.100.10 -p icmp -m limit --limit 3/minute  #每个客户端每分钟只能有3次请求

· -m string：根据字符串进行匹配

iptables -I INPUT -p tcp --dport 80 -m string --algo bm --string 'www.baidu.com' -j DROP #不允许访问baidu.com，--alog bm是一种算法

· -m time：根据时间进行匹配

-m time --datestart 2019-05-01 --datestop 2019-05-04  #匹配五一节
iptables -I OUTPUT -p tcp --dport 80 -m time --timestart 12:30 --timestop 13:30 --kerneltz 2019-05-04  -j DROP #午休拒绝上网

· -m state：根据连接追踪机制检查连接的状态

[!] --state state：state包含以下几种状态
NEW：新请求
ESTABLISHED：NEW状态后所建立好的连接
RELATED：相关联的连接，如FTP服务有2个端口且相关
INVALID：无效连接

iptables -A INPUT -d 192.168.100.10 -p tcp -m multiport --dports 22,80 -m state --state NEW,ESTABLISHED -j ACCEPT

2、iptables 示例

· 单服务器防护，对明确端口的服务放行，其他全部拒绝

iptables -A INPUT -p tcp --dport 22 -j ACCEPT  #放行ssh服务
iptables -A OUTPUT -p tcp --sport 22 -j ACCEPT

iptables -A INPUT -p tcp -m multiport --dport 443,80 -j ACCEPT  #放行443,80端口
iptables -A INPUT -p tcp -dport 3306 -m iprange --src-range 192.168.1.201-192.168.1.210 -j ACCEPT  #允许特定IP访问3306端口
iptables -A OUTPUT -p tcp -dport 3306 -m iprange --dst-range 192.168.1.201-192.168.1.210 -j ACCEPT 

iptables -A INPUT -i lo -j ACCEPT  #本地连接都允许
iptables -A OUTPUT -i lo -j ACCEPT

iptables -A OUTPUT -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT #根据连接状态放行
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -P INPUT DROP
iptables -P OUTPUT DROP

· 局域网共享一个公网地址实现上网。将一台拥有内网、外网双网卡的服务器作为路由器，配置iptables规则，局域网内其他机器将网关地址指向到该路由器内网网卡地址即可

iptables -t nat POSTROUTING -s 192.169.1.100 -o eth0 -j SNAT -to-source 222.201.178.10

· 跳板机功能

# 打开系统IP转发功能
echo 1 > /proc/sys/net/ipv4/ip_forward #临时开启
#永久生效
vi /etc/sysctl.conf
net.ipv4.ip_forward=1
sysctl -p

#请求本机21022端口将跳转到192.168.17.47:3306端口
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 21022 -j DNAT --to-destination 192.168.17.47:3306

#如果客户端172.20.1.132访问172.20.7.101:3306端口，将转发到172.20.7.100:3311端口，该配置是在172.20.7.101完成
iptables -t nat -A PREROUTING -d 172.20.7.101 -p tcp -s 172.20.1.132 --dport 3312 -j DNAT --to-destination 172.20.7.100:3311
iptables -t nat -A POSTROUTING -d 172.20.7.100 -p tcp --dport 3311 -j SNAT --to-source 172.20.7.101

3、iptables 规则的保存与恢复

iptables 的规则默认存储在内存中，重启后会丢失，可以通过命令进行规则持久化

#保存当前配置的规则到指定文件
iptables-save > filename  

#从配置文件还原规则
iptabels-restore < filename

四、firewalld 用法介绍

1、服务管理

systemctl status firewalld      # 检查状态
systemctl start firewalld       # 启动服务
systemctl stop firewalld        # 停止服务
systemctl enable firewalld      # 开机自启
firewall-cmd --reload           # 重新加载配置

2、firewalld 区域（zone）配置

firewall-cmd get-zones    #查看所有zone
firewall-cmd --get-default-zone    #查看默认区域
firewall-cmd --list-all    #查看默认zone的规则
firewall-cmd --list-all --zone=public    #查看指定zone的规则
firewall-cmd  --set-default-zone=test_zone  #指定默认区域

3、firewalld 规则管理

firewalld中可分为service（针对服务）、port（针对端口）、rich rule（富规则）三种配置方式，添加的规则都需要reload才会生效并能查看，permanent表示永久生效

#针对服务
firewall-cmd --zone=public --add-service=http --permanent    # 添加 HTTP 服务
firewall-cmd --zone=public --remove-service=http --permanent # 移除 HTTP 服务

# 端口管理
firewall-cmd --zone=public --add-port=8080/tcp --permanent   # 添加单个端口
firewall-cmd --zone=public --remove-port=8080/tcp --permanent # 移除端口

# 允许/拒绝特定 IP
firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.10" accept' --permanent
firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.20" reject' --permanent

# 端口转发
firewall-cmd --zone=public --add-forward-port=port=80:proto=tcp:toport=8080 --permanent

# 修改默认区域
firewall-cmd --set-default-zone=home

MySQL教程（12）锁的原理与常见锁问题处理

Wed, 11 Feb 2026 14:41:56 +0800

一、数据库锁的作用

数据库锁主要用于解决并发问题，当并发操作发生时，数据库依靠锁来控制这些并发请求对资源（锁是针对资源而非事务）的访问规则，因为被上锁的资源不会被其他事务修改，因为可以保证事务之间的隔离性与一致性

二、MySQL锁分类

1、按粒度分为全局锁、表锁、行锁

· 全局锁

对整个数据库加读锁，当需要让整个数据库处于只读状态时才会加全局读锁，比如需要对使用非InnoDB引擎的数据库做全库逻辑备份。加锁后其他线程的增删改语句、建表、修改表结构语句都会被阻塞，只能进行查询操作，当上锁的客户端断开时会自动释放全局锁

mysql > flush tables with read lock

· 表锁

对整个表进行上锁，表锁开销小、加锁速度快，不会出现死锁，但是发生冲突概率高，导致数据库并发低。用EXCEL举例的话就是用户A正在编辑的表格文件，用户B是无法编辑的。通常数据库引擎不支持行锁的情况下才会用到表锁。适用于查询为主、少量更新的应用，如WEB应用（需要注意全表扫描行为其实也是属于表锁，只不过数据库Server层进行了过滤优化）

mysql > lock tables t1 read  #给t1表上读锁，自己和其他事务可读，但是都不可写
mysql > unlock tables  #释放锁

mysql > lock tables t1 write ; #给t1表上写锁，仅上锁的事务可读可写
mysql > unlock tables  #释放锁

· 元数据锁

表锁的另一种形式，在对表进行DDL操作时，如果有其他事务对该表并发执行DML操作，这些后续的DML都会被阻塞，反过来先有DML再DDL也会有阻塞情况，这都是因为MDL元数据锁的存在。该锁不需要显式使用，事务执行UPDATE、INSERT等操作修改数据时都会对表加MDL写锁，而事务SELECT读取数据时也会自动加MDL读锁，让查询语句未结束无法对数据进行变更。MDL的存在避免DDL操作影响了事务的正常执行，还可以控制不同线程之间事务的执行顺序，避免主从数据不一致。不过也因为MDL的存在，有时候给一个小表进行变更的时候会导致数据库挂掉，如下图：

1、session A进行查询，此时会对表加一个MDL读锁

2、session B进行查询，需要的也是MDL读锁，因此不会互斥，可以正常执行
3、session C修改表结构会被卡住，因为session A的MDL读锁还没有释放，而session C需要MDL写锁，二者互斥
4、后续要对该表申请MDL读锁的请求全部会被session C阻塞，因为所有对表的增删改查操作都需要先申请MDL读锁，自然都被锁住，这个表完全不可读写了

5、如该表查询语句频繁且客户端有重试机制，数据库线程很快就会撑满

· 意向锁

意向锁分为意向共享锁（IS）和意向排他锁（IX），它们都是由存储引擎自行维护的，无法手动去操作意向锁。事务在加共享锁或者排他锁的时候，会自动在该表上添加对应的意向共享锁或意向排他锁。当有其他事务产生时，存储引擎会先获取该数据行所在表上对应的意向锁，这样实现高效的锁冲突检测。

举例说明，比如t1表有10万行数据，某事务只修改了其中一行，这个时候除了被修改的一行会上行锁以外，还会在表上加上意向排他锁。这样后续的事务想对该表进行更新需要上锁的时候只需要先看该表有没有意向锁就可以了，如果没有意向锁的话就需要遍历每一行才知道这个事情

· 行锁

InnoDB引擎默认使用行级锁，行锁相对表锁来性能开销更大，但是可以最大程度地支持并发，冲突概率较低，有可能出现死锁，适合并发度高的业务。用EXCEL举例的话就是用户A正在编辑表格第9行，那么只有第9行是其他用户无法编辑的。InnoDB 的行级锁是通过对索引项加锁来实现的。当查询使用索引时，InnoDB 能够高效地加行级锁。如果查询未使用索引，InnoDB 会进行全表扫描并对扫描到的行逐行加锁，而如果是写操作，如果没有使用索引并且影响的数据行数较多（接近全表），InnoDB为了简化锁管理，会升级会表锁。

UPDATE 和 DELETE 操作都会为数据加行锁，且锁的类型都是独占锁(X型锁)，而普通的 SELECT 语句属于快照读不会对记录加锁，如果要在查询时对记录加行级锁可以使用锁定读的方式实现

#对读取的记录加共享锁(S型锁)
select ... lock in share mode;
select ... lock for share;  # 8.0新增语法

#对读取的记录加独占锁(X型锁)
select ... for update;

· 页锁：开销和并发都介于表锁和行锁之间，会出现死锁

2、按数据操作类型分为读锁和写锁

· 读锁

读锁也可称为共享锁、S锁。当读取一行数据时，为了防止数据被其他事务修改而产生数据不一致的情况，此时就需要对该数据添加S锁。读锁和读锁之间是兼容的，例如事务1在某一行数据上加了共享锁，另外一个事务2也是可以正常对改行进行读取的，因为读取数据的操作并没有改变数据本身，这种情况锁和锁之间是兼容的

· 写锁

写锁也可称为排他锁、X锁、独占锁。通常被修改的数据都会上写锁，这也是为了防止其他事务同时对数据进行修改或者查询。写锁与写锁以及写锁与读锁之间都是互斥的，也就是说必须等当前上锁的事务结束后才能继续上其他锁

SELECT * FROM t1 where id=1 FOR UPDATE  #使用FOR UPDATE对数据加X锁

· 间隙锁（GAP锁）

GAP只会在RR隔离级别才会产生，通过对一个被事务修改的数据的空隙上锁的手段来防止幻读，但是会让死锁的机率变高。这个间隙是根据表中数据的实际情况来进行划分的，比如事务1执行“update test set num=10 where num < 10”，如果表中存在1,3,5,10这几个值，那么被锁的范围应该是1-3，3-5，5-10，这时执行insert into test values (8)是会被锁住的。

假设有表数据如下图

SELECT * FROM t1 WHERE id > 15 FOR UPDATE;  
INSERT INTO t1 VALUES (20)  #这个被锁很好理解，>15区间
INSERT INTO t1 VALUES (13)  #也会被锁，因为命中了区间为(11,+∞)的GAP锁

3、从对待锁的态度划分（并不是真正的锁，只是锁的设计思想）

· 悲观锁：悲观锁在处理事务的时候认为数据大概率会被修改，所以每次操作都会先上锁，此时其他事务会被阻塞。行锁、表锁、写锁、读锁这些在操作前先上锁的行为都属于悲观锁。悲观锁适用于写操作频繁的场景，如果有大量的读操作，每次读取都会加锁，降低了系统的吞吐量

· 乐观锁：只有在进行数据提交的时候才会判断是否需要加锁。乐观锁不采用数据库自审的锁机制，通常通过程序来实现。乐观锁适用于读操作频繁的场景，如果有大量的写操作，则冲突的可能性会变高

三、MySQL死锁问题

1、死锁的产生

首先长时间的锁等待不等于死锁，偶尔的死锁也不可怕，频繁死锁就需要关注了，理论上来说并发度越高越容易出现死锁，而并发往往不是能自己控制的。所以建议如果事务中需要锁多个行，要把最可能造成锁冲突、最可能影响并发度的锁的申请时机尽量往后放。避免出现死锁后如果某表查询语句比较频繁且客户端有重试机制，把数据库线程撑爆。

死锁现象模拟：

# 事务A和事务B在互相等待对方释放锁，然后形成死锁情况

# 会话A：关闭自动提交事务，修改某行数据但并不提交
mysql> SET AUTOCOMMIT = off;
mysql> START TRANSACTION;
mysql> UPDATE worker SET type = 'B' WHERE id = 1;

# 会话B：关闭自动提交事务，修改某行数据但并不提交
mysql> SET AUTOCOMMIT = off;
mysql> START TRANSACTION;
mysql> UPDATE worker SET type = 'A' WHERE id = 2;

# 会话A：更新id=2的记录，此时事务就已经卡住了，因为会话B还没有提交对该行的修改
mysql> UPDATE worker SET type = 'A' WHERE id = 2;

# 会话B：更新id=1的记录，出现了死锁，MySQL报错，并让重启事务
mysql> UPDATE worker SET type = 'B' WHERE id = 1;
ERROR 1213 (40001): Deadlock found when trying to get lock; try resta rting transaction

# 会话A：更新id=2的记录成功，这是因为会话B出现死锁被KILL了，所以会话A才能执行成功，但是也经历了很长的锁等待时间

2、MySQL对于死锁的处理

当出现死锁后，如果不回滚其中一个事务就无法打破锁，MySQL数据库通过死锁检测和超时来解决死锁问题，当检测到有事务出现循环依赖的时候会返回一个错误信息或者超过锁等待时间后终止查询。为了避免死锁，最好的方式一是调整业务逻辑，避免一些会长时间持有锁的事务在前面执行。二是将大事务拆成小事务，缩短每个事务锁的时长；三是调整事务隔离级别，比如RR模式下存在的GAP锁就可能产生意料之外的死锁

· 等待，直到超时

设置锁超时时间，减少无意义的等待。但是也不能直接设置成一个很小的值，比如1S，这样虽然出现死锁的时候很快就可以解开，但如果是简单的锁等待也会被误伤

lock_wait_timeout = 1800  #默认是1年，非常不合理，建议设置为1800秒足够
innodb_lock_wait_timeout= 10  #行锁超时时间，默认50秒，建议调低

· 使用死锁检测自动处理

开启死锁自动检测机制，当事务出现死锁的时候触发，可以主动回滚死锁链条中代价较小的事务，让其他事务得以继续执行。死锁检测会消耗一定的CPU资源，复杂度是O(n)级别，比如100个并发更新同一行数据，那么检测次数就是100*100=1万次，所以如果是在一些经常出现死锁的业务场景，可以尝试关掉死锁的自动检测，让事务排队处理，节约CPU资源。

innodb_deadlock_detect=on  #默认已开启这个逻辑

四、MySQL 锁的分析与排查

查询表锁

--- 查看当前数据库是否存在表锁，只要大于0就代表有表正在被锁
mysql > show open tables where in_use >0 ;

查看事务锁的情况

在MySQL 5.7或之前版本中，通过information_schema系统库中的INNODB_TRX、INNODB_LOCKS、INNODB_LOCK_WAITS三张表可以查看当前数据库事务与锁详情，MySQL 8.0 开始使用 PERFORMANCE_SCHEMA.DATA_LOCKS 替代 INNODB_LOCKS，PERFORMANCE_SCHEMA.DATA_LOCK_WAITS 替代 INNODB_LOCK_WAITS

· innodb_trx：查看当前正在执行的事务

字段名	含义
trx_id	事务 ID，用于关联锁信息（`INNODB_LOCKS` 和 `INNODB_LOCK_WAITS`）
trx_state	事务状态，如 `RUNNING`（正在运行）、`LOCK WAIT`（等待锁）、`ROLLING BACK`（回滚中）
trx_started	事务开始时间，长时间未结束的事务可能是锁问题的根源
trx_weight	事务对资源的影响程度（锁数、修改数等）
trx_mysql_thread_id	MySQL 线程 ID，可通过 `KILL` 命令终止事务
trx_query	事务正在执行的 SQL 语句，有助于定位问题 SQL

· INNODB_LOCKS：如果没有记录返回，则当前没有事务持有锁，如果有记录则说明有事务对表或行进行了锁定，配合 lock_trx_id，到 INNODB_TRX 表中可以查看该事务的开始时间和执行的 SQL 语句，分析是否为长时间未提交的事务

· innodb_lock_waits：查看当前正在等待的事务，也就是因为锁而被阻塞的事务

字段名	含义
requesting_trx_id	正在等待锁的事务 ID，可关联 `INNODB_TRX`
requested_lock_id	正在请求的锁 ID，可关联 `INNODB_LOCKS`，查看具体的锁资源
blocking_trx_id	阻塞请求的事务 ID，可关联 `INNODB_TRX`，查看持有锁的事务信息
blocking_lock_id	阻塞锁的 ID，可关联 `INNODB_LOCKS`，查看具体的锁资源

SELECT * FROM information_schema.innodb_trx ;     
SELECT * FROM information_schema.innodb_locks ;    #查看当前存在的锁 
SELECT * FROM information_schema.innodb_lock_waits;   
SELECT * FROM sys.innodb_lock_waits          #将information_schema.innodb_lock_waits的信息进行了整理，方便用kill命令处理

查找被锁的语句

1、首先简单的制造一个锁

#事务A
mysql> begin;
mysql> delete from action1 where id = 3;

#事务B
mysql> update action1 set id = 7 where id = 3;

2、通过show processlist命令只能看到事务B的语句一直处于执行中的状态，但是并不知道为什么被锁住。如果state字段出现很多waiting for ... lock，大概率也是出现了死锁，但是通过show processlist已经无法定位原因

3、查看当前正在执行的事务，主要关注trx_weight、trx_rows_modified、trx_rows_locked，它们代表了事务的大小和影响行数

SELECT * FROM information_schema.innodb_trx ;    #查看正在执行的事务
SELECT * FROM information_schema.innodb_locks ;   #查看锁 
SELECT * FROM information_schema.innodb_lock_waits;  #查看被阻塞和产生阻塞的事务，但是这里的ID为数据库内部ID，并不能很快速的处理
SELECT * FROM sys.innodb_lock_waits          #将information_schema.innodb_lock_waits的信息进行了整理，方便用kill命令处理

4、sys.innodb_lock_waits解析

waiting_trx_id：等待锁释放的线程ID，属于MySQL内部的ID

waiting_query_secs：因为锁导致事务的等待时间

waiting_pid：等待锁的事务ID，也就是show processlist看到的ID

waiting_query：因为锁被阻塞的SQL语句

blocking_trx_id：导致锁的线程ID，属于MySQL内部的ID

blocking_pid：导致锁的事务ID，，也就是show processlist看到的ID，通常是KILL的对象

Redis教程（2）常用数据类型与数据管理

Tue, 03 Feb 2026 11:30:37 +0800

一、Redis 数据类型

Redis最核心的5种数据类型是字符串（Strings）、哈希（hash）、列表（list）、集合（set）、有序集合（sorted set），除此之外还有高级数据类型位图（Bitmap）、HyperLogLog、地理位置（Geo），其中字符串类型是最简单、使用也最广泛的数据类型。

· 字符串类型

字符串数据类型可以用于多种场景，但是单个Key的值不能超过512M。通常运用于分布式系统session会话缓存共享、浏览计数器等，比如直播时的浏览量就可以使用incr、decr来实现，刷礼物时通过incrby命令来实现。字符串类型有点万金油，但是由于它需要额外的空间来记录数据长度、内存使用等元数据，当实际保存的数据本身很小时，元数据的空间开销反而显得就很大了

· Hash类型

常当作数据库缓存使用，如商品购物车、用户或者产品的详情信息。哈希类型的数据适合存储对象，其数据结构有点像MySQL表中的一行数据，包含了多个字段。MySQL是一张表里存放了多个字段和值，而Redis的Hash类型就是一个key里存放了多个字段和值。由于一个Hash对应一个集合的数据，但是也只使用一个dictEntry来存储元数据，所以会比字符串类型的数据更节省内存空间

· Redis list类型

list列表类型的数据一般用于消息队列（比如使用Redis作为ES的消息队列，当发现ES没有日志进来的时候，可以先看redis消息队列中是否有数据），一个key可以拥有多个value，且值可重复

· Redis集合

分为了有序集合（zset）和无序集合（set），集合内的元素都不可重复。无序集合通过交集、差集或并集获得需要的数据，常用于社交软件共同好友、微博圈子。区别在于有序集合的每一个成员都关联一个评分(score)，可以根据这个评分对集合中的成员进行排序，成员虽然是唯一的，但是评分可以重复，常用于做排行榜场景。

· HyperLogLog

该数据类型主要用于对一些海量数据进行统计，并且只会消耗少量的空间（12K的空间可以统计出2^64的数据）。比如统计数千万级别的访问请求中的独立IP数

· GEO类型

该数据类型根据设置的经纬度可以算出地理位置信息以及不同位置的距离，还可以统计出某范围内的成员，比如很多APP上附近的人就可以用该功能实现，而经纬度信息可以通过百度地图等工具进行查询

二、Redis 客户端使用

Redis 自带了命令行客户端工具 redis-cli，通过该工具可以连接 Redis 并进行相关服务管理、数据操作

redis-cli 常用选项介绍

· -h：指定redis的地址，域名或者ip都可以

· -p：指定redis的端口

· -n：指定需要连接的数据库编号

· -a：如果redis配置了密码需要使用该选项指定密码

· -r：指定命令执行的次数

redis-cli -r 3 ping #ping 三次

· -i：和r结合使用，指定多次命令执行的时间间隔，单位为秒

· --bigkeys：找到内存占用比较大的Key，如果是String类型是输出最大 bigkey 的字节长度、对于集合类型来说会输出最大 bigkey 的元素个数。该命令会扫描数据库来进行查找，对 Redis 性能有一定影响，建议在从节点上执行该命令或者使用 -i 参数控制扫描间隔，避免长时间扫描降低 Redis 实例的性能。这个方法只能返回每种类型中最大的那个 bigkey，无法得到大小排在前 N 位的 bigkey，对于集合类型来说只统计集合元素个数的多少，而不是实际占用的内存量

./redis-cli  --bigkeys

-------- summary -------
Sampled 32 keys in the keyspace!
Total key length in bytes is 184 (avg len 5.75)

//统计每种数据类型中元素个数最多的bigkey
Biggest   list found 'product1' has 8 items
Biggest   hash found 'dtemp' has 5 fields
Biggest string found 'page2' has 28 bytes
Biggest stream found 'mqstream' has 4 entries
Biggest    set found 'userid' has 5 members
Biggest   zset found 'device:temperature' has 6 members

//统计每种数据类型的总键值个数，占所有键值个数的比例，以及平均大小
4 lists with 15 items (12.50% of keys, avg size 3.75)
5 hashs with 14 fields (15.62% of keys, avg size 2.80)
10 strings with 68 bytes (31.25% of keys, avg size 6.80)
1 streams with 4 entries (03.12% of keys, avg size 4.00)
7 sets with 19 members (21.88% of keys, avg size 2.71)
5 zsets with 17 members (15.62% of keys, avg size 3.40)

· --latency：检查redis服务的网络延迟，可以用来查看Redis延迟峰值，分析性能问题

· --latency-histrory：以15秒为间隔显示多条网络延迟信息

redis-cli --latency-histrory

· --stat：实时获取redis重要统计信息，虽然统计信息没有info全面，但是能实时看到增量变化

· --raw：将返回的数据格式化再输出，常用于显示包含中文的Key，当key包含了中文时，登陆Redis增加该选项就可以正确获取到中文，否则是二进制格式

三、Redis 管理命令

· keys：列出符合匹配条件的key，支持通配符，如keys *，但是需要注意如果Key数量特别多的话会导致服务阻塞，建议在从节点执行或者使用scan命令

· type：查看指定key的类型，比如是string还是hash

· exists：查看指定key是否存在，存在返回1，否则为0

· randomkey：返回一个随机Key

· ttl：查看指定Key的有效期，-1代表不过期，-2代表键不存在，其他数字代表距离过期秒数

ttl name

· expire / expireat：设置指定Key的有效期，单位为秒，expireat为时间戳格式

expire name 100

· persist：设置指定Key永不过期

persist name

· del：删除一个或多个key，返回的值是成功删除的个数，如果删除的键不存在返回0。删除Bigkey会有阻塞风险

del key1 key2

· renamenx：修改key的名字，只不过新的key名必须是不存在的才可以，避免覆盖已有的key

· unlink：4.0以上版本所支持新的删除Key方法，不会有阻塞问题

· rename：修改key的名字

rename oldkey newkey

· 命令别名：Redis提供了命令别名的功能，可以把默认命名修改或禁用以增强安全性，如果发现命令无法执行需要检查配置文件中是否配置了命令别名

#将FLUSHALL命令禁用
rename-command FLUSHALL ""

· ping：查看服务是否正常连接，如果正常的话会返回一个pong的输出

· select：选择指定编号的数据库。Redis提供了0-15号数据库，默认是0，但是不推荐使用多个数据库来区分业务，真有这种需求的话考虑多实例更好

select 1  #选择1号数据库

· info：获取服务相关统计信息，如Redis版本的查看，占用的内存等，和keys命令一样可以通配符

· memory usage：4.0开始支持，用于查看制定key占用的内存，单位是字节

memory usage test_key

· client list：查看已连接的客户端

· config get：根据匹配条件查看服务配置信息，支持通配符

config get timeout  #查看配置文件中timeout相关信息
config get requ*  #查看requ开头的配置项

· config set：在线修改redis配置，结合config rewrite可以实现不重启服务而修改配置

config set maxmemory 1gb  #在线修改内存大小，支持各种单位

· config rewrite：将在线配置写入到配置文件，不用重启服务

#在线修改redis最大内存
127.0.0.1:6379> config get maxmemory
1) "maxmemory"
2) "24000000000"
127.0.0.1:6379> config set maxmemory 26000000000
OK
127.0.0.1:6379> config get maxmemory
1) "maxmemory"
2) "26000000000"
127.0.0.1:6379> config rewrite
OK

· flushdb：删除当前选中库中的所有key，数据量大的时候有阻塞风险

· flushall：删除所有库中的所有key，数据量大的时候有阻塞风险

· dbsize：返回当前库中key的数量

· save：将redis数据持久化存储到rdb文件，由于是前台运行会产生阻塞

· bgsave：开启子现成进行数据持久化，不会阻塞

· shutdown：优雅关闭redis

redis-cli -a 123456 -h 127.0.0.1 shutdown

四、Redis 数据操作命令

字符串

· set：创建Key并赋值，区分大小写，可以非交互写入

set site ywpie.com #设置一个key，名为“site”，值为ywpie.com
redis-cli -h 192.168.100.10 -p 6379 set name tom  #非交互式设置或读取key

· get：获取指定Key的值

get site  #获取之前设置的“site”的值

· setnx：创建Key并赋值，但是会先判断该Key是否已经存在，已存在返回0失败，避免覆盖已有数据

· setex：给某个key设置一个值，并且指定一个有效期

setex name 10 tanglu  #10秒过期

· getset：获取一个key的旧值，并赋予新值

getset name tom  #如name旧值为jerry，那么会打印出来，并且重新设置为to

· mset / mget：批量设置和获取多个key，命令复杂度属于O(N)，如果获取的元素个数不是特别多的话可以使用，通过批量操作节约网络带宽。该操作属于原子性操作，在批量设置key时如果有一个key失败，整个操作都会失败

mset name1 tom name2 jerry name3 john

· incr / decr：对指定整数型的Key进行自增自减，应用场景比如微博转发增加次数

· incrby / decrby：对指定整数型的Key进行指定数值的增加或减少

Hash

· hset：设置Redis Hash Key

# hset key field value
# hsetnx key field value
# hmset key field1 value1 field2 value2
hset student1 name tanglu age 30  #设置一个hash key，名为student1，然后添加了name和age两个字段
hset student1 sex male  #新增一个sex字段，值位male
hmset student1 height 175 weight 70  #一次新增多个字段

· hlen：获取Redis Hash Key元素个数

# hlen key
hlen tanglu  #显示结果为4，因为上面示例设置了age sex height weight一共4个字段

· hget：获取指定字段的值，get的时候必须写清楚表名和字段名

# hmget key field1 field2  #获取多个值
hget student1 name

· hgetall：获取Hash Key所有字段的值，同keys命令一样需谨慎使用

hgetall key  #显示出该Hash类型的key下的所有字段和值，谨慎使用
hkeys key  #仅显示该Hash类型的key下的所有字段
hvals key  #和上一步相反，显示的是具体的值

· hdel：删除Hash Key中指定的字段和值

hdel key field1 field2...

· hexists：判断Hash Key字段是否存在，返回1代表存在，0代表不存在

hexists key field  #一次只能跟一个字段
hexists student1 address

无序集合

sadd ages 25
sadd ages 30
sadd ages 32
sadd ages 25  #重复定义，会添加失败
smembers ages  #显示集合中的元素，由于是无序的，不用再指定序号
srem ages 25  #移除一个元素
sismember ages 30  #检查集合中有没有30这个元素

集合

zadd students_top3 tanglu 100 zhangsan 90 lisi 85   
zrange students_top3 0 -1  #会根据评分对成员自动排序 
zrank students_top3 tanglu  #返回1，因为分数排名第一

GEO

#设置2个包含经纬度的key
geoadd site 116.404269 39.913411 tiananmen      #设置了tiananmeng的经纬度
geoadd site 116.36 39.922461  yuetangongyuan

#查询
geopos site tiananmen

#距离计算，可选m或km等单位
geodist site tiananmen yuetangongyuan km

列表

lpush names tanglu  #从左边开始插入数据
lpush names tom
lpush names tanglu  #故意定义了重复的value
lrange names 0 -1  #获取列表里的全部值，0和-1是起始和结束范围，后进入的key的值反而是在前面的
lrange names 0 1  #获取第一个和第二个值
lrem names 1 tanglu  #移除一个值为tanglu的列，这里将会按照序号移除。如果要移除所有的话，序号写0
lpop names  #按照后进先出的方式读取列表里的数据，可当做消息队列
rpop names  #先进先出
del names  #删除列表

blpop   #lpop的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被阻塞，直到有另一个客户端对该key执行LPUSH或RPUSH

【操作系统】LVM的组建与挂载教程

Mon, 19 Jan 2026 10:55:19 +0800

一、背景

在当前业务环境中，为了满足对大容量存储的需求并提升磁盘空间的统一管理能力，计划将服务器中可用的 12 块裸盘（sda~sdl）通过 LVM 的方式整合为一个逻辑卷（LVM），通过把多块物理磁盘组合成一个统一的逻辑存储池，实现简化容量管理、提升扩容灵活性的目的。本次操作会清空目标磁盘上的所有数据，因此在执行前需确认磁盘中无重要数据或已完成备份

二、LVM创建和挂载步骤

1、查看磁盘信息

通过lsblk命令查看当前操作系统中磁盘信息，可以看到这12块盘当前都没有挂载使用，没有MOUNTPOINT信息

[root@k2data-41 ~]# lsblk
NAME            MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda               8:0    0   7.3T  0 disk 
sdb               8:16   0   7.3T  0 disk 
sdc               8:32   0   7.3T  0 disk 
sdd               8:48   0   7.3T  0 disk 
sde               8:64   0   7.3T  0 disk 
sdf               8:80   0   7.3T  0 disk 
sdg               8:96   0   7.3T  0 disk 
sdh               8:112  0   7.3T  0 disk 
sdi               8:128  0   7.3T  0 disk 
sdj               8:144  0   7.3T  0 disk 
sdk               8:160  0   7.3T  0 disk 
sdl               8:176  0   7.3T  0 disk

2、创建 Physical Volume（PV）

通过pvcreate命令将12块磁盘创建为物理卷，即PV

[root@k2data-41 ~]# pvcreate /dev/sda /dev/sdb /dev/sdc /dev/sdd /dev/sde /dev/sdf /dev/sdg /dev/sdh /dev/sdi /dev/sdj /dev/sdk /dev/sdl
  Physical volume "/dev/sda" successfully created.
  Physical volume "/dev/sdb" successfully created.
  Physical volume "/dev/sdc" successfully created.
  Physical volume "/dev/sdd" successfully created.
  Physical volume "/dev/sde" successfully created.
  Physical volume "/dev/sdf" successfully created.
  Physical volume "/dev/sdg" successfully created.
  Physical volume "/dev/sdh" successfully created.
  Physical volume "/dev/sdi" successfully created.
  Physical volume "/dev/sdj" successfully created.
  Physical volume "/dev/sdk" successfully created.
  Physical volume "/dev/sdl" successfully created.
  
  
[root@k2data-41 ~]# pvs
  PV         VG     Fmt  Attr PSize  PFree 
  /dev/sda          lvm2 ---  <7.28t <7.28t
  /dev/sdb          lvm2 ---  <7.28t <7.28t
  /dev/sdc          lvm2 ---  <7.28t <7.28t
  /dev/sdd          lvm2 ---  <7.28t <7.28t
  /dev/sde          lvm2 ---  <7.28t <7.28t
  /dev/sdf          lvm2 ---  <7.28t <7.28t
  /dev/sdg          lvm2 ---  <7.28t <7.28t
  /dev/sdh          lvm2 ---  <7.28t <7.28t
  /dev/sdi          lvm2 ---  <7.28t <7.28t
  /dev/sdj          lvm2 ---  <7.28t <7.28t
  /dev/sdk          lvm2 ---  <7.28t <7.28t
  /dev/sdl          lvm2 ---  <7.28t <7.28t

3、创建 Volume Group（VG）

将12个物理卷组成物理卷组，即VG，并命名为 vg_data

[root@k2data-41 ~]# vgcreate vg_data /dev/sda /dev/sdb /dev/sdc /dev/sdd /dev/sde /dev/sdf /dev/sdg /dev/sdh /dev/sdi /dev/sdj /dev/sdk /dev/sdl
  Volume group "vg_data" successfully created
  
[root@k2data-41 ~]# vgs
VG      #PV #LV #SN Attr   VSize   VFree  
centos    1   3   0 wz--n-  <1.63t      0     #之前的卷组信息
vg_data  12   0   0 wz--n- <87.33t <87.33t    #刚创建的卷组信息

4、创建 Logical Volume（LV）

创建一个逻辑卷lv_data，并且将刚才物理卷组的全部空间都分配给该逻辑卷

[root@k2data-41 ~]# lvcreate -l 100%FREE -n lv_data vg_data
  Logical volume "lv_data" created.
  
[root@k2data-41 ~]# lvs
  LV      VG      Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
  home    centos  -wi-ao---- 100.00g                                                    
  root    centos  -wi-ao----   1.52t                                                    
  swap    centos  -wi-a-----   4.00g                                                    
  lv_data vg_data -wi-a----- <87.33t

5、格式化 LV

[root@k2data-41 ~]# mkfs.xfs /dev/vg_data/lv_data
meta-data=/dev/vg_data/lv_data   isize=512    agcount=88, agsize=268435455 blks
         =                       sectsz=4096  attr=2, projid32bit=1
         =                       crc=1        finobt=0, sparse=0
data     =                       bsize=4096   blocks=23442075648, imaxpct=1
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal log           bsize=4096   blocks=521728, version=2
         =                       sectsz=4096  sunit=1 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

6、挂载分区

mkdir  /data
mount /dev/vg_data/lv_data /data

7、开机自动挂载

编辑 /etc/fstab

bash -c 'echo "/dev/vg_data/lv_data  /data  xfs  defaults  0 0" >> /etc/fstab'

【MySQL 8.0】MySQL 8.0新特性介绍与升级方法

Tue, 02 Dec 2025 09:11:38 +0800

一、MySQL 8.0主要新特性

截至2023年12月，MySQL官方发布的稳定版为8.0.35，另有一个MySQL8.2为创新版，所以暂不做考虑

· 快速新增/删除列

虽然 MySQL 在8.0 以前就已经支持通过 Online DDL实现DDL操作不阻塞DML操作，但在对一些大表进行DDL操作时仍然需要等待很长时间，这样就面临从库延时、耗时过久或者因为DDL操作而创建的临时表产生的资源开销问题。在8.0.12版本开始支持了instant add new column特性，在DDL执行过程中不需要修改存储数据，只用修改存储在系统表中的结构，这样就避免了最耗时的rebuild和apply row log过程，因此效率非常高。经过实际测试，在同服务器下对一个500W的表进行新增或删除字段操作，MySQL 5.7 耗时接近6分钟，MySQL 8.0.35 下仅需要5秒左右

· 自增列持久化

在8.0之前的版本中，如果在自增主键AUTO_INCREMENT值大于max(primary key) + 1 的时候重启了服务，会重置AUTO_INCREMENT的值为max(primary key) + 1。如果主键发生过删除行为，并且对主键列有过更新操作，会触发BUG导致主键冲突。而8.0以后AUTO_INCREMENT会进行持久化存储，不管是删除还是更新操作都会记录到文件中，不会再有这种情况

#5.7 BUG复现过程

#t1表有3行数据
select * from t1  ;
id   c1 
1   test1
2   test2
3   test3

#此时删除AUTO_INCREMENT为3的数据
delete from t1 where id = 3;

select * from t1  ;
id   c1 
1   test1
2   test2

#重启服务后插入新数据
insert into t1(c1) values('test4') ;

#查看新插入的数据，AUTO_INCREMENT将回退为3
select * from t1  ;
id   c1 
1   test1
2   test2
3   test4

#手动修改一条数数据，用到了AUTO_INCREMENT为5
update t1 set id = 5 where c1 = "test1";

select * from t1 ; 
id   c1 
2   test2
3   test4
5   test1

#继续插入数据
insert into t(c1) values('test5') ;

select * from t1  ;
id   c1 
2   test2
3   test4
4   test5
5   test1

#继续插入数据会出现主键冲突，因为mysql此时自动生成的AUTO_INCREMENT为5
insert into t(c1) values('test6') ;

· 新增函数索引

在MySQL 8.0.13之前的版本中如果在查询中使用了函数，会导致索引失效。而从MySQL 8.0.13开始，支持在索引中使用函数或表达式的值。函数索引基于虚拟列功能实现，该列的值都是通过前面的函数或者表达式计算出来的，当使用函数索引的时候就会使用这个计算后的列作为索引

#在未创建函数索引的列上使用函数，不会用到索引
EXPLAIN SELECT * FROM `t_audit_info` WHERE DATE(create_time) > '2021-11-21';

#在t3表的create_time列创建一个使用了DATE函数的索引
ALTER TABLE t3 ADD INDEX idx_create_time_func((DATE(create_time)));

#再次执行查询可以使用索引
EXPLAIN SELECT * FROM `t_audit_info` WHERE DATE(create_time) > '2021-11-21';

· 新增降序索引

倒叙索引的语法在5.7的时候虽然可以使用，但是不会真正生效，添加索引后再查看表结构会发现依然使用的是升序索引。降序索引从8.0 正式支持使用，在对多个字段进行排序时，不同的字段的排序规则可能不同，通过倒叙索引可以提高反向扫描的效率

#创建一个包含降序索引的表格
create table t1(
c1 int,
c2 int,
index idx_c1_c2(c1,c2 desc)
);

#下列包含降序查询的语句可以直接使用索引，执行计划中没有using filesort而是using index
select * from t1 order by c1,c2 desc;

· 新增隐藏索引（不可见索引）

使用invisible关键词可以将索引设置为隐藏索引，查询语句不会使用被隐藏的索引（即便使用force index也不会使用）。该特性一般用于对需要删除的索引进行观察，当索引被隐藏后如果不会对业务带来影响那么就可以正式删除，这样可以减少对大表误删索引后再添加带来的性能成本。需要注意的是索引被隐藏后，如果数据发生更新，索引依然会被更新，长期被隐藏的索引一定要记得删除

creata table t1(
c1 int,
c2 int,
index idx_c1(c1),
index idx_c2(c2) invisible
);

#也可以修改原索引不可见
alter table t1 alter index idx_c1 invisiable;

#不会使用索引
select * from t1 where c2=1;

· Innodb存储引擎支持跳过锁等待

FOR UPDATE语句支持添加NOWAIT、SKIP LOCKED语句。NOWAIT表示如果查询行已经被加锁，那么直接报错返回，不用等待锁超时；SKIP LOCKED可以跳过被锁的行，返回其他没有锁定的记录

select * from t1 for update skip locked;

· GROUP BY语句不再进行隐式排序

在5.7的时候经过group by的字段会默认进行隐式排序，8.0开始需要显式加上order by字句，这个主要是考虑对其他数据库没有自动隐式排序进行兼容，语法更严谨

#5.7支持隐式排序时语法
select count(*) from t1 group by c2;

#5.7版本结果
count(*)        c2
1               10
2               50
1               80
1               100

#8.0版本结果
count(*)        c2
1               10
2               50
1               100
1               80

#8.0开始必须指定order by语句
select count(*) from t1 group by c2 order by c2;

· 新增innodb_dedicated_server自适应参数

该参数可以让InnoDB根据服务器内存自动调整innodb_buffer_pool、innodb_log_file_size等参数，尽可能的使用内存资源。该参数默认关闭，如果服务器上存在其他组件或者是多实例部署，不建议打开该功能

show variables like '%innodb_dedicated_server%';

· undo文件不再使用系统表空间

8.0 将为Undo log默认创建2个单独的表空间，不再使用系统表空间。Undo Log主要存储了回滚数据，是MySQL MVCC机制的根本。在MySQL 8以前这些回滚数据默认存储在了系统表空间ibdata1文件中（在5.7之前甚至无法分离出来）。在有大量并发事务或者大事务未提交的情况下会导致ibdata暴涨的问题，而这部分空间通常只有重启数据库\重建实例才能回收

· binlog日志过期时间可以精确到秒

在8.0之前通过expire_logs_day参数控制binlog的过期时间，8.0开始默认使用更为精确的binlog_expire_logs_seconds参数，expire_logs_day会在未来版本弃用

· DDL事务原子化

MySQL 8.0开始支持了更多的数据字典，元数据全部采用InnoDB引擎进行存储，不再存在.frm文件。因此也让DDL开始支持事务完整性，一个事务中如果提交了多个DDL，它们要么全部成功要么全部回滚，不再出现部分成功的情况

· 可在线持久化配置

MySQL 8.0通过PERSIST命令可以在线修改全局参数并持久化到配置文件中，在线修改的参数会保存到data/mysqld.auto.cnf（该配置文件优先级高于my.cnf），启动MySQL时会从该配置文件拉取配置

SET PERSIST innodb_lock_wait_timeout=15;

· 支持公共表表达式，即WITH语句（CTE，Common Table Expression）

可以将复杂的子查询提取出来，主查询中直接使用，降低子查询复杂度

WITH cte_name AS (
    SELECT ...
)
SELECT * FROM cte_name;

· 支持窗口函数和通用表达式（主要用于OLAP场景）

窗口函数可以在一组查询行上执行类似于聚合的操作，主要用于OLAP场景，比如处理复杂的报表、统计分析等。相比传统的聚合函数，窗口函数不会修改原有语句的输出结果，而是直接添加新的聚合字段进行展现，可以在不分组的前提下对数据进行聚合计算

select name,sum(balance) from account_channel group by name;

#不再需要group by，聚合结果在每一行中展示
select name,channel,balance,sum(balance) over(partition by name) as sum_balance from account_channel;

除了上述亮点特性以外，还有以下更新：

· 在官方测评中 MySQL 8.0 性能峰值几乎是5.7的两倍

· 调整默认字符集为utf8mb4

· 使用新的密码认证插件caching_sha2_password（替代原本的mysql_native_password）（客户端需要升级驱动），支持更高的密码策略，即便相同的密码加密后的密文也是不同的

· 重构SQL分析器，增强优化器和CBO特性

· 支持使用shutdown命令直接关闭服务

· 错误日志增加了不同错误的错误编号，方便查询

· 并行复制writeset机制，提升从库复制性能

· 支持创建系统级别或者用户级别资源组以限制SQL对服务器资源的占用

· 新增计算列功能，比如C列的数据是通过A列和B列计算后产生

· 增加CREATE TABLE ... SELECT的原子性和crash safe支持，解决了MGR架构下无法使用的问题

· 角色role功能

· 可并行写入redo log，提升大量事务写入时的性能

· 可在线调整redo log buffer和undo log相关设置

· 可针对单个会话SET_VAR设置变量，提升灵活性

· 增加部分索引（条件索引）功能

二、升级8.0前的准备

1、先阅读官方What Is New In MySQL 8.0文档，关注被废弃的功能，避免配置文件中依然存在这些历史配置

2、需要考虑回滚方案

3、通过先升级从库的方式进行平稳过渡

4、升级前需要关注是否存在关键词兼容问题以及GROUP BY语句兼容问题，可以使用官方的检查工具

mysqlsh root:123456@192.168.1.101:3306 -e "util.checkForServerUpgrade();"

5、5.7版本支持直接升级8.0（5.6不支持），升级大版本前建议先把小版本升级到最新

6、建议升级方式采用逻辑备份+导入的方式

三、升级MySQL 8.0步骤

1、关闭当前MySQL

2、备份数据

3、使用新版本二进制包替换原版本

4、更改配置文件

5、启动服务，不需要mysql_upgrade，MySQL 8.0支持通过配置upgrade = AUTO参数来自动处理升级需要做的一切

【MySQL 8.0】MySQL5.7升级MySQL8.0的步骤与常见问题

Tue, 02 Dec 2025 09:08:13 +0800

一、为什么推荐将MySQL从5.7升级到8.0

MySQL5.7的生命周期已经在2023年10月结束，沿用老版本将存在以下问题：

· 所有漏洞不再修复，如自增ID回退问题

· 核心新特性无法使用，如秒级加列、在线持久化配置

· 生态衰退，如Xtrabackup等工具的使用

· 后期跨版本升级风险更大

二、升级过程中可能出现的问题

这里的问题都是实际升级过程中发生的，有代表意义

1、注释乱码问题

在升级过程中有部分表或字段的注释出现了乱码，原因无法追究，但是乱码会导致升级失败，所以需要先对这部分乱码内容进行修复

2、清理孤儿存储过程

在部分实例中发现有存储过程变为了孤儿存储过程（即存储过程所依赖的库表已不存在），这部分存储过程会导致升级失败。在正式升级前，需对存储过程进行梳理，清理无用的存储过程

#查看存储过程
SHOW PROCEDURE STATUS;

#删除无用的存储过程
DROP PROCEDURE your_database_name.your_procedure_name;

#部分存储过程无法直接通过SHOW命令查询，可以通过特殊方式删除
SELECT * FROM mysql.proc WHERE db = 'your_database_name';
DELETE FROM mysql.proc WHERE db = 'your_database_name' AND NAME = 'your_procedure_name';

3、用户认证插件选择问题

新版本数据库中默认的用户认证插件为caching_sha2_password，相比早期的mysql_native_password插件而言，有更强的安全性、更好的插件支持、更大的灵活性。

如果使用新的插件，需要对实例中所有用户的认证信息进行统一修改。如果为了兼顾老版本配置，可以通过修改数据库服务端配置，将认证插件指定为mysql_native_password（未来有弃用风险）

[mysqld]
default_authentication_plugin = mysql_native_password

4、row_format格式问题

MySQL 5.7和8.0的默认行格式都是Dynamic，而5.7之前是COMPACT，Dynamic和COMPACT在对于数据出现行溢出问题时处理策略不同。如果有库表的行格式使用到了MySQL早期的Compact格式，在进行升级前必须对这部分表字段格式先行调整为Dynamic。

#查看存储引擎默认的行格式
select @@innodb_default_raw_format; 

#查看表的行格式
show table status like 'table_name' \G 

#建表时指定行格式的语法
create table t1(in int,name varchar(10)) row_format=compact;

#修改表的行格式
alter table t1 row_format=dynamic;

5、数据库发行版不一致的问题

如果是跨发行版升级，比如从 Percona 5.7升级到 MySQL 官方发行版8.0，需要先将 Percona 5.7转换为官方版然后再进行升级操作

6、canal升级测试

如果有依赖Canal组件，需要注意Canal1.14对于mysql8的支持不够好，比如隐藏索引导致报错、新的binlog格式无法识别等问题，所以还需要对Canal进行升级

7、表名大小写问题

MySQL配置项 lower_case_table_names用于设置表文件名大小写存储规则。该值默认为0，表示在进行物理存储和查询时都区分大小写。在升级过程中需要注意之前实例的配置，如果有配置为1的（表示在进行物理存储和查询时自动将大写转换为小写），那么在进行升级的时候就必须要指定为1，因为8.0开始该值不能进行修改，需要在实例进行初始化时就指定好，或者统一代码写法，大小写不混用

8、NOT NULL字段插入NULL值

非空字段如果有定义默认值（如DEFAULT CURRENT_TIMESTAMP），在传值的时候应该使用 DEFAULT 或者省略这个字段，不能继续采用NULL来获取默认值。虽然在8.0版本可以通过数据库服务端配置来强行允许这个行为，但是官方已经明确未来会废弃该功能，如果继续沿用会在未来的升级中带来更大量的排查工作所以需要开发人员对这部分代码进行优化，后续新增代码不再使用NULL获取默认值的方式

#字段属性
`create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'

#插入语句
insert into t1(create_time) VALUES (NULL)

9、Unsupported conversion from DATETIME to java.lang.Long

部分老旧系统的代码存在将 DATETIME 类型数据转换为 Long 类型的情况，由于新版本JDBC驱动中不支持这种自动转换，所以需要对这部分代码进行优化，显式地进行日期/时间到时间戳的转换

10、驱动兼容问题

数据库升级后JDBC版本也需要进行统一升级，这也是最容易遇到的问题

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.33</version>
</dependency>

11、字符集默认排序规则问题

在MySQL8中，UTF8MB4使用的排序规则默认为utf8mb4_0900_ai_ci，而之前的版本中是utf8mb4_general_ci，为了兼容性可以通过配置文件指定为之前的排序规则

[mysqld]
character_set_server			= utf8mb4
collation_server            = utf8mb4_general_ci