Docker学习笔记

阿莨去爬山了

已于 2022-12-09 09:44:52 修改

阅读量732

点赞数 1

分类专栏：学习笔记文章标签： docker 学习容器

于 2022-06-29 16:34:31 首次发布

本文链接：https://blog.csdn.net/qq_44441509/article/details/125524803

版权

学习笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Docker学习

学习时遵循AB（After、Before）法则。

1、Docker实际解决的痛点

开发环境中运行没有问题的项目，移交测试或者运维时，出现问题。Docker的解决方案就是将项目带环境已经移交。

主要解决了环境迁移问题。

2、Docker的概念

Docker是一个开源的应用容器引擎
Docker诞生于2013年初，基于Go语言实现，dotCloud公司出品，该公司后改名Docker Inc
Docker可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的linux机器上。
容器是完全使用沙箱机制，相互隔离。
容器性能开销极低
Docker从17.03v版本之后分为CE社区版和EE企业版

3、Docker架构

镜像：Docker镜像，就相当于一个root文件系统。
容器：镜像和容器的关系，就相当于面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体，容器可以被创建、启动、暂停、停止、删除等。
仓库：仓库可看成一个代码控制中心，用来保存镜像。

4、Docker安装

1、执行yum update -y 更新yum包
注意：如果出现Failed to download metadata for repo ‘appstream‘: Cannot prepare internal mirrorlist:…这个错误时，这是因为Centos8于2021年年底停止了服务，所以我们使用yum源安装时候会出现这个错误，解决办法也很简单
1.1、进入yum的repos目录
cd /etc/yum.repos.d/
1.2、修改所有的CentOS文件内容
sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
1.3、更新yum源为阿里镜像
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
1.4、清除缓存
yum clean all
yum makecache
1.5、重新执行安装命令即可
yum update -y

2、更新yum包 yum install -y yum-utils device-mapper-persistent-data lvm2

3、更新docker下载源 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

4、安装docker yum install -y docker-ce

5、查看docker版本，用于确认是否安装成功 docker -v

6、进入https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors 获取阿里云提供的专属镜像加速地址

针对Docker客户端版本大于 1.10.0 的用户

可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

mkdir -p /etc/docker

touch /etc/docker/daemon.json 添加以下内容到文件
{

“registry-mirrors”: [“https://66m2rqkw.mirror.aliyuncs.com”]
}

systemctl daemon-reload

systemctl restart docker

5、镜像命令

从远程仓库下载需要的镜像到本地。

镜像命令包括：查看、搜索、拉取（下载）、删除

查看：

docker images

docker images -q # 查看所用镜像的id
搜索：

docker search

docker search redis # 查找redis镜像
拉取：

docker pull

docker pull mysql:8.0.28 # 后面可以指定版本号也可以不指定
删除：

docker rmi [镜像id]

docker rmi [镜像名称]

docker rmi [镜像名称:版本]

docker rmi ` docker images -q` 删除所有镜像

6、容器命令

容器的命令包括：查看、创建、进入、启动、停止、删除、查看容器信息。

查看：

docker ps # 查看正在运行的容器

docker ps -a #查看所有容器
创建：

docker run [参数]

参数：

-i：保持容器运行，通常与-t同时使用，加上-it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭。

-t：为容器重新分配一个伪输入终端，通常与-i同时使用。

-d：以守护（后台）模式运行，创建一个容器在后台运行，需要使用docker exec进入容器，退出后，容器不会关闭。

-it：创建的容器一般称为交互式容器

-id：创建的容器一般为守护式容器。

-name：为创建的容器命名。

举例：docker run -it --name=cc centos:7 /bin/bash # 注意：前面使用了参数后面的参数要使用两个杠然后后面指定容器名称，容器环境以及版本号或者不指定版本号
进入：

docker exec [参数，参考创建时的参数] [容器id或名称] [容器脚本]

举例：docker exec -it cc /bin/bash

注意：只能进入已启动的容器，未启动的需要先启动才可以进入
启动：

docker start [容器id或名称]
停止：

docker stop [容器id或名称]
删除：

docker rm [容器id或名称] #删除单个

docker rm ` docker ps -aq ` # 删除多个
查看容器信息：

docker inspect [容器id或名称]

7、数据卷的介绍

数据卷就是宿主机的一个目录或文件。

数据卷的作用：

容器数据持久化
客户端和容器数据交换
荣期间数据交换

创建容器时，使用-v 参数设置数据卷

docker run ... -v 宿主机目录/文件:容器内目录/文件

注意：

容器目录必须是绝对路径
如果目录不存在，会自动创建
可以挂载多个数据卷，也可以一个数据卷挂在多个容器上

数据卷挂载命令示例：

docker run -it --name=c1 -v /root/data:/root/data_container centos:7 /bin/bash

单个数据卷挂载操作示例

# 1、查看docker是否启动
systemctl status docker
# 2、运行docker
systemctl start docker
# 3、在需要挂载的宿主目录下创建测试文件
touch /root/dockertest/testFile.txt
# 4、创建docker容器，挂载第三步创建的测试文件目录
docker run -it --name=test -v /root/dockertest:/root/dockerData centos:7 /bin/bash
# 5、进入docker容器后，查看测试文件是否存在
cd /root/dockerData
ll

宿主机对该目录下的更改会同步到容器中，容器中该数据卷的更改也会同步到宿主机。即便容器被删除掉，产生的更改也不会回滚，依旧还在。

多个数据卷挂载时，只要修改上面一条命令即可

docker run -it --name=test -v /root/data1:/root/data1 -v /root/data2:/root/data2 centos:7 /bin/bash

多个容器挂载同一个数据卷时，两个容器就可以交换数据了。

8、数据卷容器

数据卷容器本质上还是一个数据卷，不是它是创建一个容器，挂载一个目录，让其它容器继承自该容器。并可以对容器做一些简单的配置。

多个容器进行数据交换，多个容器挂载同一个数据卷容器，完成数据交互。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rIZNrLvX-1656491514218)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220309164730326.png)]

# 1、创建数据卷容器
docker run -it --name=c3 -v /volume centos:7 /bin/bash # 未指定宿主机目录，默认会自动生成一个宿主机目录，使用docker inspect [容器名] 查看
# 2、创建两个容器，关联这个数据卷容器
docker run -it --name=c1 --volumes-from c3 centos:7 /bin/bash # 使用--volumes-from关联数据卷容器
docker run -it --name=c2 --volumes-from c3 centos:7 /bin/bash # 此时的c1,c2容器中的/root目录下，会自动出现一个/root/volume文件夹,这就是关联的的容器卷

使用docker inspect [容器名] 命令查看数据卷容器信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CDpmJg3i-1656491514219)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220309165221882.png)]

type为volume即表示该容器为数据卷容器。

数据卷容器不启动也可以实现相应的作用。

9、Docker安装常用软件

容器内的网络服务和宿主机之外的机器不能直接通信，但是外部机器可以和宿主机直接通信，当容器中的网络服务需要呗外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上，从而达成外部机器间接访问容器服务。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JPWdI1Bb-1656491514219)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220309171800658.png)]

9.1、Mysql安装：

# 1、搜索mysql镜像
docker search mysql
# 2、拉取mysql镜像
docker pull mysql:8.0.19
docker pull mysql:5.7
# 3、创建容器，设置端口映射、目录映射等
# 3.1、在宿主机的/root目录下创建用于存储mysql数据信息的目录/root/mysql
mkdir ~/mysql
cd ~/mysql
# 3.2、创建容器，设置端口映射，目录映射
docker run -id -p 3307:3306 --name=mysql1 -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0.19 # $PWD代表宿主机当前操作目录，即/root/mysql

docker run -id -p 3307:3306 --name=mysql2 -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7 # $PWD代表宿主机当前操作目录，即/root/mysql

# 4、进入容器
docker exec -it mysql1 /bin/bash
docker exec -it mysql2 /bin/bash
# 5、连接容器中的mysql
mysql -uroot -p123456
# 6、查看mysql中的所有数据库
show databases;
# 7、创建名为dockerBase的mysql数据库
create dataBase db1;
# 8、此时使用navicat连接虚拟机的3307端口，查看数据库内容时，遇到了一个
Client does not support authentication protocol requested by server; consider upgrading MysQL client问题。
这是由于mysql8之前的版本中加密规则是mysql_native_password,而在mysql8之后,加密规则是caching_sha2_password,上面提供的mysql5.7容器，连接时未出现问题。
mysql8.0以上此问题的解决方案：
	进入容器的mysql后，输入以下内容
	①：GRANT ALL ON *.* TO 'root'@'%';
	②：flush privileges;
	③：ALTER USER 'root'@'localhost' IDENTIFIED BY 'password' PASSWORD EXPIRE NEVER;
	④：ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';
	⑤：FLUSH PRIVILEGES;  #刷新权限使修改生效，此时就可以正常连接了。

参数说明：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VExFAowq-1656491514219)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220309173104523.png)]

9.2、Tomcat安装：

# 1、搜索tomcat镜像
docker search tomcat
# 2、拉取tomcat镜像
docker pull tomcat
# 3、创建容器，设置端口映射，目录映射
mkdir ~/tomcat
cd ~/tomcat
docker run -id --name=my_tomcat -p 8080:8080 -v $PWD:/usr/local/tomcat/webapps tomcat
# 4、在宿主机中的/root/tomcat下创建测试文件夹，模拟项目部署
mkdir ~/tomcat/tets
vim index.html
<h1>Hello Docker And Tomcat</h1>
保存内容
# 5、浏览器中输入[宿主机ip]:8080/test/index.html,页面显示Hello Docker And Tomcat,Tomcat安装成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6MSeTdE6-1656491514220)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220309230325220.png)]

9.3、Niginx安装：

# 1、搜索Nginx镜像
docker search nginx
# 2、拉取Nginx镜像
docker pull nginx
# 3、在宿主机创建目录
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 创建nginx的配置文件
vim nginx.conf
输入以下内容：
user nginx; 
worker_processes 1; 

error_log /var/log/nginx/error.log warn; 
pid /var/run/nginx.pid; 


events { 
	worker_connections 1024; 
}


http {
	include /etc/nginx/mime.types; 
	default_type application/octet-stream; 

	log_format main '$remote_addr - $remote_user [$time_local] "$request" '
					'$status $body_bytes_sent "$http_referer" ' 
					'"$http_user_agent" "$http_x_forwarded_for"'; 
	access_log /var/log/nginx/access.log main; 

	sendfile on; 
	#tcp_nopush on; 

	keepalive_timeout 65; 

	#gzip on;

	include /etc/nginx/conf.d/*.conf; 
}
保存完毕后，退回到/root/nginx目录下，继续下一步操作    
# 4、创建容器，设置端口映射，目录映射
docker run -id --name=my_nginx -p 80:80 -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf -v $PWD/logs:/var/log/nginx -v $PWD/html:/usr/share/nginx/html nginx
# 5、在宿主机的/root/nginx/html中创建测试文件index.html
# 6、浏览器输入访问地址，成功打印输出html页面内容即成功

9.4、Redis安装：

参考我的另一篇博客

10、Docker镜像原理

Linux系统由bootfs和rootfs两部分组成。

bootfs包含bootloader（引导加载程序）和kernel（内核）

rootfs是文件系统，它包含linux系统中的/dev、/proc、/bin、/etc等标准目录和文件

不同的linux发行版，bootfs基本一样，而rootfs却不同，如ubuntu和centos

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xMLitHbB-1656491514220)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220310181840094.png)]

Docker的镜像是由特殊的文件系统叠加而成

最底端的是bootfs，rootfs部分使用的是宿主机的。

镜像的第二层是root文件系统rootfs，这部分称为base image

第二层往上，就可以叠加其它的镜像文件了。使用统一文件系统（Union File System）技术，将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度来看，只存在一个文件系统一样。

一个镜像可以放在另一个镜像的上层，位于下层的镜像称为父镜像，最底层的镜像称为基础镜像。

当一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WHFFGm2D-1656491514220)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220310182256527.png)]

Docker镜像本质是一个分层文件系统。

在Docker中，一个CentOS镜像只有200MB，不同于CentOS的ISO文件，好几个G，原因是因为CentOS的ISO镜像文件包括bootfs和rootfs两部分，而Docker的CentOS镜像复用操作系统的bootfs，只包含了rootfs部分和其它镜像层，所以镜像大小只有200MB。

在Docker中一个Tomcat镜像有600MB，而Tomcat原本的安装包只有70MB的原因是，由于Docker中镜像是分层的，Tomcat虽然只有70多但是它需要依赖于父镜像和基础镜像，所以整个tomcat镜像大小就变得很大了。

11、镜像的制作

镜像制作就解决了实际开发交接时的痛点环境不一致。开发人员将能正常运行项目的容器包括开发环境版本等一并打包成镜像，交予测试人员加载到docker还原开发环境去运行以及测试。

容器转镜像

# 将容器打包为镜像
docker commit [容器id] [镜像名称]:[版本号]
# 将打包好的镜像压缩
docker save -o [压缩文件名称] [镜像名称]:[版本号]
# 加载压缩好的镜像
docker load -i [压缩文件名称]

12、DockerFile

Dockerfifile 是一个文本文件，包含了一条条的指令，每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像

对于开发人员：可以为开发团队提供一个完全一致的开发环境

对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfifile文件构建一个新的镜像开始工作了

对于运维人员：在部署时，可以实现应用的无缝移植

dockerfile的指令关键字以及说明：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pvP9TqMl-1656491514221)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220310235023281.png)]

dockerfile案例1：自定义centos镜像

要求：默认登录路径为/usr，可以使用vim

实现步骤：

定义父镜像：FROM centos:7

定义作者信息：MAINTAINER aliang aliang@aliang.cn

执行安装vim命令： RUN yum install -y vim

定义默认的工作目录：WORKDIR /usr

定义容器启动执行的命令：CMD /bin/bash

通过dockerfifile构建镜像：docker bulid –f dockerfifile文件路径 –t 镜像名称:版本 .

# 创建dockerfile文件
mkdir ~/docker-files 
cd ~/docker-files 
vim centos_dockerfile

# 编写dockerfile指令
FROM centos:7
MAINTAINER aliang <aliang@aliang.cn>
RUN yum install -y vim 
WORKDIR /usr 
CMD /bin/bash

# 构建这个dockerfile文件
docker build -f ./centos_dockerfile -t lxs_centos:1 .
-f：镜像文件 -t：新镜像名 . 寻址路径

# 进入创建好的dockerfile查看效果
docker run -it --name=c2 lxs_centos:1

dockerfile案例2：发布Springboot项目

定义父镜像：FROM java:8

定义作者信息：MAINTAINER aliang aliang@aliang.com

将jar包添加到容器： ADD springboot.jar app.jar

定义容器启动执行的命令：CMD [“java”,“-jar”,“app.jar”]

通过dockerfifile构建镜像：docker build –f dockerfifile文件路径 –t 镜像名称:版本 .

# 创建dockerfile文件
mkdir ~/docker-files 
cd ~/docker-files 
vim springboot_dockerfile

# 编写dockerfile指令
FROM java:8 
MAINTAINER aliang <aliang@aliang.com> 
ADD springboot.jar app.jar  # springboot.jar为原来的名字 app.jar为新名字
CMD ["java","-jar","app.jar"]

# 构建
docker build –f ./springboot_dockerfile –t app .

# 启动容器
docker run -id -p 9000:8080 app

13、Compose服务编排

微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启动停止，维护的工作量会很大，在未使用compose之前的操作步骤是：

从dockerfile build image 或者去dockerhub 拉取image
创建多个容器
管理多个容器（启动停止删除）

以上步骤可以通过服务编排大大简化，服务编排会按照一定的业务规则批量管理容器。使用compose之后的操作步骤：

利用dockerfile定义运行环境镜像
使用docker-compose.yml 定义组成应用的各个服务
运行docker-compose up 启动应用

docker-compose的安装：

# 下载
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置权限
chmod +x /usr/local/bin/docker-compose
#查看版本信息，确认安装成功
docker-compose -version

docker-compose的卸载

rm /usr/local/bin/docker-compose

服务编排案例1：编排nginx+springboot

需求：使用nginx反向代理到springboot应用

# 1、创建docker-compose目录
mkdir ~/docker-compose
cd ~/docker-compose
# 2、编写docker-compose.yml文件
version: '3'
services:
 nginx:
  image: nginx # 注意，docker中需要有nginx镜像
  ports:
   - 80:80
  links:
   - app # 此处用于链接下面的app服务，使用app这个名字在nginx中访问对应的springboot服务
  volumes:
   - ./nginx/conf.d:/etc/nginx/conf.d
 app:
  image: app # 注意，docker中需要有app镜像,此处案例的app镜像是从开发环境打包之后制作的
  expose: # 暴露端口
   - "8080"
# 3、创建nginx的配置文件
mkdir -p ./nginx/conf.d
# 4、在./nginx/conf.d目录下，编写app.conf文件
server{
	listen 80;
	access_log off;
	
	location / {
		proxy_pass http://app:8080/hello;
	}
}
# 以上配置文件的内容说明：当启用了nginx服务并访问80端口时，反向代理到http://app:8080/hello上
# 5、在docker-compose目录下，使用命令启动容器
docker-compose up # 可以加上参数 -d 表示守护进程
# 6、停止
docker-compose down

服务编排案例2：部署SpringCloud多模块应用

1、使用Idea连接虚拟机CentOS7中部署的docker

1.1、IDEA上下载docker插件

1.2、连接

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WAful1vk-1656491514221)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220311172546015.png)]

1.3、Docker操作台

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5Hlr8o6Z-1656491514221)(https://gitee.com/superAliang/pic-go-imges/raw/master/dubbo/imgs/image-20220311172626347.png)]

2、开通docker远程访问功能，打开/usr/lib/systemd/system/docker.service文件，找到ExecStart这行，在中间，修改为：

ExecStart=/usr/bin/dockerd  -H tcp://0.0.0.0:2375  -H unix:///var/run/docker.sock

重新启动docker

systemctl daemon-reload    
systemctl restart docker

14、私有仓库

私有仓库的目的用于管理和存放自己的镜像。

# 1、拉取私有仓库镜像
docker pull registry
# 2、启动私有仓库容器
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址：http://私有仓库服务器ip:5000/v2/_catalog ,看到{"repositories":[]} 表示私有仓库搭建成功，
# 4、修改daemon.json
vim /etc/docker/daemon.json
在该文件中，添加一个key，保存退出，这一步用于让docker信任私有仓库，注意：将私有仓库服务器ip修改为自己私有仓库服务器真实ip
{"insecure-registries":["私有仓库服务器ip:5000"]}
例如:
{"insecure-registries":["192.168.1.6:5000"]}
# 5、重启docker服务

将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像
docker tag centos:7 192.168.1.6:5000/centos:7ddf
# 2、上传标记的镜像
docker push 192.168.1.6:5000/centos:7

从私有仓库拉取镜像

docker pull 192.168.1.6:5000/centos:7

SpringCloud_Bill项目移植到本地docker

SpringCloud项目包含：Eureka集群、服务提供者集群、Gateway、Config、消费者

# 安装了mysql的主机ip:192.168.1.4
# 安装了docker的主机ip:192.168.1.6
# 
#
# 1、所有的模块改造eureka地址，从本地域名改成docker所在宿主机的ip
http://192.168.1.6:7001/eureka,http://192.168.1.6:7002/eureka,http://192.168.1.6:7003/eureka


# 2、所有子模块添加maven插件
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
    
# 3、父工程添加maven依赖
    <build>
        <plugins>
            <plugin>
                <!--当子工程之间存在依赖关系时使用下面的打包方式，防止出现依赖的工程打包时找不到被依赖工程的class问题-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.6.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
  
  
# 4、去掉返回页面的controller所返回的视图地址前面的斜杠
"/bill/list-page"  修改成 "bill/list-page"


# 5、修改服务提供者连接数据库的地址，由localhost改成ip
url: jdbc:mysql://localhost:3306/bill-manager?serverTimezone=GMT%2B8
修改成
url: jdbc:mysql://192.168.1.4:3306/bill-manager?serverTimezone=GMT%2B8


# 6、各个Eureka的配置文件中，将register-with-eureka改成false，默认为true
register-with-eureka: false


# 7、修改consumer80模块中的html中的跨域请求地址
"http://127.0.0.1:10010/consumer/add"
修改为
"http://192.168.1.6:10010/consumer/add"


# 8、父工程添加依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-validation</artifactId>
</dependency>


# 9、使用maven将父工程clean、package


# 10、将所有的打包好的jar包上传到安装了docker的linux中
注意：上传的是所有的 xxxxxxx-xxxxxxx-1.0-SNAPSHOT-exec.jar 文件


# 11、在jar所在目录，创建并编写dockerfile将所有的jar包制成镜像
Eureka示例，其它就是将jar包名称换了就行。每个jar包都需要制作成镜像。
FROM icestormspirit/java:11
MAINTAINER aliang <aliang@aliang>
ADD SpringCloud-EurekaServer-7001-1.0-SNAPSHOT-exec.jar eureka7001.jar
CMD ["java", "-jar","eureka7001.jar"]
注意：FROM icestormspirit/java:11这个地方，由于本SpringCloud项目使用的是jdk11，而这个仓库中有java11镜像，所以引入，如果是jdk8使用FROM java:8 ,其它版本jdk请自行百度。


# 12、使用docker images查看jar包的镜像是否全部制作成功
docker images


# 13、使用这些dockerfile一个个构建镜像
docker build -f ./[这部分填写当前模块构建文件名称] -t [这部分填写构建后的镜像名称]:[这部分填写版本号] . 后面的点也要
示例：docker build -f ./eureka7001 -t eureka7001:1 .


# 14、创建docker-compose.yml编排配置文件，用于一键启动部署
version: '3'
services:
  eureka7001:
    image: eureka7001
    ports:
      - 7001:7001
  eureka7002:
    image: eureka7002
    depends_on:
      - eureka7001
    ports:
      - 7002:7002
  eureka7003:
    image: eureka7003
    depends_on:
      - eureka7002
    ports:
      - 7003:7003
  config12000:
    image: config12000
    container_name: config12000
    depends_on:
      - eureka7003
      - eureka7001
      - eureka7002
    links:
      - eureka7001
      - eureka7002
      - eureka7003
    restart: always
    ports:
      - 12000:12000
  gateway10010:
    image: gateway10010
    container_name: gateway10010
    depends_on:
      - config12000
      - eureka7003
      - eureka7001
      - eureka7002
    links:
      - eureka7001
      - eureka7002
      - eureka7003
    restart: always
    ports:
      - 10010:10010
  provider8003:
    image: provider8003
    container_name: provider_8003
    depends_on:
      - gateway10010
      - eureka7003
      - eureka7001
      - eureka7002
    links:
      - eureka7001
      - eureka7002
      - eureka7003
    restart: always
    ports:
      - 8003:8003
  provider8002:
    image: provider8002
    container_name: provider_8002
    depends_on:
      - provider8003
      - eureka7003
      - eureka7001
      - eureka7002
    links:
      - eureka7001
      - eureka7002
      - eureka7003
    restart: always
    ports:
      - 8002:8002
  provider8001:
    image: provider8001
    container_name: provider_8001
    depends_on:
      - provider8002
      - eureka7003
      - eureka7001
      - eureka7002
    links:
      - eureka7001
      - eureka7002
      - eureka7003
    restart: always
    ports:
      - 8001:8001
  consumer80:
    image: consumer80
    container_name: consumer_80
    depends_on:
      - eureka7003
      - eureka7001
      - eureka7002
      - provider8001
    links:
      - eureka7001
      - eureka7002
      - eureka7003
    restart: always
    ports:
      - 80:80
      
# 15、本地主机的mysql虚拟机无法访问，需要开启远程访问
登录mysql
mysql> use mysql;
mysql> ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '111111';
mysql> FLUSH PRIVILEGES;
即可远程登录了


# 16、使用docker-compose启动
jar包和dockerfile以及docker.compose.yml需要在同一个目录，更好操作
执行命令：coker-compose up

# 15、浏览器输入192.168.1.6
结果显示可以正常访问