关于java:步骤详解Docker一键部署微服务详细教程

Docker 部署微服务

场景介绍

咱们应用 Docker 实现一个微服务的搭建过程

整体架构如下

应用多个微服务进行我的项目部署测试

整体服务阐明

咱们总共波及到三个微服务以及两个中间件

配置文件提取

因为咱们在开发中须要频繁批改 application.yml 文件咱们将配置项配置到 pom 文件中打包时主动打到配置文件，这样能够用一个 pom 文件管制多个不同的服务的配置文件项的批改

pom 文件定义属性

咱们须要在总 pom 文件定义全局配置，例如 nacos、mysql 等配置

<properties>
    <mysql.addr>192.168.64.153:3306</mysql.addr>
    <nacos.addr>192.168.64.153:8848</nacos.addr>
</properties>

配置编译选项

在子项目的 pom 文件的 build 构建配置中应用 <filtering>true</filtering> 配置，这样就能够将咱们的总 pom 中的配置编译进配置文件了

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

配置文件配置

在子项目的 application.yml 配置文件中留神应用 @xxx@ 占位符来配置编译占位配置，上面的配置就是用了 @@ 占位符编译后会将 pom 中的配置编译到配置文件中

server:
  port: @project.server.prot@
spring:
  application:
    name: learn-docker-storage
    ######################### 数据源连接池的配置信息  #################
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://@db.addr@/employees?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
    initialSize: 10
    minIdle: 20
    maxActive: 100
    maxWait: 60000
  #### nacos 配置 #######
  cloud:
    nacos:
      server-addr: @nacos.addr@
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.heima.module.p

编译测试

配置完后编译我的项目后，能够进入 target 目录下查看编译后的配置文件

咱们看到 maven 曾经帮咱们将配置编译进了配置文件中了

装置 MySQL

MySQL 简介

​ MySQL 是世界上最受欢迎的开源数据库。凭借其可靠性、易用性和性能，MySQL 已成为 Web 应用程序的数据库优先选择。

查找 MySQL 镜像

咱们能够应用 docker search 镜像名称，命令来搜寻镜像

docker search mysql

参数解释

搜寻进去的有这么多镜像，怎么抉择呢

• NAME: 镜像仓库源的名称
• DESCRIPTION: 镜像的形容
• OFFICIAL: 是否 docker 官网公布
• stars: 相似 Github 外面的 star，示意点赞、喜爱的意思。
• AUTOMATED: 主动构建。

依据参数，咱们个别抉择 官网公布的，并且 stars 多的。

下载镜像

能够应用 docker pull 镜像名称 来拉取镜像，咱们抉择了第一个 Mysql 的镜像，咱们把它给拉取下来

docker pull mysql

注意事项

• 如果不写版本号默认拉取最新的版本好latest。
• 拉取的时候是多个层一起拉取的，这样可用让其余镜像复用分层
• 如果拉取的镜像不写仓库地址默认就是docker.io/library/

下载指定版本的镜像

咱们下面下载的镜像不合乎咱们的预期，咱们须要 Mysql5.7 的镜像

查找指定镜像

能够登录 https://hub.docker.com 地址搜寻镜像

输出须要搜寻的镜像名称，并抉择对应镜像名称

抉择 tag 标签，这个就是版本的信息

找到合乎的版本 的 mysql 镜像，这里咱们抉择5.7.33

下载指定版本镜像

方才咱们曾经找到了 5.7.33 版本的 Mysql 的镜像，咱们应用 docker pull 命令下载，镜像前面跟的是 tag 也就是版本名称

docker pull mysql:5.7.34

咱们发现，咱们的新拉取的 mysql 镜像共用了 局部分层

查看镜像

装置完镜像后，咱们须要看一下咱们的本地镜像，应用docker images 可用查看本地镜像

docker images

这里有两个镜像，一个是最新版本的一个是咱们方才下载的 5.7.33 版本的

MySQL 配置

配置 MySQL 疏忽大小写

创立 MySQL 挂载目录，等会会解释什么是挂载门路

# 创立 MySQL 配置的文件夹
mkdir -p /tmp/etc/mysql
# 编辑 my.cnf 配置文件
vi /tmp/etc/mysql/my.cnf

配置 MySQL 疏忽大小写，在咱们创立的 MySQL 配置文件挂载点的目录的 my.cnf 文件退出如下内容

[mysqld]
lower_case_table_names=1

创立 MySQL 数据目录

因为默认 MySQL 启动后他的文件是在容器中的，如果咱们删除容器，数据也将会隐没，咱们须要将数据挂载进去。

# 创立 mysql 存储的目录
mkdir -p /tmp/data/mysql

启动 MySql

应用 docker run 启动容器

docker run -d -p 3306:3306 -v /tmp/etc/mysql:/etc/mysql/mysql.conf.d/ -v /tmp/data/mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --name mysql mysql:5.7.34

到这里 MySQL 曾经后盾运行了

参数解释

• -d：是指容器后盾运行，如果不加-d, 当用户断开客户端时容器会完结运行
• -p：将容器的 3306 端口映射到主机的 3306 端口，用来暴漏端口的
• -v：这个命令是用来挂载目录的，将本地目录挂载到容器中，这样容器操作的就是本地目录
• -e：这个命令是配置环境参数的，这里 MYSQL_ROOT_PASSWORD=root 指的是用 root 用户运行 mysql，能够登录 Docker 容器通过 ENV 命令查看
• –name：这个命令是配置 Mysql 的容器名称的，如果不配置，默认是随机生成的名字

查看 MySQL 运行状态

当初并不能确认 MySQL 的运行状态，咱们须要去看下

查看容器运行状态

应用 docker ps 能够看到运行中的容器

docker ps

执行命令后，咱们看到 mysql 的服务曾经起来了

查看 MySQL 运行日志

当初 MySQL 容器起来了，并不代表 MySQL 曾经胜利启动，咱们须要应用 docker logs 命令查看 MySQL 的日志

docker logs -f mysql

该命令能够查看容器日志 -f 是追踪打印日志，能够看到 MySQL 曾经启动了

客户端连贯 MySQL

因为咱们曾经暴漏端口了，能够应用客户端工具连贯 MySQL

查看配置的大小写参数是否失效

SHOW VARIABLES LIKE '%case_table%';

查看容器挂载的配置文件

能够通过 docker exec -ti mysql /bin/bash 命令登录容器，查看挂载的配置文件状况

# 登录容器
docker exec -ti mysql /bin/bash

该命令含意是在 mysql 容器中以

咱们能够看到咱们批改的配置文件曾经被挂载到了 docker 外部，这外面用到了 exec 命令，次要是在 deocker 容器中运行命令，上面咱们介绍下

命令格局

次要是在 deocker 容器中运行命令

docker exec [options] container command [arg...]

命令参数

查看挂载的数据文件

能够看下挂载的数据文件是否存在

cd /tmp/data/mysql/ && ll

咱们看到数据文件曾经写入了

MySQL 筹备数据

MySql 须要导入一些数据用来操作，咱们用 MySQL 官网提供的数据库来操作

下载并导入数据

下载 MySQL 测试数据库

到测试数据官网 下载数据库文件

间接导入无奈导入，须要编辑 employees.sql 文件的一些中央

1. set storage_engine = InnoDB;批改为: set default_storage_engine = InnoDB;
2. select CONCAT('storage engine:', @@storage_engine) as INFO;批改为：select CONCAT('storage engine:', @@default_storage_engine) as INFO;

  .....
  set default_storage_engine  = InnoDB;
-- set storage_engine = MyISAM;
-- set storage_engine = Falcon;
-- set storage_engine = PBXT;
-- set storage_engine = Maria;

select CONCAT('storage engine:',@@default_storage_engine) as INFO;
.....

导入测试数据

下载解压后，在本地执行命令导入到 mysql 服务器

mysql -uroot -h192.168.64.152 -p < employees.sql

客户端检查数据

在登陆客户端就能看到数据库以及表了

装置部署 nacos

​ Nacos 是阿里巴巴开源的一款反对服务注册与发现，配置管理以及微服务治理的组件。用来取代以前罕用的注册核心（zookeeper , eureka 等等），以及配置核心（spring cloud config 等等）。Nacos 是集成了注册核心和配置核心的性能，做到了二合一。

间接运行服务

能够间接用 docker 启动服务，镜像不存在会主动拉取

docker run -d -p 8848:8848 --name nacos --env MODE=standalone nacos/nacos-server

运行容器后能够稍等下，期待 nacos 启动胜利，受环境限度启动可能有些慢

登录页面测试

能够登录服务器测试以下

用户名：nacos 明码：nacos

微服务打包镜像

咱们筹备将一个微服务打包成 Docker 镜像，在各种服务器中进行运行，改为服务反对进行查问用户信息

提前阐明

因为咱们刚开始进行学习 Docker，先从单个微服务开始学习，咱们就先部署 learn-docker-storage 服务，前面随着课程的深刻在缓缓减少其余的微服务

拜访测试

在 idea 中运行learn-docker-storage，

咱们配置的端口是 8003，咱们能够间接拜访http://localhost:8003/storage/employe/findByID/10001

打包上传微服务

将 learn-docker-storage 服务打包后上传到服务器

留神配置项

这里须要查看下 maven 配置的编译属性是否正确

<mysql.addr>192.168.64.153:3306</mysql.addr>
<nacos.addr>192.168.64.153:8848</nacos.addr>

咱们发现是咱们容器中启动的地址

上传打包后的微服务

将 target 目录中打包实现的微服务上传到服务器

创立 DockerFile

Dockerfile 是一个用来构建镜像的文本文件，文本内容蕴含了一条条构建镜像所需的指令和阐明。

创立一个 Dockerfile 文件

vi Dockerfile

具体内容如下

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD learn-docker-storage-1.0-SNAPSHOT.jar app.jar
EXPOSE  8003
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

命令解释

• FORM：定制的镜像都是基于 FROM 的镜像，这里的 openjdk 就是定制须要的根底镜像，后续操作都是基于 openjdk
• VOLUME：挂载一个数据卷，这里因为没有名称，所以是一个默认的数据卷（前面具体解释）
• ADD：增加一层镜像到以后镜像，这里就是增加 SpringBootTest 镜像到以后层，并改名 app.jar
• EXPOSE：暴漏端口，因为咱们的本人的端口是 8080，所以咱们暴漏 8080
• ENTRYPOINT：设定容器启动时第一个运行的命令及其参数，这里就是容器以启动就执行 java -jar /app.jar

打包镜像

写好 DockerFile 后就须要用 docker build 命令来构建咱们的镜像了，这样就能够将咱们的微服务打包成一个镜像了

构建命令格局

构建一个镜像须要应用以下命令

docker bulid -t 仓库名 / 镜像名:tag .

参数解释

• -t：镜像的名字及标签，个别命名规定是 仓库名 / 镜像名:tag，

  • 仓库名：个别是私服或者 dockerhub 等地址，如果疏忽默认就是 dockerhub 的地址docker.io.library/
  • 镜像名称：就是咱们的本人的服务名称，能够随便命名
  • tag：就是咱们的版本号
• .：这个 . 示意当前目录，这实际上是在指定上下文的目录是当前目录，docker build 命令会将该目录下的内容打包交给 Docker 引擎以帮忙构建镜像。

实战操作

​ 一般来说，应该会将 Dockerfile 置于一个空目录下，或者我的项目根目录下，如果该目录下没有所需文件，那么应该把所需文件复制一份过去。

​ 个别大家习惯性的会应用默认的文件名 Dockerfile，以及会将其置于镜像构建上下文目录中。

当前目录的构造如下

构建镜像

进入 Dockerfile 的目录，通过如下命令构建镜像

 docker build -t learn-docker-storage:0.0.1 .

构建实现如果呈现 Successfully 阐明曾经构建胜利了，

查看咱们构建的镜像

应用 docker images 命令查看咱们构建实现的镜像

docker images

咱们能够看到咱们的镜像就在第一个地位

运行镜像

方才曾经打包实现了镜像，当初咱们运行咱们本人的镜像

# 运行容器
docker run -d -p 8003:8003 learn-docker-storage:0.0.1
# 查看运行中的容器
docker ps

参数最初的 learn-docker-storage:0.0.1 是镜像的名称，如果启动容器能够应用镜像名称或者镜像 ID

参数解释

• -d：后盾运行
• -p：映射端口，将宿主机的 8080 端口映射到 docker 外部的 8080 端口上

查看启动日志

应用 docker logs 容器 ID 来查看启动日志

docker logs -f 74c239792266

尝试拜访服务

通过curl 命令来拜访服务

curl http://192.168.64.153:8003/storage/employe/findByID/10001 | python -m json.tool

咱们发现服务调用胜利了，咱们根本实现了微服务革新为 docker 形式并运行

删除容器

要删除一个容器首先须要将一个容器进行掉

进行容器

咱们要把方才运行的容器进行掉，应用docker stop 容器 ID 进行一个容器

docker stop 3752f7088a04

进行容器后，咱们在通过过程查看是看不到容器的，然而容器还是存在咱们的服务中的

查看全副容器

通过docker ps 只能看到运行中的容器，然而咱们进行的容器是看不到的，能够加上-a 查看所有的容器

docker ps -a

咱们能够看到 加上 -a 参数能够看到方才曾经进行掉的容器

启动进行的容器

想要启动一个进行的容器能够应用docker start 容器 ID

docker start 3752f7088a04

这样就把方才曾经进行的容器启动了

删除容器

曾经进行的容器能够应用 docker rm 容器 ID 删除容器，然而对于运行中的容器能够加上 -f 参数强制删除

docker rm -f 3752f7088a04

这样能够将一个运行的容器强制删除，如果进行的容器能够通过通过 docker rm 删除

docker rm 3752f7088a04

这个时候就把容器给删除掉了

日志挂载优化

存储卷优化

什么是存储卷

“卷”是容器上的一个或多个“目录”，此类目录 可绕过联结文件系统 ， 与宿主机上的某个目录“绑定（关联）”；

​ 在 Docker 中，要想实现数据的长久化（所谓 Docker 的数据长久化即 数据不随着 Container 的完结而完结），须要将数据从宿主机挂载到容器中。

​ Docker 治理宿主机文件系统的一部分，默认位于 /var/lib/docker/volumes 目录中；（最罕用的形式）

存储卷优化写入速度

Docker 镜像由 多个只读层叠加而成 ，启动容器时，docker 会 加载只读镜像层并在镜像栈顶部加一个读写层；

​ 如果运行中的容器批改了现有的一个曾经存在的文件，那该文件将会从读写层上面的只读层复制到读写层，该文件版本依然存在，只是曾经被读写层中该文件的正本所暗藏，此即“写时复制(COW)”机制。

为了防止这种状况，构建 Dockerfile 的时候应该退出一个存储卷

Dockerfile 减少存储卷

减少存储卷

编写 Dockerfile 减少存储卷，减少日志存储卷/logs，这会是一个匿名存储卷

FROM openjdk:8-jdk-alpine
VOLUME /tmp /logs
ADD learn-docker-storage-1.0-SNAPSHOT.jar app.jar
EXPOSE  8003
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

构建镜像

因为咱们原来曾经构建了镜像，这次应用版本号是 0.0.2

# 构建镜像
docker build -t learn-docker-storage:0.0.2 .
# 查看镜像列表
docker images

运行容器

通过 run 命令运行容器

# 运行容器
docker run -d -p 8003:8003 learn-docker-storage:0.0.2
# 查看运行中的容器
docker ps

查看存储卷

通过 docker volume ls 能够看到存储卷

docker volume ls

查看容器信息

咱们发现都是匿名的存储卷，如何来确定都是那个呢，能够通过 docker inspect 容器 ID 来查看存储陈腐

 docker inspect 2041965c3e87|grep Mounts -A20

通过这个命令能够看到数据卷的名称以及宿主机的存储门路，咱们能够间接到宿主机打印日志

 # 进入文件挂载目录
cd /var/lib/docker/volumes/d35de1b7e4631908b05635db4c1f114ab3aafbdf25a9843c068696e66a779c75/_data
# 输入日志
tail -f learn-docker-storage.log

这样就看到了咱们的日志文件

验证存储卷

删除容器查看存储卷开释隐没

# 查看运行的容器列表
docker ps
#删除容器
docker rm -f 2041965c3e87
#查看所有的容器列表(运行 + 进行)
docker ps -a

咱们看到容器曾经被删除了，查看咱们的存储卷

docker volume ls

发现存储卷还存在，数据还是存在的，并且数据也存在

# 查看存储卷列表
docker volume ls
# 查看存储卷详情
docker inspect 296ccc64d919e86bb8329bf6b08447c2ea6a118458d3fcb86d5c7c9a3177dfe0

从新运行镜像启动一个新的容器

# 运行容器
docker run -d -p 8080:8080 e1222496c69f
# 查看运行中的容器
docker ps

启动容器后查看存储卷列表

# 查看存储卷列表
docker volume ls

咱们发现有创立了两个存储卷，查看容器详情

 docker inspect 2041965c3e87|grep Mounts -A20

咱们发现新启动的容器新开了一个匿名存储卷

bind 挂载共享存储

什么是 bind

​ Bind mounts 模式和 Volumes 十分类似，不同点在于 Bind mounts 模式是将宿主机上的任意文件或文件夹挂载到容器，而 Volumes 实质上是将 Docker 服务治理的一块区域（默认是 /var/lib/docker/volumes 下的文件夹）挂载到容器。

共享存储

通过下面的测试，咱们发现每一个容器都是独自用一个存储卷，用于临时文件没有问题的，然而如果要让容器都用同一个存储门路怎么办呢，这个时候就用到了 bind 挂载了，能够应用 -v 进行挂载挂载方才的存储卷。

# 级联创立文件夹
mkdir -p /tmp/data/logs
# 运行容器，指定挂载门路 
docker run -d -v /tmp/data/logs:/logs \
-p 8003:8003 --name learn-docker-storage \
learn-docker-storage:0.0.2

这外面 --name 是指定 docker 容器的名称，咱们操作容器就能够应用名称进行操作了

而后应用 docker inspect 命令来查看容器详情

docker inspect learn-docker-storage|grep Mounts -A20

咱们发现挂载日志的挂载形式曾经变了，由原来的 volume 变为了 bind, 并且挂载门路变为了咱们本人定义的门路，进入目录查看

# 进入目录并浏览目录文件
cd /tmp/data/logs/&&ll
# 打印日志详情
tail -f learn-docker-storage.log

验证共享存储

咱们也依照下面步骤验证下 bind 形式挂载的存储，先删除容器, 查看日志文件是否存在

# 进行并删除容器
docker rm -f learn-docker-storage
# 查看容器曾经被删除了
docker ps -a
# 进入日志挂载门路查看日志是否村咋
cd /tmp/data/logs/&&ll

咱们发现容器被删除然而日志文件还存在本地

启动一个新的容器

# 运行容器，指定挂载门路 
docker run -d -v /tmp/data/logs:/logs \
-p 8003:8003 --name learn-docker-storage \
learn-docker-storage:0.0.2
# 查看日志文件
cat learn-docker-storage.log

咱们发现新的容器的日志文件追加进来了

咱们发现日志曾经追加，咱们让不同的容器挂载同一个目录了

volume 和 bind 的区别

对于多个容器须要共享拜访同一数据目录，或者须要长久化容器内数据（如数据库）时，咱们都是采纳挂载目录模式（bind mounts），将宿主机的某一目录挂载到容器内的指定目录，这种形式能解决问题，但这种形式也始终有一些毛病

• 容器在不同的服务器部署须要依据理论磁盘挂载目录批改门路
• 不同操作系统的文件和目录权限会搞得你昏头转向，火冒三丈 ?

​ bind mount 和 volume 其实都是利用宿主机的文件系统，不同之处在于 volume 是 docker 本身治理的目录中的子目录，所以不存在权限引发的挂载的问题，并且目录门路是 docker 本身治理的，所以也不须要在不同的服务器上指定不同的门路，你不须要关怀门路。

清理 volume 挂载

volume 挂载形式，会生成很多匿名的目录，咱们能够找到对应的没有应用的 volume 进行删除

docker volume ls

通过查看咱们发现外面，有很多的 volume，咱们能够找到没有用的删除

 docker volume rm volume_name

还能够通过命令将没有援用的全副 volume 革除掉，然而这个命令很危险

docker volume prune

这样就将咱们服务器上有效的 volume 革除掉了

网络优化

Docker 网络原理

​ Docker 应用 Linux 桥接，在宿主机虚构一个 Docker 容器网桥(docker0)，Docker 启动一个容器时会依据 Docker 网桥的网段调配给容器一个 IP 地址，称为 Container-IP，同时 Docker 网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就可能通过容器的 Container-IP 间接通信。

​ Docker 网桥是宿主机虚构进去的，并不是实在存在的网络设备，内部网络是无奈寻址到的，这也意味着内部网络无奈通过间接 Container-IP 拜访到容器。如果容器心愿内部拜访可能拜访到，能够通过映射容器端口到宿主主机（端口映射），即 docker run 创立容器时候通过 -p 或 -P 参数来启用，拜访容器的时候就通过 [宿主机 IP]:[容器端口] 拜访容器。

Docker 网络模式

host 模式

​ 如果启动容器的时候应用 host 模式，那么这个容器将不会取得一个独立的 Network Namespace，而是和宿主机共用一个 Network Namespace。容器将不会虚构出本人的网卡，配置本人的 IP 等，而是应用宿主机的 IP 和端口。然而，容器的其余方面，如文件系统、过程列表等还是和宿主机隔离的。

​ 应用 host 模式的容器能够间接应用宿主机的 IP 地址与外界通信，容器外部的服务端口也能够应用宿主机的端口，不须要进行 NAT，host 最大的劣势就是网络性能比拟好，然而 docker host 上曾经应用的端口就不能再用了，网络的隔离性不好。

Host 模式如下图所示

container 模式

​ 这个模式指定新创建的容器和曾经存在的一个容器共享一个 Network Namespace，而不是和宿主机共享。新创建的容器不会创立本人的网卡，配置本人的 IP，而是和一个指定的容器共享 IP、端口范畴等。同样，两个容器除了网络方面，其余的如文件系统、过程列表等还是隔离的。两个容器的过程能够通过 lo 网卡设施通信。

Container 模式示意图

none 模式

​ 应用 none 模式，Docker 容器领有本人的 Network Namespace，然而，并不为 Docker 容器进行任何网络配置。也就是说，这个 Docker 容器没有网卡、IP、路由等信息。须要咱们本人为 Docker 容器增加网卡、配置 IP 等。

​ 这种网络模式下容器只有 lo 回环网络，没有其余网卡。none 模式能够在容器创立时通过 –network=none 来指定。这种类型的网络没有方法联网，关闭的网络能很好的保障容器的安全性。

None 模式示意图

overlay 模式

​ 容器在两个跨主机进行通信的时候，是应用 overlay network 这个网络模式进行通信，如果应用 host 也能够实现跨主机进行通信，间接应用这个物理的 ip 地址就能够进行通信。overlay 它会虚构出一个网络比方 10.0.9.3 这个 ip 地址，在这个 overlay 网络模式外面，有一个相似于服务网关的地址，而后把这个包转发到物理服务器这个地址，最终通过路由和替换，达到另一个服务器的 ip 地址。

bridge 模式

​ 当 Docker 过程启动时，会在主机上创立一个名为 docker0 的虚构网桥，此主机上启动的 Docker 容器会连贯到这个虚构网桥上。虚构网桥的工作形式和物理交换机相似，这样主机上的所有容器就通过交换机连在了一个二层网络中。

​ 从 docker0 子网中调配一个 IP 给容器应用，并设置 docker0 的 IP 地址为容器的默认网关。在主机上创立一对虚构网卡 veth pair 设施，Docker 将 veth pair 设施的一端放在新创建的容器中，并命名为 eth0（容器的网卡），另一端放在主机中，以 vethxxx 这样相似的名字命名，并将这个网络设备退出到 docker0 网桥中。能够通过 brctl show 命令查看。

​ bridge 模式是 docker 的默认网络模式，不写 –net 参数，就是 bridge 模式。应用 docker run - p 时，docker 理论是在 iptables 做了 DNAT 规定，实现端口转发性能。能够应用 iptables -t nat -vnL 查看。

bridge 模式如下图所示

咱们的网络结构

下图是咱们本人的网络结构，咱们是通过宿主机拜访 Mysql 容器的，方才咱们学过，默认 Docker 曾经接入了一个名字叫 bridge 的桥接网络

咱们能够让咱们的网络间接接入桥接网络，例如下图

创立网络

查看网络列表

能够通过 docker network ls 命令查看网络列表

# 查看网络列表
docker network ls

下面就是容器默认几种网络

创立一个桥接网络

默认容器启动会主动默认接入 bridge 的桥接网络，为了辨别咱们的服务也避免各种网络问题，咱们创立一个专用网络，能够通过 docker network create 网络名称 来创立一个默认的桥接网络

# 创立一个桥接网络
docker network create learn-docker-network
# 查看网络列表
docker network ls

服务接入网络

进行并删除原有容器

进行和删除咱们的微服务以及 mysql 服务

# 删除以后运行中的容器
docker rm -f learn-docker-storage nacos mysql

创立 MySQL

因为咱们的微服务依赖 MySQL 先启动 MySQL 并接入网络, 因为 MySQL 不须要通过宿主机拜访，所有也不须要映射端口了，–network 是配置接入哪一个网络

docker run -d \
-v /tmp/etc/mysql:/etc/mysql/mysql.conf.d/ \
-v /tmp/data/mysql:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
--name mysql --network=learn-docker-network \
mysql:5.7.34

这样咱们就把咱们的 MySQL 服务启动起来了并且退出了 learn-docker-network 的网络

创立 Nacos

咱们的 nacos 是须要暴漏端口的，因为咱们须要内部可能看到 nacos 页面，然而咱们也须要咱们的 nacos 连贯到以后网络

docker run -d -p 8848:8848 \
--network=learn-docker-network \
--name nacos --env MODE=standalone \
nacos/nacos-server

查看网络详情

能够通过 docker network inspect 网络名称 能够查看以后的网络的详细信息

docker network inspect learn-docker-network|grep Containers -A 20

批改微服务配置

因为须要应用自定义网络拜访 mysql 容器以及 nacos 容器，须要批改微服务数据库连贯地址，

​ docker 网络拜访 能够通过 IP 或者通过服务名称都是能够的，这里咱们通过 服务名称拜访，因为咱们应用了 maven 打包的形式，咱们只须要将 pom 文件批改就能够

<properties>
    <mysql.addr>mysql:3306</mysql.addr>
    <nacos.addr>nacos:8848</nacos.addr>
</properties>

批改实现后进行编译我的项目

这里将数据库连贯地址改为 mysql 容器的服务名称mysql，nacos 的连贯地址变为了nacos

从新打包服务

将打包的文件上传服务器后依照下面步骤同下面打包，打包版本为 0.0.3

docker build -t learn-docker-storage:0.0.3 .

创立微服务

上面就循序渐进的创立微服务就能够, 只是留神须要退出网络，这里这个端口须要映射外网拜访

docker run -d \
-v /tmp/data/logs:/logs \
-p 8003:8003 \
--name learn-docker-storage \
--network=learn-docker-network \
learn-docker-storage:0.0.3

测试微服务

到当初微服务曾经启动，咱们尝试拜访以下

 curl http://192.168.64.153:8003/storage/employe/findByID/10001 | python -m json.tool

拜访测试数据没有问题，到当初咱们服务曾经搭建实现，并且应用网络进行了优化

本文由传智教育博学谷 – 狂野架构师教研团队公布，转载请注明出处！

如果本文对您有帮忙，欢送关注和点赞；如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源