docker 部署教学版本

文章目录

  • 一、docker使用场景及常用命令
    • 1)docker使用场景
    • 2)rocky8+(centos8+)安装 docker
    • 3)docker 常用命令
    • 补充常用命令
  • 二、 单独部署每个镜像,部署spring 应用
    • 镜像推荐(2023-12-18)
    • 1、 安装使用 mysql
      • 1.1 创建挂在需要的目录和文件
        • 1)创建目录并授权
        • 2)新建mysql配置文件-注意启动小写允许:
      • 1.2 启动mysql镜像
        • 1)启动镜像
        • 2)查看日志
      • 1.3 防火墙开启允许访问
      • 1.4 测试远程连接
      • 1.5 导入数据
      • 补充:若需要修改镜像配置(非操作步骤,略)
        • 1、进入镜像
        • 2、修改密码
    • 2、 安装使用 redis
      • 2.1 创建目录
      • 2.2 创建文件
      • 2.3 启动redis 容器
      • 2.4 测试redis 容器
    • 3、 安装rabbitmq
      • 3.1 创建rabbitmq相关挂载目录
      • 3.2 授权
      • 3.3 启动rabbitmq
      • 3.4 防火墙开启允许访问
      • 3.5 测试是否启动
    • 4、 安装nginx
      • 4.1 首先:参考教程创建临时nginx 容器,并将容器内的配置文件拷贝出来
      • 4.2 修改nginx的配置
      • 4.3 启动nginx镜像
    • 5、 jar打包docker 镜像
      • 5.1 新建配置文件:将所有127.0.0.1换成机器的ip
      • 5.2 在linux 新建打包路径,将打包jar上传此路径:
      • 5.3 在目录下新建DockerFile,内容如下:
      • 5.4 打包镜像
      • 5.5 启动镜像
      • 5.6 查看日志
  • 三、使用Docker虚拟网络,解决部署时,springboot 配置文件不一致
    • 1、容器的网络
    • 2、改造网路:使用自定义网路
      • 2.1 创建虚拟网络
      • 2.2 启动的 mysql 添加虚拟网络
      • 2.3 启动的 redis 添加虚拟网络
      • 2.4 启动的 reabbit 添加虚拟网络
      • 2.5 修改 nginx 配置文件,重启,并添加虚拟网络
      • 2.6 修改应用链接中间件为:中间件虚拟网络别名,重新打包jar
  • 四、docker-compose 快速单机部署
    • 1、 新建docker-compose.yaml 文件
    • 2、将 docker-compose.yaml 上传至之前上传的jar包的文件路径
    • 3、启动并排查启动情况
      • 3.1 创建 docker-compose.yaml 文件中的容器
      • 3.2 查看整体启动情况
      • 3.3 查看异常容器状态的日志(上面 ps 命令中status 显示异常的)
      • 3.4 移除 docker-compose.yaml 文件的容器
  • 五、docker 镜像合并(测试失败)
    • 测试结果
  • 六、docker镜像与容器的导入导出
    • 1 镜像导出
    • 2 镜像导入
    • 3 容器导出
    • 4 容器导入
    • 5 实例化并启动容器
  • 七、docker 跨机器网络通信
    • 方案
    • 1、简单测试
  • 八、docker 共享存储
  • 九、docker 未列明知识

一、docker使用场景及常用命令

1)docker使用场景

注:

1)docker 好在容器编排和部署于机器无关,并不是性能;因其虚拟网络和容器化环境,其性能能砍到1/4~1/2;
例如:不建议在 Docker 中跑 MySQL(其中关于性能损耗部分是有参考性,其他部署描述有错误)
https://www.zhihu.com/question/627105598/answer/3261151560

2)目前(2023-12-22)redis+消息队列+jar可能5000/qps,放在docker 闭眼盲猜1000/qps

3)docker企业版本是支持大型机;以前在大型机操作系统上虚拟操作系统,现在在其上虚拟容器;
,所有真实并发在专业机器上性能有待考证(专业资料不好找):
https://developer.aliyun.com/article/193973

4)所以docker适用于中大型企业负载均衡管理应用(或者一定的降低部署难度),不适合小企业;且应用负载均衡节点数大于5;

2)rocky8+(centos8+)安装 docker

教程: https://doracoin.cc/504

注:dnf替代yum是早晚的事,所以就不找低版本教程了

3)docker 常用命令

注:镜像:存放在本地或远程仓库的docker打包文件叫镜像,仓库:集中存放和管理镜像的地方;
容器:镜像启动后生成的虚拟容器(含成功和失败的)

列出本地镜像:docker image ls
查找mysql镜像:docker search mysql
拉取镜像 mysql镜像:docker pull mysql:8.2.0
删除镜像:docker rmi -f mysql:8.2.0

查找镜像版本:1、命令查找:命令特别长,2、官网查找(推荐):hub.docker.com;3)或者百度镜像版本号

查看本机存在的容器:docker ps (运行的)或docker ps -a (全部的,含停止运行的)
查看镜像日志(正在运行的,含状态异常) docker logs -f 镜像名

启动容器:docker run --name 容器别名 -d 镜像:版本号

重启容器:docker restart 容器别名
停止容器:docker stop 容器别名
删除容器:docker rm -f 容器别名

进入镜像内
docker exec -it 容器别名 /bin/bash
退出:exit;

补充常用命令

$  docker stop $(docker ps -a -q) : 停止所有容器
$  docker start $(docker ps -a -q) : 启动所有容器
$  docker rm -f $(docker ps -a -q) : 删除所有容器

$ docker ps :列出当前所有正在运行的container
$ docker ps -a :列出所有的container(包含历史,即运行过的container)
$ docker kill id    : 杀死容器
$ docker stop id    : 停止容器

$ docker start id   : 启动容器
$ docker restart id : 重启容器

$ docker rmi -f  : 删除一个或多个镜像 image
$ docker rm -f  id   :  删除指定 镜像 image
$ docker rm -f    :  删除一个或多个container
$ docker rm  -f `docker ps -a -q`   : 删除所有的container
$ docker rm `docker ps -f "status=exited" -q`  : 删除停止的容器
$ docker kill`docker ps -a -q` :停止所有container
$ docker exec -it ng /bin/bash  :进入容器
$ docker cp ng:/etc/nginx/nginx.conf /data/nginx.conf   :拷贝容器内文件到外部
$ docker logs -f 容器名称 :查看容器日志

全命令补充,菜鸟:https://www.runoob.com/docker/docker-command-manual.html
(2019年后未更新,学的快):http://www.zhaowenyu.com/docker/dockerbackground/docker-history.html

二、 单独部署每个镜像,部署spring 应用

镜像推荐(2023-12-18)

# 1、mysql(最新镜像 2023-12-15):8.2.0 ,下载镜像:
docker pull mysql:8.2.0
# 2、redis(最新镜像 2023-12-15):7.2.3 ,下载镜像:
docker pull redis:7.2.3
# 3、rabbitmq(最新镜像 2023-12-15:3.13.0-rc),下载镜像:
# 不带控制台的镜像
docker pull rabbitmq:3.12.10
# management带控制台的镜像
docker pull rabbitmq:3.12.10-management

# 4、jdk(最新镜像 2023-12-15:openjdk:21),下载镜像(项目使用):
docker pull openjdk:17

# 5、nginx(最新镜像 2023-12-15:1.25.3),下载镜像:
docker pull nginx:1.25.3

注:1)若镜像拉去速度慢,可注册阿里云账号,用自己的阿里云镜像仓库拉去镜像(目前:2023-12-22 阿里镜像仓库免费-镜像空间)
2)mysql、redis、消息队列等高io应用,对应实体机一般要配置优化(例如:打开文件句柄数);高并发下,其实不建议容器部署(非专业硬件,例如:专门虚拟化机器,也有适配容器的 jvm: 9j);且mysql、redis、消息队列等高io应用,这些也属于分布式应用中的有主服务;
3)目前(2023-12-22) jvm: 9j 配置麻烦(ibm掺和了),且未做并发压测(jmeter压测),所以本教程采用常规方案-openjdk;
4)若拉取镜像报禁止,设置DNS为8.8.8.8(谷歌免费提供的DNS服务);拉取超时,则设置国内镜像源:https://developer.aliyun.com/article/1044251

1、 安装使用 mysql

1.1 创建挂在需要的目录和文件

1)创建目录并授权
mkdir -p /data/mysql8
chmod 777 /data/mysql8
2)新建mysql配置文件-注意启动小写允许:
touch /data/mysql8/my.conf

my.conf文件内容

注:该配置未优化,优化见(含:内存:32g linux和64 g windows mysql的配置):
https://blog.csdn.net/qq_26408545/article/details/124114793

[mysql]
#设置mysql客户端默认字符集
default-character-set=UTF8MB4
[mysqld]
#linux 需配置,忽略表名大小写
lower_case_table_names=1
#设置3306端口
port=3306
#允许最大连接数
max_connections=200
#允许连接失败的次数
max_connect_errors=10
#使用“caching_sha2_password”插件认证
default_authentication_plugin=caching_sha2_password
#服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=UTF8MB4
#开启查询缓存
explicit_defaults_for_timestamp=true
#创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
#等待超时时间秒
wait_timeout=60
#交互式连接超时时间秒
interactive-timeout=600
#binlog日志保留10天的
binlog_expire_logs_seconds=864000

1.2 启动mysql镜像

1)启动镜像

注:mysql镜像日志未挂在出来:日志默认输出到docker镜像的控制台,查看日志用 docker logs -f mysql8

踩坑:运行镜像:可添加参数运行远程访问

# 研究镜像日志默认输出为终端log_error = stderr
# 即 -v /data/mysql8/mysqld.log:/var/log/mysqld.log 无意义,所以就未独立日志

docker run --name mysql8\
  -p 3308:3306 \
  -v /data/mysql8/my.cnf:/etc/my.cnf \
  -v /data/mysql8/data:/var/lib/mysql \
  -e TZ=Asia/Shanghai \
  -e MYSQL_DATABASE=hy_cost_grain \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -e MYSQL_ROOT_HOST='%' \
  --restart=always \
  --privileged=true \
  -d mysql:8.2.0

补充启动参数:-e 参数=值

# 数据库时区
TZ: Asia/Shanghai

# 开启远程访问
MYSQL_ROOT_HOST: '%'

# 等同于 -e MYSQL_ROOT_PASSWORD指定root的登录密码
MYSQL_ROOT_PASSWORD: 123456
#- MYSQL_ROOT_PASSWORD=123456a?
#- MYSQL_ALLOW_EMPTY_PASSWORD='no'

# 这里这个指令compose启动成功后会自动创建名为docker的数据库
MYSQL_DATABASE: hy_cost_grain
#- MYSQL_DATABASE='ecdb02'

# 此处就是相当于 mysql create user,创建了数据库的登录用户
#- MYSQL_USER='ecuser'
#- MYSQL_PASSWORD='123456a?'
2)查看日志
docker logs -f mysql8

注:若有问题:

#查看容器运行情况
docker ps
# 停止
docker stop mysql8
# 删除
docker rm -f mysql8
# 重启
docker restart mysql8

# 产看端口占用
nestat -ntlp | grep 占用端口号

1.3 防火墙开启允许访问

firewall-cmd --zone=public --add-port=3306/tcp --permanent
firewall-cmd --reload

# 注:如果用的是阿里云的话,也需要配置 阿里云控制台防火墙

1.4 测试远程连接

工具链接数据库,操作:略

1.5 导入数据

操作:略
dbeaver导入数据:数据库右击->选择恢复数据->弹窗中 额外的命令参数添加:–default-character-set=utf8

补充:若需要修改镜像配置(非操作步骤,略)

例如:假设需要开启mysql远程访问
注:启动mysql镜像时,已开启允许远程访问,本操作仅是知识补充

1、进入镜像
docker exec -it mysql8 /bin/bash
2、修改密码

进入镜像:像正常linux操作即可
注:很多镜像只含基础命令,例如vim,ll等不存在,可自己安装:一般采用rpm源码包安装(保证容器体积不至于太大)

# 本机访问mysql:mysql -u账户 -p密码
mysql -uroot -p123456
#切换数据库
use mysql;
#开启远程访问
alter user 'root'@'%' identified with caching_sha2_password by '123456';
#刷新权限
flush privileges;
#退出mysql命令窗口
quit; 或者 exit;
#退出容器
exit;

2、 安装使用 redis

注:

1)redis号称单机20w/qps,固一般保证并发,实体机器+本机和机器配置优化+(条件可以:再建个哨兵保证高可用)
2)性能评估按照10w/qps用;redis6 有多线程参数-启用相关参数是真的能到
3)硬件:多核4~16核 8~16g内存 或者 低配3台 4核8g内存的哨兵(低配:rdb文件-不建议超过4g,高配rdb建议超过:7g,高配更好-事少(16核16g也是其顶配了);
4)应用链接池lettuce,其他的连接池各种崩溃,例如:jedis-操作接口简单、redission-分布式限流等解决方案;

2.1 创建目录

mkdir -p /data/redis/data
mkdir -p /data/redis/logs

2.2 创建文件

touch /data/redis/redis.conf

redis.conf 文件内容如下

注:redis 具体的优化看此篇文章中的优化部分:https://blog.csdn.net/qq_26408545/article/details/132696788

#暂不设置密码,启动容器也可设置密码
#requirepass 123
maxclients 10000

#如果要外网访问,请注释掉下面,或者修改为0.0.0.0,保险起见,也可以把protected-mode设置为no
bind 0.0.0.0
protected-mode no

#注意修改这里端口,根据你实际暴露端口情况配置
port 6379

tcp-backlog 511
timeout 0
tcp-keepalive 300

#注意这里要把后台运行设置为no,避免docker后台运行冲突
daemonize no

supervised no
pidfile /docker/redis/redis.pid
loglevel notice

databases 16

always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb

#注意修改这里的目录为容器内目录,默认reids进来是在/data/目录
dir /data/redis/data

#日志输入指定路径
#logfile ""

replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no

#注意修改这里的配置,yes开启持久化,no关闭持久化
appendonly yes

appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

2.3 启动redis 容器

注:redis 和数据库一样吃内存,他多的时候甚至占12G,redisDb文件在
配置了日志未映射出来,所以放弃了

# 日志配置放弃: -v /data/redis/logs:/data/redis/logs \
docker run \
--restart=always \
--log-opt max-size=100m \
--log-opt max-file=2 \
-p 6379:6379 \
--name redis7 \
-v /data/redis/conf/redis.conf:/etc/redis/redis.conf  \
-v /data/redis/data:/data/redis/data \
-d redis:7.2.3 redis-server /etc/redis/redis.conf \
--appendonly yes \
--requirepass '' 

2.4 测试redis 容器

略 Another-Redis-Desktop-Manager 链接看一下

3、 安装rabbitmq

注:1)rabbitmq-金融领域消息队列:(2023-12-22)单机优化配置的 性能 1w/qps;其它号称10w/qps的消息队列,一般给数据中心传递数据用,不用做应用领域;当时集群怕问题,就1个应用对应1个队列;(并发大)
2)消息队列堆积100w后各种问题,磁盘占用100G,所以部署应用+队列:50G+200G挂载盘+独立文件服务:8核+16G;有台单独处理任务的windows server(部署含队列中间件) 16核+32G(定时处理各种数据的 + 一些手工处理数据的 + 一些处理特殊任务的)
3)应用的rabbitmq链接池配置,要压测通过,加参数保证高并发,连接池不崩溃;
4)没系统研究过,配置优化不知道。网传(opp、vivo、小米:其中的2家)-迁移它的环境很麻烦,只能停机等消费完,且迁移步骤麻烦;

3.1 创建rabbitmq相关挂载目录

mkdir -p /data/rabbitmq/{data,conf,log}

3.2 授权

chmod -R 777 /data/rabbitmq 

3.3 启动rabbitmq

注:启动命令,未挂在配置目录 -v /data/rabbitmq/conf:/etc/rabbitmq

网上未找到专业的关于rabbitmq配置优化(且配置空,无法启动控制台)

docker run -d  --privileged=true --name rabbitmq3.12.10 \
--hostname localhost \
-e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=12345678 \
-v /rabbitmq/data:/var/lib/rabbitmq \
-v /data/rabbitmq/log:/var/log/rabbitmq \
-v /docker-work/rabbitmq/conf:/etc/rabbitmq \
-p 5672:5672 -p 15672:15672 \
-d rabbitmq:3.12.10-management

参数说明:
–restart=always :表示随着Docker容器重启(~~可加可不加~~ )
--hostname :主机名 (~~可加可不加~~ ) rabbitmq节点名称
-e :指定环境变量 RABBITMQ_DEFAULT_VHOST:默认虚拟机名;
-e :RABBITMQ_DEFAULT_USER:默认的用户名;
-e :RABBITMQ_DEFAULT_PASS:默认用户名的密码,rabbitmq默认账号和密码是guest
-p :端口映射
-v :文件挂载
-d :表示后台运行
–name rabbitmq :表示启动后的容器实例名称为rabbitmq

3.4 防火墙开启允许访问

firewall-cmd --zone=public --add-port=5672/tcp --permanent
firewall-cmd --zone=public --add-port=15672/tcp --permanent
firewall-cmd --reload

# 注:如果用的是阿里云的话,顺便开放下这两个端口,不然没法访问

3.5 测试是否启动

netstat -ntlp|grep 5672
浏览器访问:http://IP:15672/

4、 安装nginx

注:(2023-12-22)我们当时压测1w/qps就各种问题,理论2w/qps;号称10w/qps这货;尴尬的是(jdk15+,16核32g,优化参数的tomcat)单个jar可达到5000~7000/qps;不过nginx是占用内存小,但cpu耗用高,优化其多线程参数;因没能力优化-就外采的一个负载均衡中间件(基于nginx的);

4.1 首先:参考教程创建临时nginx 容器,并将容器内的配置文件拷贝出来

仅参考教程前半部分生成配置文件,文档也付相关配置和目录
教程:https://blog.csdn.net/longzaizai_/article/details/130675135

#nginx配置文件2个,日志目录2个文件,html容器路径映射出来
docker cp nginx01:/etc/nginx/nginx.conf /data/nginx/
docker cp nginx01:/etc/nginx/conf.d /data/nginx/conf/
docker cp nginx01:/usr/share/nginx/html /data/nginx/html
docker cp nginx01:/var/log/nginx/ /data/nginx/logs/

4.2 修改nginx的配置

注:html的路径实在容器下:所以开头:/usr/share/nginx/html/

** 网络要用主机ip,因为localhost 是指向容器 **

# 省去不必要的配置代码
server {
    listen       80; # 本服务监听的端口号
    server_name  localhost; # 主机名称

    client_max_body_size 600m;
    client_body_buffer_size 128k;
    proxy_connect_timeout 600;
    proxy_read_timeout 600;
    proxy_send_timeout 600;
    proxy_buffer_size 64k;
    proxy_buffers   4 32k;
    proxy_busy_buffers_size 64k;
    proxy_temp_file_write_size 64k;

    location / {
        # root 规定了通过监听的端口号访问的文件目录
        root   /usr/share/nginx/html/grain/dist;
        # 配置资源重新跳转,防止刷新后页面丢失
        try_files $uri $uri/  /index.html;
        # index 规定了该目录下指定哪个文件
        index  index.html index.htm;
    }

    # 配置后端接口的跨域代理
    # 对于路径为 "prod-api 的接口,帮助他跳转到指定的地址
    location /prod-api/ {
    proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header REMOTE-HOST $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        # 本机上运行的后端接口
        proxy_pass http://localhost:8080/;     
    }

    location /status{
        stub_status on;
    }
}

4.3 启动nginx镜像

docker run --name nginx \
-p 80:80 -p 443:443 \
-v /data/nginx/nginx.conf:/etc/nginx/nginx.conf \
-v /data/nginx/logs:/var/log/nginx \
-v /data/nginx/html:/usr/share/nginx/html \
-v /data/nginx/conf:/etc/nginx/conf.d \
--privileged=true \
-e TZ=Asia/Shanghai \
-d nginx:1.25.3

5、 jar打包docker 镜像

注:jar包尽量无主服务方便扩容(token+redis 认证变无主,独立文件、数据库让其于应用无关),负载均衡不行买现成的;消息队列目前这玩意高并发坑多;rocketmq 并发高,吃资源太厉害了;
分布式部署jar,得将jar打成镜像,方便一键部署;

5.1 新建配置文件:将所有127.0.0.1换成机器的ip

注:因为容器部署问题

5.2 在linux 新建打包路径,将打包jar上传此路径:

5.3 在目录下新建DockerFile,内容如下:

或者将DockerFile也上传linux相应路径

#基础镜像使用jdk17
FROM openjdk:17
#作者
MAINTAINER kly

# VOLUME 指定临时文件目录为/tmp,在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp

# 将jar包添加到容器中并更名
ADD hy-admin.jar /app.jar

# 运行jar包
RUN bash -c 'touch /app.jar'

# 为了缩短 Tomcat 启动时间,添加一个系统属性指向 “/dev/./urandom” 作为 Entropy Source
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

#ENTRYPOINT ["nohup","java","-jar","/data/app/hy-admin.jar","&"]

#暴露9000端口
EXPOSE 9000

5.4 打包镜像

注:命令最后面有 空格 和 点符号

# 命令后面有个 空格 .
docker build -f DockerFile -t app:1.0 .

5.5 启动镜像

docker run -d --name app -p 9000:9000 app:1.0

5.6 查看日志

docker logs -f app:1.0

三、使用Docker虚拟网络,解决部署时,springboot 配置文件不一致

先了解:1)docker网络命令:https://www.phpsdk.cn/plug/news/show.html?id=12824

1、容器的网络

Docker 网络之前,我们有必要先来了解一下这几种网络模式都是什么意思。
Docker中容器间的通信方式
1.通过容器ip访问
容器重启后,ip会发生变化。通过容器ip访问不是一个好的方案。

2.通过宿主机的ip:port访问
通过宿主机的ip:port访问,只能依靠监听在暴露出的端口的进程来进行有限的通信。
3.通过link建立连接(官方不推荐使用)
4.通过 User-defined networks(推荐)

例子:

# 1、创建 docker 虚拟网络
docker network create my-network

# 查看网络情况:
docker network ls

# 2、所有容器通信添加2个参数(建议启动时添加):--network 虚拟网络网卡 --network-alias 容器在虚拟网路别名
# 之后 springboot应用 可通过 容器的虚拟网路别名, 直接访问mysql

docker run -itd --name mysql --network my-network --network-alias mysql \
-e MYSQL_ROOT_PASSWORD=root mysql:5.7.24

# 3、对于已经创建好的容器:
如果容器已创建好但是之前没有指定自己的网络,则使用下面命令修改:

docker network connect --alias mysql my-network mysql
# 第一个mysql是网络别名 第二个mysql是容器名

# 4、通过网络别名测试访问
# 进入web容器,使用ping命令测试
docker exec -it mysql /bin/bash
容器> ping mysql

2、改造网路:使用自定义网路

参考教程:https://blog.csdn.net/cjbfzxz/article/details/106652867

2.1 创建虚拟网络

创建 docker 虚拟网络
docker network create my-network
#查看网络情况:
docker network ls

2.2 启动的 mysql 添加虚拟网络

docker network connect --alias mysql8 my-network mysql8

2.3 启动的 redis 添加虚拟网络

docker network connect --alias redis7 my-network redis7

2.4 启动的 reabbit 添加虚拟网络

docker network connect --alias rabbitmq3.12.10 my-network rabbitmq3.12.10

2.5 修改 nginx 配置文件,重启,并添加虚拟网络

注:修改nginx配置为后台应用地址:假设springboot 应用的虚拟网路别名为:jar-grain-9000 – 类型-项目-端口号

# 重启
docker restart nginx
# 俩接网络
docker network connect --alias nginx my-network nginx

2.6 修改应用链接中间件为:中间件虚拟网络别名,重新打包jar

例如mysql的链接
url: jdbc:mysql://${DB_HOST:mysql8}{DB_PORT:3306}/${DB_NAME:hy_cost_grain}?..

仅了解:外置配置文件:https://blog.51cto.com/u_16213321/7860225

# 1、停止容器
docker stop app
# 2、删除容器
docker rm -f app
# 3、删除镜像(正常可保留镜像叠加版本号:也删掉没用的,太多了会乱)
docker rmi -f app:1.0
# 4、新建配置文件:将:mysql、redis、rabbit改用虚拟网络的配置,并重新打包jar
注:此时使用是容器的内部端口,例如mysql 映射外部3308,内部使用的是3306
# 5、上传并重新打包镜像:命令后面有个 空格 .
docker build -f DockerFile -t app:1.0 .

# 6、使用虚拟网络运行镜像

docker run -d --name app --network my-network --network-alias jar-grain-9000 \
-e "JAVA_OPTS=--DB_HOST=mysql8" \
-p 9000:9000 app:1.0

# 查看日志
docker logs -f app
# 测试也可以访问

打包 DockerFile 添加镜像启动参数
教程(测试传参失败):https://www.cnblogs.com/HMingR/p/13588123.html

#基础镜像使用jdk1.8
FROM openjdk:17
#作者
MAINTAINER kly
 
# VOLUME 指定临时文件目录为/tmp,在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
 
# 将jar包添加到容器中并更名
ADD hy-admin.jar /app.jar
 
# 启动内运行下列命令:文件不存在,则创建/app.jar文件
RUN bash -c 'touch /app.jar'
 
# 为了缩短 Tomcat 启动时间,添加一个系统属性指向 “/dev/./urandom” 作为 Entropy Source
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
 
#ENTRYPOINT ["nohup","java","-jar","/app.jar","$JAVA_OPTS","&"]
 
#暴露9000端口
EXPOSE 9000
#暴露6000端口
EXPOSE 6000

【1】Dockerfile详解 https://www.jianshu.com/p/4508784f6ddc
【2】Docker数据卷(Volume)作用 https://blog.csdn.net/zhousenshan/article/details/129229378

四、docker-compose 快速单机部署

参考:https://blog.csdn.net/u010361276/article/details/130877191

1、 新建docker-compose.yaml 文件

注:若使用的镜像不存在,docker会先拉取镜像

version: "3.0"

networks: 
  ruoyi-net: 
    driver: bridge

services:
  mysql8:
    image: mysql:8.2.0
    container_name: mysql8
    hostname: mysql8
    volumes:
      - /data/docker-worker/mysql8/data:/var/lib/mysql
      - /data/docker-worker/mysql8/my.cnf:/etc/my.cnf
    environment:
      TZ: Asia/Shanghai
      MYSQL_DATABASE: hy_cost_grain
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_ROOT_HOST: '%'
      # 等同于 -e MYSQL_ROOT_PASSWORD指定root的登录密码
      #- MYSQL_ROOT_PASSWORD=123456a?
      #- MYSQL_ALLOW_EMPTY_PASSWORD='no'
      # 这里这个指令compose启动成功后会自动创建名为docker的数据库
      #- MYSQL_DATABASE='ecdb02'
      # 此处就是相当于 mysql create user,创建了数据库的登录用户
      #- MYSQL_USER='ecuser'
      #- MYSQL_PASSWORD='123456a?'
    privileged: true
    ports:
      - "3308:3306"
    restart: always
    command: [
      '--character-set-server=utf8mb4',
      '--collation-server=utf8mb4_unicode_ci'
    ]
    networks:
      - ruoyi-net

  # 配置redis服务
  redis7:
    # 设置容器对应的镜像
    image: redis:7.2.3
    # 设置容器名
    container_name: redis7
    # 配置环境
    environment:
      - TZ=Asia/Shanghai
    # 同上,作为端口映射
    ports:
      - "6379:6379"
    # 同上,挂载文件夹
    volumes:
      # 配置文件(需要在宿主机路径上传redis.conf文件)
      - /data/docker-worker/redis/redis.conf:/etc/redis/redis.conf
      # 数据
      - /data/docker-worker/redis/data:/data/redis
      # 日志
      - /data/docker-worker/redis/logs:/var/log/redis
    # 设置命令
    command: redis-server /etc/redis/redis.conf --appendonly yes --requirepass ''
    # 自动重启
    restart: always
    networks:
      - ruoyi-net

  # 配置nignx服务
  nginx:
    # nginx最新镜像
    image: nginx:1.25.3
    # 定义容器名称
    container_name: nginx
    # 配置nginx环境
    environment:
      - TZ=Asia/Shanghai
    # 配置端口
    ports:
      - "80:80"
      - "443:443"
    # 配置挂载的文件夹
    volumes:
      # nginx 主配置文件
      - /data/docker-worker/nginx/nginx.conf:/etc/nginx/nginx.conf
      # nginx 配置文件夹
      - /data/docker-worker/nginx/conf:/etc/nginx/conf.d
      # nginx静态文件
      - /data/docker-worker/nginx/html:/usr/share/nginx/html
      # nginx日志
      - /data/docker-worker/nginx/logs:/var/log/nginx
    # 自动重启
    restart: always
    networks:
      - ruoyi-net

  jar-grain-9000:
    image: openjdk:17
    container_name: jar-grain-9000
    restart: always
    cap_add:
      - SYS_PTRACE
    depends_on:
      - mysql8
      - redis7
    ports:
      - "9000:9000"
    links: 
      - mysql8
    environment:
      - spring.profiles.active=test
      - server.port=9000
      - REDIS_HOST=redis7
      - DB_HOST=mysql8
      - DB_PORT=3306
      - DB_NAME=hy_cost_grain
      - DB_USERNAME=root
      - DB_PASSWORD=123456
      - FILE_BASE_PATH=/data/grain/uploadPath
    volumes:
      - /data/grain:/data/grain
    working_dir: /data/grain
    command: java -Xmx1024m -jar hy-admin.jar
    networks:
     - ruoyi-net

注:详解docker compose的version(是指compose版本。默认2,这里用3.0)
https://www.cnblogs.com/daizichuan/p/17732059.html
https://cloud.tencent.com/developer/article/2291042?areaSource=102001.17&traceId=l78txME4HLUl-hqPvwGUV

2、将 docker-compose.yaml 上传至之前上传的jar包的文件路径

3、启动并排查启动情况

3.1 创建 docker-compose.yaml 文件中的容器

docker compose -f /data/grain/docker-compose.yaml up -d
# docker-compose.yaml 文件路径一致时,可以简写为
docker compose up -d

3.2 查看整体启动情况

docker compose -f /data/grain/docker-compose.yaml ps
# docker-compose.yaml 文件路径一致时,可以简写为
docker compose ps

3.3 查看异常容器状态的日志(上面 ps 命令中status 显示异常的)

# docker compose -f 路径/docker-compose.yaml logs -f 容器名
docker compose -f /data/grain/docker-compose.yaml logs -f mysql8
# docker-compose.yaml 文件路径一致时,可以简写为
docker compose logs -f mysql8

3.4 移除 docker-compose.yaml 文件的容器

docker compose -f /data/grain/docker-compose.yaml down
# docker-compose.yaml 文件路径一致时,可以简写为
docker compose down

五、docker 镜像合并(测试失败)

注:docker17.05版本开始 才支持多阶段构,理论上能将所有操作合并成一个镜像
【1】Dockerfile多个from的使用及多个build-arg的使用示例
https://blog.csdn.net/quyingzhe0217/article/details/129319294?utm_source=miniapp_weixin

【2】docker 合并所有镜像 docker from多个镜像
https://blog.51cto.com/u_14112/6687045
【3】 Docker 多阶段构建打包Java应用
https://blog.csdn.net/LK_Lawliet/article/details/131950674

测试结果

测试失败,理论上是可以;但是需要解决各种问题
例如:以centos docker基础镜像,在上面安装mysql、redis、nginx、程序
将这些步骤封住哪个成一个 dockerFile,一键就可完成所有;
其操作跟打包linux带环境镜像的工作量一样大,这里就不试验了

六、docker镜像与容器的导入导出

【1】Docker及Docker-compose常用命令总结
https://blog.csdn.net/weixin_42521409/article/details/130638142
【2】docker镜像的导入和导出
https://www.cnblogs.com/kanie-life/p/17532411.html
docker镜像的导入和导出

1 镜像导出

docker save > 生成路径/[镜像名].tar 镜像ID
docker save 镜像ID > [镜像名].tar
docker save -o [镜像名].tar 镜像ID 镜像ID 镜像ID(可多个images打包成一个)

#测试 7.2.3单独,其他合并,跨机器测试)
docker pull redis:7.2.3
docker pull redis:7.2
docker pull redis:7.0.14
docker pull redis:6.2.14

# 导出单个镜像
docker save > /data/docker-export/redis:7.2.3.tar redis:7.2.3
# 导出多个,不能指定路径;只能切换路径导入当前文件夹
cd /data/docker-export
docker save -o redisMore.tar redis:7.2 redis:7.0.14 redis:6.2.14

2 镜像导入

# docker load < [镜像名].tar
docker load < redis:7.2.3.tar
docker load < redisMore.tar
# 测试
镜像都可用启动,可用

#删除镜像前,需检查镜像是否存在引用
docker ps
#若存在引用,删不掉,只会把镜像的标签名和版本号删掉
docker image ls
#删掉一半的 docker rmi -f 镜像ID
docker rmi -f redis:7.2.3

3 容器导出

docker export (生成路径,无则生成当前文件夹) 容器的ID > [容器名].tar

4 容器导入

docker import [容器名].tar 自定义容器名

5 实例化并启动容器

docker run -d 自定义容器名

注:如实例化失败,提示docker: Error response from daemon: No command specified

解决:运行指令docker ps -a,查看容器的COMMAND,并将COMMAND的值加入到启动命令最后面。

将容器打包成镜像

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]、

OPTIONS说明:

-a :提交的镜像作者;
-c :使用Dockerfile指令来创建镜像;
-m :提交时的说明文字;
-p :在commit时,将容器暂停
eg:docker commit -a “abc” -m “123” 容器ID 自定义镜像名:版本

容器导入导出与镜像导入导出的选择
如果需要把 A 机器上的容器1迁移到 B 机器上, 且容器1中有重要的数据需要随之一起迁移的, 就可以选择容器导入导出。

七、docker 跨机器网络通信

【1】Docker跨主机通信解决方案探讨(仅是解决方案优缺点介绍)
https://blog.csdn.net/adparking/article/details/119140506
【2】Docker网络体系结构:设计可扩展、可移植的Docker容器网络(含解决方)
https://blog.csdn.net/docerce/article/details/79278568
【3】Docker跨主机网络通信(简单、精炼)
https://blog.csdn.net/qq_36733838/article/details/130533447

方案

###方案一
少量直接使用主机ip 简单
###方案二
(推荐-机器较多)docker swarm 集群服务编排部署指南(docker stack)
https://blog.csdn.net/footless_bird/article/details/129121931


量多:
1)先用:docker swarm 搭建集群环境(极限是在 1000 个节点上运行 50000 个部署容器)
2)创建用于swarm服务的自定义的overlay网络
3)改造docker-compose.yml 文件, 并 用Docker Stack 编排集群环境下的多服务
# swarm 集群网络(每台机器都要执行)
# 1、开放以下TCP协议端口,2377 :集群管理端口; 7946 :节点之间通讯端口(不开放则会负载均衡失效)
# 4789 :overlay网络通讯端口
firewall-cmd --zone=public --add-port=2377/tcp --permanent
firewall-cmd --zone=public --add-port=7946/tcp --permanent
firewall-cmd --zone=public --add-port=4789/tcp --permanent

# 更新firewalld防火墙规则(并不中断用户连接,即不丢失状态信息)
firewall-cmd --reload

# 2、创建docker swarm集群
**注:swarn 对主节点磁盘占用较大,真实可以主节点用个1T~8T的磁盘,我这边测试用了120g,docker虚拟网络占了80G的磁盘(含其占用但未使用的)**
# 2.1 master主机上初始化swarm
docker swarm init
# 注:如果主机有多个网卡,拥有多个IP,必须使用 --advertise-addr 指定 IP。
# 示例:
docker swarm init --advertise-addr 192.168.99.100

在这里插入图片描述

# 2.2 在非主节点上执行初始化的节点名
docker swarm join --token SWMTKN-1-6ckn864g7ve7dd32x6il0os9oj1vanzptor5tgho07r07jn9a0-2w2n30m22aihpq8dlr8g7ite5 192.168.0.8:2377

# 2.3 在master 节点查看信息
# 查看 swarm 集群状态
docker info
# 查看集群节点信息
docker node ls 
# 3 创建用于swarm服务的自定义的overlay网络
docker network create -d overlay --attachable swarm-overlay
# 注:overlay 网络创建可以在 Swarm 集群下的任意节点执行,并同步更新到所有节点。
# 4 测试创建3个nginx(只能在主节点执行创建,且集群机器够用,不够则执行卡那):docker service
docker service create --replicas 3 -p 80:80 --name nginx nginx:1.25.3

# 4.1 查看服务状态:
docker service ls

# 4.2 删除服务
docker service rm nginx
**注:实际情可能网络较为复杂,例如:**

**1)xx局项目,有个队列是实体机器,容器应用得访问此台机器生成要处理的任务;因为应用session(shiro)存储在redis,
所以外部机器也得访问 容器环境的redis;固:中间件需要指定节点启动,不能瞎搞,且需要挂在磁盘目录;**

**2)当时这个环境并发量不大,用NFS做磁盘共享,无文件服务器;若量大了需要独立文件服务,若依解决方案是minio,简单的就自己写个文件上传下载+NFS共享磁盘**
1)实际情况,一般实际(mysql,redis,指定节点创建)
2)程序和前端能无主注册到负载均衡器上
3)随便启动一定副本的前端和后端

注:1)一个程序流量崩溃最大的头的前端(集群不能满足流量就得加DNS),文件(独立服务,甚至必要时只提供少量服务)
2)我们当时前后一体,负载均衡器自动识别有效的服务,对外提供服务;
3)云厂商提供oos 服务,可支持前端全球负载和DNS;
4)阿里云springboot后台自动扩容及负载,根据实时负载自动扩缩容ECI实例:https://help.aliyun.com/zh/eci/user-guide/automatically-scale-elastic-container-instances-based-on-real-time-workloads


其他有用教程
【1】docker swarm 部署minio集群并配合nginx实现负载均衡
https://www.cnblogs.com/JentZhang/p/17120500.html
【2】linux环境docker部署ruoyi-vue(若依)总结
https://zhuanlan.zhihu.com/p/438076591
【3】docker swarm 指定节点部署应用
https://zhangqingya.cn/2022/07/06/docker%20swarm%E9%9B%86%E7%BE%A4%E4%B8%AD%E5%A6%82%E4%BD%95%E6%8C%87%E5%AE%9A%E5%AE%B9%E5%99%A8%E9%83%A8%E7%BD%B2%E8%8A%82%E7%82%B9

1、简单测试

这里简单部署一台应用,在指定节点上创建服务

# 参考教程 使用Docker Stack部署应用:https://zhuanlan.zhihu.com/p/182198031
docker stack deploy -c services.yml learn-docker-test
docker stack ls
docker service ls
docker service logs -f learn-docker-test_jar-grain-9000

注:
1)services.yml 详见附件,其中含包含2个: docker service和 docker stack命令,这里详细用法就不多做介绍
2)services.yml 中的网络类型 overlay,再包含 deploy 发布属性;

八、docker 共享存储

Docker Swarm NFS 数据持久化存储:https://blog.csdn.net/IT_ZRS/article/details/128648548

九、docker 未列明知识

【1】docker操作命令查漏
菜鸟:https://www.runoob.com/docker/docker-command-manual.html
(2019年后未更新,学的快):http://www.zhaowenyu.com/docker/dockerbackground/docker-history.html

【2】docker 容器监控、日志监控、资源监控
见/docker课件-汇总
–3.1 容器监控-N.pptx
–3.2 日志监控-N.pptx
–3.3-资源管理-N.pptx
【3】docker 仓库及扩容
扩容见/docker课件-汇总
–3.4-快速扩容-N.pptx
私有仓库 可用 1)docker nexus3 仓库
参考:https://blog.csdn.net/lishuoboy/article/details/130612821
2)harbor
https://blog.csdn.net/qq_47800859/article/details/129303922

你可能感兴趣的:(docker,容器,运维)