docker介绍

在安装部署程序过程中存在的问题：

  1. 版本依赖

    • 典型案例：java环境有很多的jre版本

  2. 环境依赖

    • 典型案例：oracle安装需要大量支撑包

  3. 安全风险

    • 典型案例：多个应用无法安装一个服务器

  4. 性能瓶颈

    • 典型案例：硬件设备扩展困难

什么是虚拟化技术

在计算机技术中，虚拟化是一种资源管理技术，是将计算机的各种实体资源，如服务器，网络，内存以及存储等予以抽象转换后呈现出来，打破实体实体结构间不可切割的障碍，使用户可以用比原本的组态更好的方式来应用这些资源

docekr容器技术的发展

  • Docker是基于Go语言实现的开原容器项目它诞生于2013年年初.现在主流的操作系统包括引inux各大发行版本，Mac
    OS,windows等都支持Docker..各大云服务提供商也纷纷推出了基于Docker的服务
  • Docker的构想是要实现”Build ship and run any App,Anywhere‘“即通过对应用的封装(packaging),分发(distribution),部署(deploymen).运行(runtime)生命周期进行管理，达到应用组件级别的”一次封装，到处运行“的目的
  • 这些应用组件即可以是一个Wb应用，一个编译环境，也可以是套数据库平台服务，甚至是一个操作系统或集群.可以说Dockeri首次为应用的开发，运行和部署提供了”一站式”的实用解决方案

docker本质

Docker的诞生基于linux的容器技术(Linux Containers,LXC)

  • 容器将应用进行沙盒封装，进行隔离，并独立分配硬件资源。
  • 容器在核心CPU本地运行指令，不需要任何专门的解释机制.

Docker在LXC基础上，优化了容器的使用体验

  • Docker指令让用户无须关注底层操作，直接管理和使用容器
  • Dock通过引入分层文件系统和镜像机制，降低了迁移难度

docekr容器技术的优势

  1. 更快的交付和部署
  2. 更高效的资源利用
  3. 更轻松的迁移和扩展
  4. 良好的隔离性
  5. 完整的技术生态

docekr容器技术和VMware的比较

docker VMware
启动 秒级 分钟级
性能 接近宿主机 较弱
资源 资源占用小 资源占用大
隔离 安全隔离 完全隔离

docker扩展组件

  1. Docker Machine

    Docker Machine 是 Docker 官方提供的一个命令行工具，用于在远程虚拟主机上安装和管理 Docker。它简化了在不同平台（如虚拟机、云服务等）上部署 Docker 环境的流程，可以快速创建、管理多个虚拟主机上的 Docker 环境，提供了一种便捷的方式来搭建分布式的 Docker 部署环境。

  2. Docker Swarm

    DockerSwarm是Docker官方提供的容器编排工具，用于管理多个Docker主机并将它们组成一个虚拟的容器集群，实现容器的自动化部署、伸缩和管理。通过 Docker Swarm，用户可以轻松地在多个主机上部署容器应用，并在需要时进行扩展或收缩，实现高可用性和负载均衡。

  3. Docker Compose

    Docker Compose是Docker官方提供的工具，用于定义和运行多个容器的应用程序。通过一个简单的YAML文件，可以定义应用程序的服务、网络和卷等配置并使用命令启动、停止、构建和管理整个应用程序的容器。Docker Compose简化了容器化应用程序的部署和管理流程，使开发人员可以更快速地搭建和运行复杂的多容器应用。

  4. Docker File

    Dockerfile是用于构建Docker镜像的文本文件，通过Dockerfile可以定义镜像的构建过程和内容。在Dockerfile中可以指定基础镜像、运行命令、复制文件、设置环境变量等操作，最终通过构建命令将Dockerfile转换为可执行的Docker镜像。使用Dockerfile可以实现自动化、可重复的镜像构建过程，帮助开发人员快速、方便地创建定制化的镜像。

  5. kubernetes

    Kubernetes最初是由Google公司发起并开源的容器编排平台，用于自动部署、扩展和管理容器化应用程序。它提供了一个高度可扩展的集群管理工具，支持多个容器化应用程序的部署、更新、维护和伸缩。Kubernetes提供了强大的自动化功能，帮助用户简化容器化应用程序的部署和管理，提高应用程序的可靠性和可扩展性。

docker安装（CentOS）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld.service
#关闭selinux
vim /etc/selinux/config
# 将SELINUX=enforcing改为

#1.拷贝一份新的阿里云的 下载源 到 /etc/yum.repos.d/下 
mv /root/CentOS-Base.repo /etc/yum.repos.d/
#2.清空原下载池
sudo yum clean all
#3. 加载新源
sudo yum makecache

#安装工具包
yum install -y epel-release
#安装基础软件
yum install -y net-tools rsync vim wget ntp

yum install -y yum-utils device-mapper-persistent-data lvm2

#添加阿里yum源
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#安装docker
yum -y install docker-ce

#启动docker
systemctl enable --now docker

#查看状态
systemctl status docker

#查看本地镜像列表
docker images

#镜像加速
vim /etc/docker/daemon.json
#添加内容
{
  "registry-mirrors": [
    "https://dockerhub.icu",
    "https://docker.registry.cyou",
    "https://docker-cf.registry.cyou",
    "https://dockercf.jsdelivr.fyi",
    "https://docker.jsdelivr.fyi",
    "https://dockertest.jsdelivr.fyi",
    "https://mirror.aliyuncs.com",
    "https://dockerproxy.com",
    "https://mirror.baidubce.com",
    "https://docker.m.daocloud.io",
    "https://docker.nju.edu.cn",
    "https://docker.mirrors.sjtug.sjtu.edu.cn",
    "https://docker.mirrors.ustc.edu.cn",
    "https://mirror.iscas.ac.cn",
    "https://docker.rainbond.cc"
  ]
}
#使文件生效
sudo systemctl daemon-reload
sudo systemctl restart docker

#验证 docker 是否安装成功并在容器中执行一个测试的镜像。
sudo docker run hello-world

image-20250716110709919

从镜像仓库获取

1
2
3
4
5
6
docker pull redis #默认最新版本latest
docker pull mysql:5.7 #指定版本
docker pull tomcat:9.0.44-jdk8

docker rmi mysql:5.7 #删除镜像
docker rmi -f mysql:5.7 #强制删除

容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#查看容器列表
docker container ls -a

#1.创建容器
docker create  centos 

#2.创建并启动容器
docker run -d tomcat:9.0.44-jdk8

#3.生成容器常用参数
docker run --name mysql_new -d -p 3306:3306 \
--net mysql-test \
-v /usr/mysql/conf:/etc/my.cnf.d \ 
-v /usr/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
--restart always \
--privileged=true \
--network-alias mysql \
mysql:5.7

#1.进入容器命令
docker exec -it  mysql_new bash
docker attach mysql_new

#2.删除容器
docker container rm mysql_new

#3.启停容器
docker container start|stop|restart mysql_new
docker container pause|unpause mysql_new

#4.容器文件传输(拷出)
docker container cp mysql_new:/root/test /root/test

#5.导出容器
docker container export  -o /root/mysql.tar mysql_new

拉取 Tomcat 镜像并启动容器

1
2
3
4
5
6
7
8
9
10
yum install -y unzip
unzip webroot.zip #解压应用包

docker pull tomcat:9.0.44-jdk8 #之前已执行可略过

docker run -d \
--name=fr_tomcat \
-p 8888:8080 \
-v /root/webroot:/usr/local/tomcat/webapps/webroot \
tomcat:9.0.44-jdk8

image-20250716111050408

docekr使用

1.docekr image

镜像获取

1
2
3
4
5
6
7
8
9
10
#1.从镜像仓库获取
    docker image pull tomcat:9.0.44-jdk8
#2.从tar压缩包获取 
    docker image load  -i /root/oracle.tar
#3.从export导出包获取
    docker image import mysql_image.tar mysql:5.7
#4.从dockerFile 文件构建
    docker image build -t centos7:7 /root/Dockerfile
#5.从container容器转化
    docker commit mysqlmaster mysql_master:5.7

镜像操作

1
2
3
4
5
6
7
8
#1.保存迁移镜像
    docker image save  -o /root/tomcat.tar tomcat:9.0.44-jdk8
#2.删除镜像 
    docker image rm mysql:5.7
#3.删除无用镜像
    docker image prune
#4.上传镜像到仓库
    docker image push tomcat:9.0.44-jdk8

镜像查看

1
2
3
4
5
6
7
8
9
10
#1.查看镜像列表
    docker images ls
#2.显示一个或多个映像的详细信息 
    docker image inspect mysql:5.7
#3.到仓库检索镜像
    docker  search  mysql
#4.上传镜像到仓库
    docker image push tomcat:9.0.44-jdk8
#5.查看镜像历史
    docker image history mysql:5.7

镜像分层结构

image-20250714151231302

2.Docker container 容器

生成容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#1.创建容器
    docker create  centos  
#2.创建并启动容器 
    docker run -d tomcat:9.0.44-jdk8
#3.生成容器常用参数
docker run --name mysql_new -d -p 3306:3306 \
--net mysql-test \
-v /usr/mysql/conf:/etc/my.cnf.d \
-v /usr/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
--restart always \
--privileged=true \
--network-alias mysql \
mysql:5.7

容器操作

1
2
3
4
5
6
7
8
9
10
11
12
#1.进入容器命令
    docker exec -it  mysql_new bash
    docker attach mysql_new
#2.删除容器 
    docker container rm mysql_new
#3.启停容器
    docker container start|stop|restart mysql_new
    docker container pause|unpause mysql_new
#4.容器文件传输(拷出)
    docker container cp mysql_new:/root/test /root/test
#5.导出容器
    docker container export  -o /root/mysql.tar mysql_new

容器查看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#1.查看容器列表
    docker container ls -a
#2.查看容器详情 
    docker container inspect mysql_new
#3.查看容器执行日志
    docker container logs mysql_new
#4.查看容器进程
    docker container ps mysql_new
    docker container top mysql_new
#6.查看容器资源占用
    docker container stats
#5.查看docker 网络\卷
    docker network ls
    docker volume ls

docker network网络

docker端口

1
2
3
4
5
6
7
8
9
10
11
12
13
#1.随机暴露容器所有端口(危险)
    docker run -P -it ubuntu /bin/bash
#2.将容器指定端口随机映射到宿主机一个端口上 
    docker run -P 80 -it ubuntu /bin/bash
#3.将容器指定端口指定映射到宿主机的一个端口上
    docker run -p 8000:80 -it ubuntu /bin/bash
#4.将容器ip和端口，随机映射到宿主机上
    docker run -P 192.168.0.100::80 -it ubuntu /bin/bash
#5.将容器ip和端口，指定映射到宿主机上
    docker run -p 192.168.0.100:8000:80 -it ubuntu /bin/bash
#6.指定协议
    docker run -d -p 8080:80/tcp nginx

image-20250714151751936

docker网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#1.使用host网络
    docker container run --network=host nginx
#2.使用macvlan 网络 
  #创建:
    docker network create -d macvlan --subnet=192.168.10.0/24 \
--gateway=192.168.100.1  -o parent=ens33 mac1
  #使用:
    docker run --ip =192.168.100.2 --network mac1 nginx
#3.使用自定义桥接网络
  #创建:
    docker network create --driver bridge \
--subnet 192.168.10.0/24 --gateway 192.168.10.1 mybridge
  #使用:
    docker run --network=mybridge -d nginx

docker compose介绍以及应用

​ Docker Compose 是 Docker 官方推出的工具，用于定义和运行多容器 Docker 应用。通过单个 YAML 文件（通常命名为 docker-compose.yml），可以配置应用的服务、网络和卷，一键启动或停止整个应用栈，无需逐个操作容器。
Docker Compose 是管理多容器应用的必备工具，通过 YAML 配置简化部署流程，尤其适合开发和测试环境。对于生产环境，可结合 Kubernetes 等更强大的编排工具。

yaml文件编辑规范

  • 第一：YAML是一种标记性语言，类似于json数据描述语言，可读性高；　
  • 第二：YAML数据结构通过缩进来表示，连续项目通过减号表示，键值对用冒号分隔，数组使用中括号[]括起来，bash用花括号{}括起来；　
  • 第三：不支持制表符TAB缩进，只能使用空格缩进；
  • 第四：字符后缩进一个空格(如冒号、逗号、横杠后须加空格)；
  • 第五：使用#号表示注释；
  • 第六：如果包含特殊字符用单引号' ' 标记为普通字符,用双引号表示特殊字符本身的意思,布尔值必须使用双引号" "括起来；
  • 第七：YAML 区分大小写；

docker compose yaml文件指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
version：指定此yml文件基于的compose的版本
services：指定创建容器的服务选项
#服务名：例如nginx等
network: 网络服务创建
volume: 数据卷服务创建
hostname：容器主机名
build ：指定构建镜像上下文路径
context：上下文路径
dockerfile：指定构建镜像的 Dockerfile 文件名
ports：暴露容器端口，与-p相同，但端口不能低于60；例如：- 1234:80
networks：加入顶级networks下配置的网络
deploy：指定部署和运行服务相关配置，只能在Swarm模式使用
volumes：挂载宿主机路径或命令卷
image：指定容器运行的镜像
command：执行命令，覆盖默认命令
container_name：指定容器名称，由于容器名称是唯一的，如果指定自定义名称，则无法scale（扩展）
environment：添加环境变量
restart：重启策略，重启策略是no，always，no-failure，unless-stoped
		no，默认策略，在容器退出时不重启容器。
					on-failure，在容器非正常退出时（退出状态非0），才会重启容器。可加(:3) 规定重启次数
					always，在容器退出时总是重启容器。
		unless-stopped，在容器退出时总是重启容器
networks：配置网络，指定网卡设备等

compose命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#1.创建和启动服务
docker compose up

#2.删除和停止服务
docker compose down

#3.服务启动/停止/重启
docker compose start/stop/restart

#4.指定启动数量
docker compose up --scale master=2 --scale slave=2

#5.查看日志
docker compose logs [ -f 容器名称 --tail =50 ]

mysql主从部署

日志介绍

image-20250716105104999

binlog 日志、undo 日志、redo 日志、relay 日志的作用与区别：

在 MySQL 主从部署中，以下是几种关键日志的作用及区别：

binlog 日志（二进制日志）

  • 作用：记录数据库执行的变更（如 INSERT、UPDATE、DELETE 等），用于主从复制和数据恢复。
  • 主从复制中的角色：主库将 binlog 发送给从库，从库通过解析 binlog 来同步数据。
  • 特点：
    • 逻辑格式（记录 SQL 语句）或二进制格式（记录物理变更）。
    • 可通过log_bin参数启用，日志文件通常位于datadir目录下（如mysql-bin.xxxxxx）。

undo 日志（回滚日志）

  • 作用：记录事务执行前的数据状态，用于回滚未提交的事务或 MVCC（多版本并发控制）。
  • 主从复制中的角色：不直接参与复制，仅用于本地事务回滚。
  • 特点：
    • 保证事务的原子性（Atomicity）和一致性（Consistency）。
    • 存储在undo tablespace中，可通过innodb_undo_tablespaces参数配置。

redo 日志（重做日志）

  • 作用：记录事务对数据页的物理修改，用于崩溃恢复（保证已提交事务不丢失）。
  • 主从复制中的角色：不直接参与复制，确保主库数据持久化后才通知从库。
  • 特点：
    • 顺序写入，效率高，避免随机 IO。
    • 存储在ib_logfile*文件中，可通过innodb_log_files_in_group和innodb_log_file_size参数配置。

relay 日志（中继日志）

  • 作用：从库用于存储从主库接收的 binlog 事件，供 SQL 线程执行。
  • 主从复制中的角色：从库 IO 线程将主库的 binlog 写入 relay log，SQL 线程从中读取并执行。
  • 特点：
    • 临时存储，执行后可删除。
    • 文件通常位于datadir目录下（如relay-bin.xxxxxx），可通过relay_log参数指定路径。

主从复制流程中的协作

  1. 主库：执行事务 → 写入 binlog → 发送 binlog 到从库。
  2. 从库：
    • IO 线程接收 binlog → 写入 relay log。
    • SQL 线程读取 relay log → 执行 SQL 语句 → 更新数据。
    • 写入 redo/undo 日志保证本地事务的持久性和一致性。

总结对比

日志类型 用途 主从复制中的角色 存储位置
binlog 记录变更，用于复制和恢复 主库生成，从库同步 主库mysql-bin.*
undo 回滚事务，支持 MVCC 不参与复制 undo tablespace
redo 崩溃恢复，保证持久化 确保主库数据持久化 ib_logfile*
relay 临时存储主库 binlog，供从库执行 从库接收主库 binlog 后生成 从库relay-bin.*

合理配置这些日志对主从复制的性能和可靠性至关重要。例如，调整 binlog 格式（binlog_format）、redo 日志大小（innodb_log_file_size）等参数可优化复制效率。

部署

image-20250716105032843

docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
version: '2.27'
services:
  mysql_m:
    image: mysql:5.7
    container_name: mysql_m
    hostname: mysql_m
    ports:
      - 3336:3306
    networks:
      - mysql_net
    volumes:
      - ./my_m.conf:/etc/mysql/conf.d/my.cnf
      - mysql_m_volume:/var/lib/mysql
      - mysql_m_volume:/var/log/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=root 
  
  mysql_s:
    image: mysql:5.7
    container_name: mysql_s
    hostname: mysql_s
    ports:
      - 3337:3306
    networks:
      - mysql_net
    volumes:
      - ./my_s.conf:/etc/mysql/conf.d/my.cnf
      - mysql_s_volume:/var/lib/mysql
      - mysql_s_volume:/var/log/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=root 

networks:
  mysql_net:
    driver: bridge
    name: mysql_net
    ipam:
      driver: default
      config:
        - subnet: 192.168.100.0/24
          gateway: 192.168.100.1
volumes:
  mysql_m_volume:
    name: mysql_m_volume
  mysql_s_volume:
    name: mysql_s_volume

修改主服务配置文件：my_m.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[mysqld]
 #主服务器唯一ID
server_id=1
 #启用二进制日志
log-bin=mysql-bin
#上面两行最重要，下面的可以不配置# 设置不要复制的数据库(可设置多个)
binlog-ignore-db=mysql
binlog-ignore-db=information_schema
 #设置需要复制的数据库 需要复制的主数据库名字
binlog-do-db=test
 #设置logbin格式 Row、Statement、Mixed
binlog_format=STATEMENT
 # Disabling symbolic-links is recommended to prevent assorted security risks 关闭配置外存储
symbolic-links=0

修改从服务配置文件：my_s.conf

1
2
3
4
5
6
[mysqld]
server-id=2
relay-log=relay-bin #启用二进制日志
log-bin=mysql-bin #上面两行最重要，下面的可以不配置# 设置不要复制的数据库(可设置多个)
# read_only=1 #从服务器只读
slave-skip-errors= 1032,1062,1007,1050 #忽略报错

执行验证

1
2
3
4
5
6
7
8
9
10
cd mysql_service/
docker compose up -d

# 进入主机容器
docker exec -it mysql_m bash
# 登录mysql
mysql -uroot -proot

show master status;
# 出现以下内容说明my_m.conf、my_s.conf配置单已生效

image-20250716110119283

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 创建一个账号（用户名：worker 密码：root）
create user 'worker'@'%' identified by 'root';
# 给权限
grant replication slave,replication client on *.* to 'worker'@'%';
# 建库
create database test;

# 需要在执行以下配置前再查看一下状态（会变）
show master status;

# 新开一个终端窗口进入从机容器
docker exec -it mysql_s bash
# 登录mysql
mysql -uroot -proot

#5.登录从服务器配置执行
CHANGE MASTER TO MASTER_HOST='mysql_m',
MASTER_USER='worker',
MASTER_PASSWORD='root',
MASTER_PORT=3306, 
MASTER_LOG_FILE='mysql-bin.000001',MASTER_LOG_POS=778;

#起服务
start slave;
#查看状态
show slave status\G;

#从机建库不会同步，需要先手动建库
create database test;

#在主机test库中键一张表
use test;
create table test (id int);
show tables;

#在从机中验证，会同步创建该表
use test;
show tables;

#若之前同步失败，修正后可用以下命令重新同步
stop slave;
reset master;
start slave;

#查看状态
show slave status\G;

image-20250716110205604

redis

redis介绍

​ REmote DIctionary Server(Redis) 是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。

​ Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的 API。

​ Redis 通常被称为数据结构服务器，因为值（value）可以是字符串(String)、哈希(Hash)、列表(list)、集合(sets)和有序集合(sorted sets)等类型。

redis部署方案介绍

特性/配置 Redis 主从复制 Redis 哨兵 Redis 集群
主要目的 数据备份与读写分离 高可用性和故障自动切换 高并发和数据分散处理
架构 一个主节点和多个从节点 监控主从结构并自动切换 多个主节点，数据分片
数据复制 主节点到从节点 监控并管理主从复制 每个主节点管理自己的数据集
故障转移机制 手动或哨兵自动切换 自动故障转移 自动处理节点故障
可伸缩性 有限，依赖主节点 为主从结构增加高可用性 高，因为数据分布式处理
使用场景 数据备份和读扩展 关键应用的高可用性 大规模应用的高性能需求
设置复杂度 相对简单 中等，需配置哨兵 复杂，需规划数据分区

redis一主两从三哨兵部署方案

image-20250716191145724

部署

配置docker-compose.yaml文件

  1. 创建文件

    1
    2
    mkdir redis_service
    vim redis_service/docker-compose.yaml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    version: '3'
    services:
      redis1:
        image: redis
        container_name: redis1
        hostname: redis1
        ports:
          - 6379:6379
          - 16379:16379
        networks:
          - redis_net
        volumes:
          - ./redis1/conf:/etc/conf
          - ./redis1/data:/data
        command:
          redis-server /etc/conf/redis.conf
      redis2:
        image: redis
        container_name: redis2
        hostname: redis2
        ports:
          - 6380:6380
          - 16380:16380
        networks:
          - redis_net
        volumes:
          - ./redis2/conf:/etc/conf
          - ./redis2/data:/data
        command:
          redis-server /etc/conf/redis.conf
      redis3:
        image: redis
        container_name: redis3
        hostname: redis3
        ports:
          - 6381:6381
          - 16381:16381
        networks:
          - redis_net
        volumes:
          - ./redis3/conf:/etc/conf
          - ./redis3/data:/data
        command:
          redis-server /etc/conf/redis.conf

      sentinel1:
        image: redis
        container_name: sentinel1
        hostname: sentinel1
        ports:
          - 26379:26379
        networks:
          - redis_net
        volumes:
          - ./sentinel1/conf:/etc/conf
          - ./setinel1/data:/data
        command:
          redis-sentinel /etc/conf/sentinel.conf


      sentinel2:
        image: redis
        container_name: sentinel2
        hostname: sentinel2
        ports:
          - 26380:26379
        networks:
          - redis_net
        volumes:
          - ./sentinel2/conf:/etc/conf
          - ./setinel2/data:/data
        command:
          redis-sentinel /etc/conf/sentinel.conf

      sentinel3:
        image: redis
        container_name: sentinel3
        hostname: sentinel3
        ports:
          - 26381:26379
        networks:
          - redis_net
        volumes:
          - ./sentinel3/conf:/etc/conf
          - ./setinel3/data:/data
        command:
          redis-sentinel /etc/conf/sentinel.conf


    networks:
      redis_net:
        name: redis_net
        driver: bridge

  2. 查看是否创建成功

    1
    2
    cd /redis_service
    docker compose up -d

redis_master配置文件

配置文件名redis.conf，在redis1/conf/redis.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
databases 10 
bind 0.0.0.0
#监听 
port 6379
#访问密码 
requirepass 123456
masterauth 123456
#持久化文件路径
dir /data 
#持久化文件
dbfilename dump.rdb
#启用 RDB 持久化文件的压缩
rdbcompression yes
#如果后台保存出错则停止写入
stop-writes-on-bgsave-error yes
#关闭保护模式
protected-mode no
#在空数据库时进行无盘复制加载
repl-diskless-load on-empty-db
#守护进程的方式运行
#daemonize yes


#持久化策略
#表示如果在 900 秒（15 分钟）内有至少 1 次数据修改操作，则执行一次 RDB 持久化。
save 900 1 
#在 300 秒（5 分钟）内有至少 10 次数据修改操作，就执行一次 RDB 持久化。
save 300 10     
save 60 10000

#日志
logfile redis.log

redis_slave配置文件

redis2和redis3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#实例化数据库
databases 10
bind 0.0.0.0 
#监听
port 6380
#访问密码和主机密码
requirepass 123456
masterauth 123456
#持久化文件路径
dir /data 
#持久化文件
dbfilename dump.rdb
#指定本地数据存储压缩
rdbcompression yes
stop-writes-on-bgsave-error yes
protected-mode no
repl-diskless-load on-empty-db
#daemonize yes
#protected-mode

#持久化策略
save 900 1
save 300 10
save 60 10000
#日志路径
logfile redis.log
replicaof redis1 6379

sentinel配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#vim /usr/local/redis/etc/sentinel.conf
 #操作端口
 #绑定所有网络接口
bind 0.0.0.0
#哨兵服务监听的端口。
port 26379
#指定进程 ID 文件的路径
pidfile "/data/redis-sentinel.pid"
#工作目录
dir "/tmp" 
#设置访问哨兵的密码
requirepass 123456
#docker必关 不以后台进程方式运行
daemonize no 
#关闭保护模式
protected-mode no 
#指定日志文件路径
logfile "/data/redis-sentinel.log"
#启用主机名解析
sentinel resolve-hostnames yes
#监控名为redisMaster的主节点，节点名为redis1，端口为 6379，需要至少 2 个哨兵
sentinel monitor redisMaster redis1 6379 2
#该主节点的认证密码
sentinel auth-pass redisMaster 123456
#在指定毫秒数后认为该主节点主观下线。
sentinel down-after-milliseconds redisMaster 100 
#故障转移时同时同步的从节点数量为 1 个
sentinel parallel-syncs redisMaster 1
#故障转移超时时间
sentinel failover-timeout redisMaster 600

验证

1
2
3
cd redis_service
docker compose down 
docker compose up -d

image-20250716193050241

1
docker container ls

image-20250716194121868

  1. 查看从机
1
2
3
4
[root@CentOS7 ~]# docker exec -it redis1 redis-cli -p 6379
127.0.0.1:6380> auth 123456
OK
127.0.0.1:6380> info

image-20250716194621403

  1. 查看从机
1
2
3
4
[root@CentOS7 ~]# docker exec -it redis2 redis-cli -p 6380
127.0.0.1:6380> auth 123456
OK
127.0.0.1:6380> info

image-20250716195916911

  1. 查看哨兵
1
2
3
4
5
6
[root@CentOS7 redis_service]# docker exec -it sentinel1 redis-cli -p 26379 
127.0.0.1:26379> info
NOAUTH Authentication required.
127.0.0.1:26379> auth 123456
OK
127.0.0.1:26379> info

image-20250716195114095

  1. 人为停掉一个redis
1
2
3
4
5
6
7
8
docker container redis1 stop
# 再次查看哨兵
[root@CentOS7 redis_service]# docker exec -it sentinel1 redis-cli -p 26379 
127.0.0.1:26379> info
NOAUTH Authentication required.
127.0.0.1:26379> auth 123456
OK
127.0.0.1:26379> info

image-20250716200102571

kubernetes介绍以及应用

  • Kubernetes（简称k8s）是一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用。

  • 它的核心功能包括自动化容器部署、负载均衡、自我修复、存储编排以及跨集群资源管理。

  • 通过Kubernetes，企业能够高效管理大规模的容器化应用，确保应用的高可用性和弹性扩展。

核心功能：

  1. 自动调度：将容器放到K8S集群的任意节点中，并根据容器需要和节点负载决定目标节点。
  2. 自动修复：当健康检查发现节点问题，系统会自动将节点上的资源进行转移，并恢复功能。
  3. 自动缩扩容：通过预定义负载指标，根据指标自动触发动态缩扩容行为。

架构

Master

Master为控制节点，负责整个集群的管理控制。

Master节点由：APIserver、ETCD 、controller Manager、schedule等组件构成。

Node

Node的作用是承接工作负载。

Node节点有由：kubelet、rumtime、kube-proxy组成。

image-20250717202918467

客户端：Kubectl、UI：负责给API-Server发送指令。

API-Server：接受指令，K8s集群的核心，是集群的API入口。它负责处理来自各种客户端的REST API请求资源并对其进行验证、授权，并将有效的请求持久化到etcd数据库。

ETCD：分布式键值存储系统，用于保存Kubernetes集群的所有配置数据和状态信息。它存储了集群中的各种资源对象的元数据。

Scheduler：负责将未调度的Pods分配到合适的Node节点上运行。它根据一系列的调度算法和策略来进行决策。

Controller-Manager、controller：运行着一系列的控制器，这些控制器负责维护集群的状态。Controller-Manager负责容器数量。controller保证运行状态。

Kubelet：负责与kube-api通信，获取节点的Pods的信息,管理其生命周期,并按照Pod的定义创建、启停监控容器的运行状态等。并将状态上报给controller。

Kube-proxy：主要负责实现K8s Service的网络代理功能.它在每个Node节点上运行，维护网络规则，将对Service的请求转发到对应的Pod上。

RunTime：负责k8s中的资源隔离,确保每个容器有独立的网络,文件系统,进程空间从而避免相互干扰。

Pod：Pod是最小的可部署和可管理的计算单元。容器在同一主机上可以相互通信。多个容器封装成一个Pod，一般一个容器只放一个应用，为了让服务高可用，需要多个容器，满足使用需求，所以用Pod

打包多个容器统一管理。

Container：用于将应用程序以及所有依赖打包在一起,确保所有程序运行环境相同。

资源

Namespace

工作负载类：负责接受客户访问请求，返回客户需要的数据

Pod、Deployment、ReplicaSet、StatefulSet、DaemonSet、Job、CronJob

网络类

Service、Ingress、NetworkPolicy

储存类

Volume、PersistentVolume (PV)、Persistent VolumeClaim (PVC)

配置类

ConfigMap、Secret

安全类
扩展类
自动缩扩容类
层级关系

image-20250717203132808

pod：最小的部署单元，包含一个或多个容器。

Deployment：管理Pod的副本和滚动更新策略。

replicaSet：确保指定数量的Pod副本运行（Deployment的底层实现）。

DaemonSet：管理有状态应用的Pod，提供有序部署和唯一网络标识。

StatefulSet：确保每个节点运行一个Pod的副本。

Service：为Pod提供稳定的网络访问（如负载均衡、服务发现）

Ingress：管理外部访问集群内服务的路由规则（如 HTTP/HTTPS 路由）。

Secret：存储敏感数据（如密码、Token），以 Base64 编码存储非敏感的配置数据（如环境变量、配置文件）。

Job/CronJob：运行一次性任务，任务完成后 Pod 终止定时运行的 Job。

PV：集群中的持久化存储资源。

PVC：用户对存储资源的请求声明，绑定到 PV。

kubernetes-集群信息查看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
kubectl get pods # 查看所有 Pod

kubectl get deployments # 查看所有 Deployment

kubectl get services # 查看所有 Service

kubectl get pvc # 查看所有 PVC

kubectl get nodes # 查看所有 Node

kubectl get namespaces # 查看所有命名空间

kubectl get configmap <name> -o yaml # 查看 ConfigMap 内容

kubectl logs <pod-name>	# 查看 Pod 日志

kubernetes-资源创建命

1
2
3
4
5
6
7
8
9
10
11
12
#1. 创建 Pod
kubectl create deployment my-pod --image=nginx
#2. 创建 Deployment
kubectl create deployment my-deployment --image=nginx --replicas=3
#3. 创建 Service
kubectl create service clusterip my-service --tcp=80:8080
#4. 创建 ConfigMap
kubectl create configmap my-config --from-literal=key1=value1 --from-literal=key2=value2
#5. 创建 Secret
kubectl create secret generic my-secret --from-literal=username=admin --from-literal=password=secret
#6. 创建 Namespace
kubectl create namespace my-namespace

kubernetes-Pod信息查看

1
2
3
4
5
6
7
8
9
10
1. 列出特定命名空间中的 pod：
kubectl get pods -n <namespace>
2. 查看一个 Pod 详情：
kubectl describe pod <pod-name> -n <namespace>
3. 查看 Pod 日志：
kubectl logs <pod-name> -n <namespace>
4. 尾部 Pod 日志：
kubectl logs -f <pod-name> -n <namespace>
5. 在 pod 中执行命令：
kubectl exec -it <pod-name> -n <namespace> -- <command>

kubernetes-deploymen信息

1
2
3
4
1. 列出命名空间中的所有Deployment：kubectl get deployments -n <namespace>
2. 查看一个Deployment详情：kubectl describe deployment <deployment-name> -n <namespace>
3. 查看滚动发布状态：kubectl rollout status deployment/<deployment-name> -n <namespace>
4. 查看滚动发布历史记录：kubectl rollout history deployment/<deployment-name> -n <namespace>

kubernetes-label指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 给名为foo的Pod添加label unhealthy=true
$ kubectl label pods foo unhealthy=true

# 给名为foo的Pod修改label 为 'status' value 'unhealthy'，且覆盖现有的value
$ kubectl label --overwrite pods foo status=unhealthy

# 给 namespace 中的所有 pod 添加 label
$ kubectl label  pods --all status=unhealthy

# 仅当resource-version=1时才更新 名为foo的Pod上的label
$ kubectl label pods foo status=unhealthy --resource-version=1

# 删除名为“bar”的label 。（使用“ - ”减号相连）
$ kubectl label pods foo bar-

kubernetes-基础指令

create，delete，get，run，expose，set，explain，edit

1
2
3
4
5
6
7
8
9
10
11
# 创建Deployment和Service资源
$ kubectl create -f demo-deployment.yaml
$ kubectl create -f demo-service.yaml

# 根据yaml文件删除对应的资源，但是yaml文件并不会被删除，这样更加高效
$ kubectl delete -f demo-deployment.yaml 
$ kubectl delete -f demo-service.yaml

# 也可以通过具体的资源名称来进行删除，使用这个删除资源，同时删除deployment和service资源
$ kubectl delete 具体的资源名称

kubernetes-基础指令

https://kubernetes.io/zh-cn/docs/reference/kubectl/quick-reference/

1
2
3
4
5
6
7
8
9
10
# 创建Deployment和Service资源
$ kubectl create -f demo-deployment.yaml
$ kubectl create -f demo-service.yaml

# 根据yaml文件删除对应的资源，但是yaml文件并不会被删除，这样更加高效
$ kubectl delete -f demo-deployment.yaml 
$ kubectl delete -f demo-service.yaml

# 也可以通过具体的资源名称来进行删除，使用这个删除资源，同时删除deployment和service资源
$ kubectl delete 具体的资源名称

Nginx反向代理

代理服务器

image-20250717203940718

代理服务器功能

1.隐藏客户端身份： 正向代理可以隐藏客户端的真实IP地址，保护客户端的隐私。

2.访问控制： 正向代理可以根据一定的规则限制或允许客户端的访问请求，实现访问控制功能。

3.缓存加速： 正向代理可以缓存经常访问的页面或资源，提高访问速度，减轻服务器负担。

目的

1.突破网络限制

2.监控和管理员工的网络访问行为

3.隐藏客户端真实IP

4.防止敏感数据泄露

5.内容过滤

6.提高访问速度

反向代理

image-20250717204042655

作用

1.负载均衡： 反向代理可以根据后端服务器的负载情况，将请求分发到不同的服务器上，提高系统的整体性能。

2.安全性增强：隐藏后端服务器的真实地址和端口，防止直接攻击。同时，还可以实现SSL加密、访问控制等安全功能。

3.缓存优化：可以缓存静态资源，减少后端服务器的负载，提高响应速度。