01--Docker技术的应用实践_docker技术应用与实战

1. Docker技术简介

Docker是一个虚拟化平台( 官网https://www.docker.com/)，诞生于 2013 年初，基于 Google 公司的 Go 语言进行实现。可以通过虚拟化方式，为应用提供可运行的容器。基于这种方式，可更快地打包、测试以及部署应用程序。

现阶段，很多应用软件的安装都基于docker方式的安装进行实现。例如mysql，那么为什么不直接在操作系统中安装一个mysql,而是用容器呢?因为，安装MySql过程并不简单,要配置安装源,安装依赖包,对mysql进行配置…如果要在多台主机上安装,每台主机都要进行这些繁琐的操作,万一服务器挂了,这一系列操作还要再重来一遍，但有了docker,一个安装配置好的mysql容器,可以直接拿到另一台主机上启动,而不必重新安装mysql。另外,docker还有一重要的用处,就是可以保证开发,测试和生产环境的一致。

1.1 版本说明

Docker分为两个版本：Docker EE （企业版）和Docker CE（社区版本），其中，Docker EE由公司支持，可在经过认证的操作系统和云提供商中使用。Docker CE是免费的Docker产品的新名称，Docker CE包含了完整的Docker平台，非常适合开发人员和运维团队构建容器APP。

1.2 Docker参考手册

docker中文免费手册，可参考：https://vuepress.mirror.docker-practice.com。

1.3 Docker的运行机制

可参考官网：https://docs.docker.com/get-started/overview/。

其中：

• Docker Host是我们的docker宿主机（就是安装了docker的操作系统）
• Registry是docker拉取镜像的远程仓库,提供大量的镜像供下载，下载完成之后保存在Images中
• Docker Daemon是docker的服务线程，处理Docker客户端命令。
• Images 是Docker本地的镜像仓库，可以通过docker images查看镜像文件。

例如：docker pull命令的执行过程。
1）客户端将指令发送给docker daemon
2）docker daemon 先检查本地images中有没有相关的镜像
3）如果本地没有相关的镜像，则向镜像服务器请求，将远程镜像下载到本地

2. 安装Docker

2.1 工具准备

（1）准备好VMware虚拟机。
（2）准备好CentOS7。
（3）准备好MobaXterm工具连接虚拟机系统。

2.2 环境准备

第一步：打开VMware虚拟机之后，选择打开虚拟机，再选择存放CentOS7的路径。

第二步：克隆CentOS7，命名为CentOS7964-docker。

说明：
（1）克隆虚拟机中的当前状态；
（2）选择链接克隆，这样更节省空间；

2.3 开启虚拟机系统

第一步：启动虚拟机，默认账号密码d都为root。

第二步：打开终端，通过“ifconfig”指令检查网络。

第三步：通过MobaXterm工具链接虚拟机系统。

2.4 在线安装Docker

第一步：如果电脑上存在旧版的Docker,想要安装新版的Docker,先要卸载旧版。
可在上述的MobaXterm工具命令行中执行下列命令：

sudo yum remove docker-ce \
                docker-ce-client \
                docker-client-latest \
                docker-common \
                docker-latest \
                docker-latest-logrotate \
                docker-logrotate \
                docker-engine
1
2
3
4
5
6
7
8

第二步：安装yum工具
可执行下列命令：

sudo yum install -y yum-utils 
1

第三步：设置yum仓库地址
可执行下列命令（两个地址可任选一个，也可全部设置）：

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
1
2
3

sudo yum-config-manager \
     --add-repo \
     http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
1
2
3

第四步：更新yum的缓存

sudo yum makecache fast    #yum是包管理器
1

第五步：安装新版的Docker

sudo yum install -y docker-ce docker-ce-cli containerd.io
1

3. Docker入门实践

3.1 基本操作

第一步：启动docker

sudo systemctl start docker
1

第二步：设置docker开机自启动

sudo systemctl enable docker
1

第三步：设置镜像加速
由于国内网络问题，需要配置加速器来加速。可通过修改配置文件daemon.json来实现。
下列的命令可直接生成daemon.json文件。

cat <<EOF > /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

说明：执行如上指令时，保证你的登录用户为root管理员用户。
第四步：重新启动服务。
重新加载docker配置

sudo systemctl daemon-reload
1

重启docker服务。

sudo systemctl restart docker
1

第五步：查看镜像配置。

docker info
1

第六步：下载hello-world镜像。

sudo docker pull hello-world
1

第七步：检查docker镜像。

docker images
1

第八步：运行docker镜像。

docker run hello-world
1

第九步：检查已启动的docker服务（正在运行中的）

docker ps
1

如果要查看所有的镜像（包含正在运行和没有运行的镜像容器），可执行如下指令：

docker ps –all   #可以用 docker ps -a 缩写形式
1

第十步：停止docker容器服务

docker stop 容器id
1

第十一步：删除docker容器

docker container rm 容器名或容器id
1

第十二步：删除docker镜像

docker images rm hello-world
1

4. 核心对象分析

4.1 镜像

docker镜像是一个特殊的文件系统，除了提供容器运行时所需要的程序、库、资源、配置等文件外，还包含一些为运行时准备的配置参数（如匿名卷、环境变量、用户等等）。镜像不包含任何动态的数据，其内容在构建之后也不会被改变。
镜像也只是一个虚拟的概念，其实际并不是由一个文件组成，而是由一组文件系统组成，或者说是，由多层文件系统联合组成。

4.2 容器

镜像（images）和容器（container）的关系，就像是光盘和光驱。容器是镜像运行时的载体，容器可以被创建、启动、停止、删除、暂停等。容器的本质是进程，但与直接在宿主机执行的进程不同，容器进程运行于属于自己的独立空间。因此，容器可以拥有自己的root文件系统、网络配置、进程空间、用户ID空间。容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主机系统下操作的一样，这种特性使得容器封装的应用比直接在宿主机中运行更加的安全。

4.3 数据卷

镜像使用的是分层存储方式，容器也是如此。每一个容器运行时，都是以镜像为基础层，在其上创建一个当前容器的存储层（我们可以称这个为容器运行时执行读写操作而准备的存储层），容器存储层的生存周期和容器相同，容器消亡时，容器存储层也随之消亡。因此，保存于容器存储层的信息都会随容器删除而丢失。
按照docker最佳实践的要求，容器不应该向其存储层写入任何数据，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷（volume）,或者绑定在宿主机目录。在这些位置的读写会跳过容器存储层，直接对宿主（或网络存储）发送读写，其性能和稳定性更高。

5. Docker镜像的操作

5.1 下载

第一步：下载 CentOS 镜像 （如果是自己制作镜像，都会先下载一个空的centos镜像,官方镜像仓库地址为https://hub.docker.com/）,如果我们要自己做镜像，则都需要这样的一个空的系统镜像文件。

docker pull centos:7
1

第二步：查看centos7镜像文件。

docker images 或者 docker image ls
1

5.2 运行镜像

通过docker启动运行centos7镜像。

docker run -it  (镜像名或容器id的前3)bash
例如：docker run -it mysql或者7b8 bash
1
2

-it 这是两个参数。一个是-i：交互式操作。一个是-t：终端。我们这里打算进入 bash 执行一些命令并查看返回结果，因此我们需要交互式终端。bash 放在镜像名后面，这里我们希望有个交互式 Shell，因此用的是 bash。

5.3 删除镜像文件

可根据镜像id或镜像名进行删除相应的镜像文件。
例如：删除的镜像id为029c773777e8，镜像id选择其前缀的前三位以上，足够区分即可。

docker image rm 029
1

删除指定镜像名的镜像。

docker image rm nacos
1

6. Docker容器的操作

6.1 容器的启动

通过docker run来创建启动容器（这个容器相当于一个独立的集装箱）。

docker run -it centos:7 bash
1

Docker 在后台运行的标准操作包括：
检查本地是否存在指定的镜像，不存在就从公有仓库下载
利用镜像创建并启动一个容器
分配一个文件系统(简版linux系统)，并在只读的镜像层外面挂载一层可读写层
从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
从地址池配置一个 ip 地址给容器
执行用户指定的应用程序

后台运行

docker run -d centos:7
1

-d代表后台运行容器，容器是否长久的运行，与docker run指定的命令有关，和-d参数无关。

6.2 查看容器信息

查看容器的日志

docker container logs 容器id
1

查看docker中运行的容器

docker ps
1

查看docker中停止的容器

docker ps -a  #-a表示全部
1

6.3 停止或重启容器

停止运行的容器，命令如下：

docker container stop 容器id
1

重新启动容器，命令如下：

docker container restart 容器id
1

6.4 进入指定的容器

当需要进入容器进行相关操作时（容器运行着），可以使用 docker exec 命令，例如：

docker exec -it 802 bash #802为容器id
1

6.5 退出正在运行的容器

假如从宿主机进入了启动的容器，退出容器需要使用exit指令，例如：

exit
1

6.6 删除容器

假如容器不用了，可执行删除操作，例如：

docker container rm 802 #802为容器id
1

其中，如果强制删除运行中的容器，需要添加 -f 参数。

docker container rm -f 802 #802为容器id，空格隔开，可写多个
1

可删除多个容器：

docker rm -f ${docker ps -aq} #先列出所有容器的id,然后一起删除。
1

清理所有退出状态的容器，例如

docker container prune
1

7. Docker的数据管理操作

7.1 概述

在容器中管理数据主要有两种方式：

• 挂载宿主机目录 (Bind mounts)-最常用 (docker run –v 宿主机目录:容器目录)
• 数据卷（Volumes）

7.2 数据卷

数据卷是一个可供一个或多个容器使用的特殊目录，可以在容器之间共享和重用，默认会一直存在，即使容器被删除。

7.3 数据卷操作

第一步：创建数据卷

docker volume create 数据卷名称
docker volume create container-vol
1
2

第二步：查看所有的数据卷

docker volume ls
1

查看指定数据卷的信息

docker volume inspect container-vol
1

查询结果：

[
    {
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/container-vol/_data",
        "Name": "container-vol",
        "Options": {},
        "Scope": "local"
    }
]
1
2
3
4
5
6
7
8
9
10

第三步：启动挂载数据卷的容器

docker run -it --mount source=container-vol,target=/root centos:7 bash
1

或者可以简写为：

docker run -it -v container-vol:/root centos:7 bash
1

说明：-v container-vol:/root 把数据卷container-vol挂载到centos7容器的/root目录上了。

第四步：删除数据卷（如果数据卷被容器正在使用，则无法删除，所以，应该先退出当前容器）

docker volume rm container-vol
1

清理无主数据卷(没有容器使用的数据卷)：

docker volume prune
1

7.3 数据卷挂载到宿主机目录（常用）

启动挂载数据卷的容器

docker run -it -v /usr/app:/opt/app centos:7 bash
1

其中：
（1）/usr/app: 为宿主机目录
（2）/opt/app 为启动容器的目录
（3）-v 用于指定挂载目录，如果宿主机目录不存在，Docker就会自动为你按照挂载目录进行目录的创建。

查看容器的信息：

docker inspect 91a #91a 为容器id
1

8. Dockerfile文件（构建镜像）的应用

8.1 概述

Dockerfile 是一个用来构建镜像的文本文件,文本内容包含了一条条构建镜像所需的指令和说明。我们通常会基于此文件创建docker镜像（所有的镜像文件创建时，都需要一个空的centos镜像）。

8.2 Dockerfile文件 —— 制作jdk镜像

先预先准备好jdk压缩包 jdk-8u51-linux-x64.tar.gz（可从官网下载：oracle.org）。
在创建新的镜像时，都需要有一个Dockerfile文件（文件名一定要注意大小写），这个文件要与准备的资源放在一起（例如：事先下载的jdk），我们可以通过linux系统中的touch指令创建此文件（touch Dockerfile）。

下面，以centos7为基础，构建oracle jdk8的镜像，首先通过vim 打开Dockerfile（这个文件不存在会自动创建），然后进入编辑模式（按字母i）,在编辑模式下可以输入一下命令语句。

第一步：编写FROM语句（关键字一定要大写）。

FROM centos:7
1

第二步：通过ADD命令将宿主机中的压缩包传入镜像容器中的指定目录，并解压。

ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker
1

第三步：设置环境变量（通过ENV关键字实现，目录为启动容器中的目录）。

ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 \
    PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH
1
2

第四步：指定命令行操作（所有指令与后面的内容要有空格）

CMD ['bash']
1

使用Dockerfile构建镜像（在Dockerfile所在目录执行docker指令）

docker build -t jdk:8 .  #不要丢掉这里的点,-t表示镜像标识(镜像名),是tag单词的缩写.
1

注意末尾的点，它表示构建过程中从当前目录寻找文件，jdk:8为我们创建的镜像名。

8.3 运行镜像文件

docker run -it jdk:8 bash
1

进入容器以后，可以通过echo $PATH查看环境变量，并可以通过java -version查看JDK版本信息。

8.4 通过镜像运行web服务（以sentinel为例）

第一步：将sentinel拷贝宿主机指定目录，例如/root/servers目录(servers目录不存在可以自己创建)。

第二步：启动镜像容器，通过java执行运行web服务。
基于jdk:8镜像启动运行sentinel服务(服务启动后可在宿主机通过localhost:8180进行访问)
命令如下：

docker run -d  -p 8180:8080 --name sentinel  \
-v /root/servers:/usr/sca  \ 
jdk:8 java -jar /usr/sca/sentinel-dashboard-1.8.0.jar
1
2
3

例如：

其中，端口映射分析图。

第三步：打开浏览器,访问sentinel服务。
访问时你的ip地址应该为宿主机的ip地址,端口号为宿主机的端口号.例如

8.5 镜像导入、导出操作

镜像导出(linux系统中的镜像文件下载到本地-例如window)，导出后给他人使用。

docker save  jdk:8 | gzip > jdk8.tar.gz  
1

镜像导入（要在jdk8.tar.gz文件所在目录下执行）

docker load < jdk8.tar.gz  
1

8.6 制作Sentinel镜像

第一步：定义Dockerfile文件,同时将jdk,sentinel的压缩包和这个文件放在同一个目录。
执行下列命令：

FROM centos:7
ADD jdk-8u51-linux-x64.tar.gz  /usr/local/
ADD sentinel-dashboard-1.8.0.jar  /usr/local/
ENV JAVA_HOME=/usr/local/jdk1.8.0_51 \
    PATH=/usr/local/jdk1.8.0_51/bin:$PATH
EXPOSE 8080
ENTRYPOINT ["java","-jar","/usr/local/sentinel-dashboard-1.8.0.jar"]

1
2
3
4
5
6
7
8

第二步:使用 Dockerfile 构建镜像(在Dockerfile所在目录执行docker指令)。

docker build -t  sentinel:8 .  #不要丢掉这里的点
1

第三步：运行sentinel容器

docker run -d -p 8180:8080 sentinel:8
1

假如我们要做目录的挂载来保存容器的日志,可参考如下方式:

docker run -d -p 8180:8080 --name sentinel  \
-v /usr/local/docker/sentinel/logs:/root/logs/csp sentinel:8
1
2

第四步:查看sentinel容器

docker ps
1

假如看不到容器,可通过"docker container logs 容器id"方式查看容器状态.

第五步:访问sentinel服务
访问时你的ip地址应该为宿主机的ip地址,端口号为宿主机的端口号.例如

9. 小结分析

10. Docker 安装镜像的操作

10.1 安装MySql数据库

10.1.1 安装步骤

第一步：在hub.docker.com搜索mysql的镜像，查看现有的版本。

第二步：拉取指定版本的mysql。

docker pull mysql:8.0.23
1

第三步：检查mysql镜像。

docker images
1

第四步：启动运行mysql镜像（docker run 用于启动一个容器）

sudo docker run -p 3306:3306 --name mysql \
-v /usr/local/docker/mysql/mysql-files:/var/lib/mysql-files \
-v /usr/local/docker/mysql/conf:/etc/mysql \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:8.0.23
1
2
3
4
5
6
7

假如安装失败，则可通过docker ps -a查看现存的容器。如果已经存在，则通过docker rm 镜像id删除再重新安装即可。

10.1.2 登录mysql服务

第一步：进入容器。

sudo docker exec -it mysql bash
1

第二步：登陆(默认密码root，一定要先进入mysql容器）

mysql -uroot -proot
1

10.1.3 启动和停止mysql服务

第一步：启动mysql服务。

• 启动运行mysql镜像时，mysql就会自动启动。
• 假如mysql服务没有启动运行，但是mysql容器是存在的，可以通过该命令：docker start mysql启动mysql。
• 可设置mysql开机自启动。可通过该命令：docker update mysql --restart=always

第二步：停止mysql服务。

• 可执行该命令：docker stop mysql
• 假如希望查看mysql启动时的日志，可以执行 docker container logs mysql 这个指令。

10.2 安装Redis数据库

10.2.1 安装步骤

第一步：下载镜像文件

docker pull redis
1

第二步：创建redis实例并启动
创建redis配置文件目录

mkdir -p /usr/local/docker/redis01/conf
1

在配置文件目录下创建redis.conf配置文件（因为redis镜像中redis.conf是一个目录，所以要先创建一个配置文件，否则我们本地挂载点也会变成一个目录)

touch /usr/local/docker/redis01/conf/redis.conf
1

启动redis镜像。

sudo docker run -p 6379:6379 --name redis01 \
-v /usr/local/docker/redis01/data:/data \
-v /usr/local/docker/redis01/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf 
1
2
3
4

第三步：查看正在运行的容器。

docker ps
1

10.2.2 访问redis服务器

第一步：控制台直接连接redis测试

docker exec -it redis bash
1

第二步：检测redis 版本

Redis-server –v 或者 redis-cli -v
1

第三步：登录redis(默认不需要密码)

redis-cli
1

或者直接将上面的两个步骤合为一个步骤执行也可以，指令如下：

docker exec -it redis redis-cli
1

10.2.3 启动和停止redis服务

启动redis服务

docker start redis
1

停止redis服务

docker stop redis
1

重启redis服务

docker restart redis
1

设置开机自启redis服务

alwaysdocker update redis01 --restart=always
1

10.3 安装Ngnix（反向代理服务器）

10.3.1 安装步骤

第一步：拉取Ngnix的镜像（可从hub.docker.com查找）

docker pull nginx
1

第二步：查看images镜像

docker images
1

第三步：简单启动（这个目的是为了拿到nginx的默认资源文件，默认会释放到到etc/nginx目录）

docker run --name nginx -d nginx
1

第四步：拷贝安装好的配置文件（将nginx容器服务中的文件拷贝到宿主机指定目录）

docker cp -a nginx:/etc/nginx /usr/local/docker/nginx
1

第五步：强制卸载刚刚安装的nginx

docker rm -f nginx
1

第六步：启动nginx容器，运行nginx镜像。

sudo docker run -p 80:80 --restart always --name nginx \
-v /usr/local/docker/nginx/:/etc/nginx/ \
-v /usr/local/docker/nginx/conf.d:/etc/nginx/conf.d \
-d nginx
1
2
3
4

10.3.2 访问nginx服务

10.3.3 启动和停止nginx服务

启动nginx服务

docker start nginx
1

停止nginx服务

docker start nginx
1

重启nginx服务

docker restart nginx
1

10.3.4 通过数据卷的方式挂载到宿主机上

第一步：创建数据卷

docker volume create nginx-vol
1

第二步：将数据卷挂载到宿主机

docker run -d --name nginx -p 80:80 -v nginx-vol:/etc/nginx nginx:latest
1

10.4 安装Nacos组件

10.4.1 安装步骤

第一步：拉取nacos（hub.docker.com）

docker pull nacos/nacos-server:1.4.1
1

第二步： 在mysql中执行nacos的sql脚本文件
1)将此文件nacos-mysql.sql拷贝到mysql容器的宿主机对应的挂载目录(可通过docker inspect mysql查看你mysql的挂载目录)
2)在linux环境下启动并登录mysql
进入mysql容器(前提是mysql已启动)

docker exec -it mysql bash
1

登录mysql

mysql -uroot -p
1

第三步：通过source指令运行容器目录下的sql文件

source /容器目录、nacos-mysql.sql
1

第四步：创建并启动nacos容器

docker run  \
-e TZ="Asia/Shanghai" \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_DATABASE_NUM=1 \
-e MYSQL_SERVICE_HOST=192.168.64.129 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=root \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
-p 8848:8848 \
--name nacos \
--restart=always \
-d nacos/nacos-server:1.4.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

参数说明

• 单节点模式 MODE=standalone
• 数据库地址 MYSQL_SERVICE_HOST
• 数据库用户名 MYSQL_SERVICE_USER
• 数据库密码 MYSQL_SERVICE_PASSWORD
• 需连接的数据库名称 MYSQL_SERVICE_DB_NAME
• 端口映射 -p 8848:8848

任意时候重启容器，开机就能自动启动容器（需设置docker为开机自启）

--restart=always
1

第四步：检查nacos服务

docker ps
1

假如启动失败，检查启动日志，例如：

docker container logs nacos
1

其中，nacos的启动日志在/home/nacos/logs/start.out文件中。

10.4.2 访问nacos服务

启动nacos，然后在windows中输入http://ip:port/nacos方式进行访问测试

10.4.3 停止和启动nacos服务

停止nacos服务

docker stop nacos
1

启动nacos服务

docker start nacos
1

重启nacos服务

docker restart nacos
1

11. Docker 容器的互联操作

11.1 概述

当Docker中存在多个容器时，容器与容器之间经常需要进行通讯。例如：nacos访问mysql，redis集群中各个节点之间的通讯。

11.2 解决方案

Docker中容器与容器之间进行通讯的解决方案一般有两种：
（1）第一种：两个容器通过宿主机进行通讯。（容器中的端口会映射到宿主机上）
（2）第二种：两个容器之间直接通过虚拟网络进行连接，但是我们需要在docker中创建网络。

11.2 初始化虚拟网络

11.2.1 新建网络

例如：创建名字为：t-net的网络。

docker network create -d bridge t-net  #t-net为自己起的网络名称
1

其中，-d（driver）代表网络类型，默认为：bridge.
创建好这个网络以后，在网络上添加多个容器，这样，容器与容器之间就能通信了。

11.2.2 查看网络信息

列出所有的网络

docker network ls
1

查看网络信息

docker inspect 67d #67d 为创建的网络id
1

11.3实现容器互联

11.3.1 创建容器

打开终端，基于centos：7这个镜像启动容器app1，并加入到t-net这个网络。

docker run -it --name app1 --network t-net centos:7
1

再打开一个新的终端，基于centos:7这个镜像启动容器app2，并加入到t-net这个网络。

11.3.2 测试网络互通

在两个终端中分别执行：

ping app1
ping aap2
1
2

11.3.3 端口映射

客户端要访问宿主机内部运行的容器时，可以在宿主机打开一个端口，当客户单访问这个端口时，可以将访问转发到内部的容器。
通过 -p 参数设置，可以在宿主机上选择一个端口，映射到容器的端口。

# 清理容器
docker rm -f $(docker ps -aq)

# 端口映射
# -p 宿主机端口:容器端口
docker run -d \
--name cat1 \
-p 80:8080 \
tomcat
1
2
3
4
5
6
7
8
9

浏览器访问宿主机映射的端口 80
http://192.168.64.150
看到 tomcat 返回的 404 页，说明已经正常访问到 cat1容器

12. Docker案例

通过docker，实现tomcat访问mysql数据库。

12.1 创建虚拟网络

docker network create --subnet=172.18.0.0/24 dockernet

docker network ls # 查看网络信息
1
2
3

12.2 mysql

12.2.1 加载 mariadb 镜像

docker load < mariadb-docker-image.gz
1

12.2.2 创建数据卷

docker volume create mysql-data
1

12.2.3 启动 mariadb 容器,并挂载数据卷

docker run -d --name mysql -v mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root --net dockernet --ip 172.18.0.11 -p 3306:3306 --restart=always mariadb
1

12.2.4 进入容器,登录mysql测试

docker exec -it mysql bash

mysql -uroot -p
1
2
3

12.2.5 连接数据库并导入sql文件

选择文件：资料/docker/EasyMall/easymall.sql

导入ROOT.war文件

12.3 tomcat

12.3.1 加载 tomcat 镜像

docker load < tomcat7-docker-image.gz
1

12.3.2 启动 tomcat 容器

docker run -d --name web -v /opt/easymall/:/usr/local/tomcat/webapps/ --net dockernet --ip 172.18.0.12 -p 8081:8080 --restart=always tomcat
1

测试