Docker

Author：Exchanges

Version：9.0.1

一、引言
二、Docker介绍
- 2.1 Docker的由来
- 2.2 Docker的思想
三、Docker的安装
四、Docker的中央仓库【重点】
五、镜像的操作【重点】
六、容器操作【重点】
七、Docker应用
八、数据卷【重点】
九、Dockerfile自定义镜像【重点】
- 9.1 Dockerfile
- 9.2 通过Dockerfile制作镜像
十. Docker-Compose【重点】
十一. Docker CI、CD（扩展）

一、引言

1.1 环境不一致

我本地运行没问题啊：由于环境不一致，导致相同的程序，运行结果却不一致。

1.2 隔离性

哪个哥们又写死循环了，怎么这么卡：在多用户的操作系统下，会因为其他用户的操作失误影响到你自己编些的程序。

1.3 弹性伸缩

淘宝在双11的时候，用户量暴增：需要很多很多的运维人员去增加部署的服务器，运维成本过高的问题。

1.4 学习成本

学习一门技术，得先安装啊：学习每一门技术都要先安装响应的软件，但是还有他所依赖的各种环境，安装软件成本快高过学习成本啦。

二、Docker介绍

2.1 Docker的由来

一帮年轻人创业，创办了一家公司，2010年的专门做PAAS平台。但是到了2013年的时候，像亚马逊，微软，Google都开始做PAAS平台。到了2013年，公司资金链断裂，不得不倒闭，于是将公司内的核心技术对外开源，核心技术就是Docker。由于开源了Docker，到了2014年的时候，得到了C轮的融资 $4000W，2015年的时候，得到了D轮的融资.$9500W。于是公司开始全神贯注的维护Docker。

Docker主要作者-所罗门

Docker的作者已经离开了维护Docker的团队

2.2 Docker的思想

集装箱：会将所有需要的内容放到不同的集装箱中，谁需要这些环境就直接拿到这个集装箱就可以了。

标准化：

运输的标准化：Docker有一个码头，所有上传的集装箱都放在了这个码头上，当谁需要某一个环境，就直接指派大海去搬运这个集装箱就可以了。

命令的标准化：Docker提供了一些列的命令，帮助我们去获取集装箱等等操作。

提供了REST的API：衍生出了很多的图形化界面，Rancher。

隔离性：Docker在运行集装箱内的内容时，会在Linux的内核中，单独的开辟一片空间，这片空间不会影响到其他程序。

中央仓库|注册中心：超级码头，上面放的就是集装箱

镜像：就是集装箱

容器：运行起来的镜像

三、Docker的安装

3.1 下载Docker依赖的环境

想安装Docker，需要先将依赖的环境全部下载，就像Maven依赖JDK一样

参考：https://developer.aliyun.com/article/110806

如果已安装，可以先删除

[root@localhost ~]# yum -y remove docker-ce

[root@localhost local]# yum -y install yum-utils device-mapper-persistent-data lvm2

3.2 指定Docker镜像源

默认下载Docker回去国外服务器下载，速度较慢，我们可以设置为阿里云镜像源，速度更快

[root@localhost ~]# yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3.3 安装Docker

依然采用yum的方式安装

[root@localhost ~]# yum makecache fast
[root@localhost ~]# yum -y install docker-ce

3.4 启动Docker并测试

安装成功后，需要手动启动，设置为开机自启，并测试一下Docker

# 启动Docker服务
[root@localhost ~]# systemctl start docker
# 测试 hello-world
[root@localhost ~]# docker run hello-world

注：关闭防火墙之后docker需要重启

[root@localhost ~]#service docker restart

四、Docker的中央仓库【`重点`】

Docker官方的中央仓库：这个仓库是镜像最全的，但是下载速度较慢。

https://hub.docker.com/

国内的镜像网站：网易蜂巢，daoCloud等，下载速度快，但是镜像相对不全。

https://c.163yun.com/hub#/home

http://hub.daocloud.io/ （推荐使用）

在公司内部会采用私服的方式拉取镜像，需要添加配置，如下……

https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

# 需要创建/etc/docker/daemon.json，并添加如下内容
{
	"registry-mirrors": ["https://registry.docker-cn.com"],
	"insecure-registries": ["ip:port"]   
}
# 重启两个服务
systemctl daemon-reload
systemctl restart docker

五、镜像的操作【`重点`】

5.1 拉取镜像

从中央仓库拉取镜像到本地

docker pull 镜像名称[:tag]

[root@localhost ~]# docker pull daocloud.io/library/tomcat:8.5.15-jre8

5.2 查看本地全部镜像

查看本地已经安装过的镜像信息，包含标识，名称，版本，更新时间，大小

[root@localhost ~]# docker images

5.3 删除本地镜像

镜像会占用磁盘空间，可以直接手动删除，表示通过查看获取

docker rmi 镜像的标识（需要先删除该镜像创建的容器，删除容器需要先停止容器）

[root@localhost ~]# docker rmi b8dfe9ade316

六、容器操作【`重点`】

6.1 运行容器

运行容器需要制定具体镜像，如果镜像不存在，会直接下载

# 简单操作
docker run 镜像的标识|镜像名称[:tag]

# 常用的参数
docker run -d -p 宿主机端口:容器端口 --name 容器名称 镜像的标识|镜像名称[:tag]
# -d：代表后台运行容器
# -p 宿主机端口:容器端口：为了映射当前Linux的端口和容器的端口
# --name 容器名称：指定容器的名称(自定义)

[root@localhost ~]# docker run -d -p 8888:8080 --name mytomcat8.5 b8dfe9ade316

# 测试：浏览器访问：虚拟机ip:8888（访问之前需要关闭防火墙以及开放安全组中的对应端口号）

6.2 查看正在运行的容器

查看全部正在运行的容器信息

docker ps [-qa]
# -a：查看全部的容器，包括没有运行
# -q：只查看容器的标识

[root@localhost ~]# docker ps

6.3 查看容器日志

查看容器日志，以查看容器运行的信息

docker logs -f 容器id
# -f：可以滚动查看日志的最后几行

[root@localhost ~]# docker logs -f 4411f56f1fbb

6.4 进入容器内部

可以进入容器内部进行操作

docker exec -it 容器id bash

[root@localhost ~]# docker exec -it 4411f56f1fbb bash

# 退出当前容器 exit
root@4411f56f1fbb:/usr/local/tomcat# exit

6.5 复制内容到容器

将宿主机的文件复制到容器内部的指定目录

docker cp 文件名称 容器id:容器内部路径

# 把主机root目录下的a.txt文件拷贝到容器的temp目录下（由于tomcat默认路径在/usr/local/tomcat）
[root@localhost ~]# docker cp /root/a.txt 441:/usr/local/tomcat/temp

# 把容器的temp目录下的a.txt拷贝到主机root目录下
[root@localhost ~]# docker cp 441:/usr/local/tomcat/temp/a.txt /root

6.6 重启&启动&停止&删除容器

容器的启动，停止，删除等操作，后续经常会使用到

# 重新启动容器
[root@localhost ~]# docker restart 容器id

# 启动停止运行的容器
[root@localhost ~]# docker start 容器id

# 停止指定的容器（删除容器前，需要先停止容器）
[root@localhost ~]# docker stop 容器id

# 停止全部容器
[root@localhost ~]# docker stop $(docker ps -qa)

# 删除指定容器
[root@localhost ~]# docker rm 容器id

# 删除全部容器
[root@localhost ~]# docker rm $(docker ps -qa)

七、Docker应用

7.1 Docker安装Tomcat

运行Tomcat容器，为部署SSM工程做准备

# 运行Tomcat容器
[root@localhost ~]# docker run -d -p 8080:8080 --name mytomcat b8dfe9ade316

7.2 Docker安装MySQL

运行MySQL容器，为部署SSM工程做准备

# 拉取MySql镜像
[root@localhost ~]# docker pull daocloud.io/library/mysql:5.7.4

# 运行MySql容器
[root@localhost ~]# docker run -d -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=root daocloud.io/library/mysql:5.7.4

7.3 部署SSM工程

修改SSM工程环境，设置为Linux中Docker容器的信息

通过Maven的package重新打成war包

将Windows下的war包复制到Linux中

通过docker命令将宿主机的war包复制到容器内部

测试访问SSM工程

八、数据卷【`重点`】

为了部署SSM的工程，需要使用到cp的命令将宿主机内的ssm.war文件复制到容器内部。

数据卷：将宿主机的一个目录映射到容器的一个目录中。

可以在宿主机中操作目录中的内容，那么容器内部映射的文件，也会跟着一起改变。

8.1 创建数据卷

创建数据卷之后，默认会存放在一个目录下 /var/lib/docker/volumes/数据卷名称/_data

docker volume create 数据卷名称

#创建一个名为tomcat的数据卷
[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker volume create tomcat
[root@iz8vbdmrir2n6xqzrbd93hz ~]# cd /var/lib/docker/volumes

8.2 查看数据卷详情

查看数据卷的详细信息，可以查询到存放路径，创建时间等等

docker volume inspect 数据卷名称

[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker volume inspect tomcat

8.3 查看全部数据卷

查看全部数据卷信息

docker volume ls

[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker volume ls

8.4 删除数据卷

删除指定数据卷

docker volume rm 数据卷名称

[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker volume rm tomcat

8.5 容器映射数据卷

映射有两种方式：（只有在创建容器的时候才能映射）

第一种：通过数据卷名称映射，如果数据卷不存在。Docker会帮你自动创建，会将容器内部自带的文件，存储在默认的存放路径中。

第二种：通过路径映射数据卷，直接指定一个路径作为数据卷的存放位置。但是这个路径下是空的。

# 第一种：通过数据卷名称映射
docker run -v 数据卷名称:容器内部的路径 镜像id

[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker volume create mytomcat_volume
[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker run -d -p 8080:8080 --name mytomcat -v mytomcat_volume:/usr/local/tomcat/webapps b8
[root@iz8vbdmrir2n6xqzrbd93hz ~]# cd /var/lib/docker/volumes
[root@iz8vbdmrir2n6xqzrbd93hz volumes]# ls
3fdc377f615693578180d1e7433d30e42baa53058eb55ebf86b6c4d0ed27d87a  metadata.db mytomcat_volume
[root@iz8vbdmrir2n6xqzrbd93hz volumes]# cd mytomcat_volume/
[root@iz8vbdmrir2n6xqzrbd93hz mytomcat_volume]# ls
_data
[root@iz8vbdmrir2n6xqzrbd93hz mytomcat_volume]# cd _data/
[root@iz8vbdmrir2n6xqzrbd93hz _data]# ls
docs  examples  host-manager  manager  ROOT


# 第二种：通过路径映射数据卷
docker run -v 路径:容器内部的路径 镜像id

[root@iz8vbdmrir2n6xqzrbd93hz ~]# docker run -d -p 8080:8080 --name mytomcat -v /opt/yangl:/usr/local/tomcat/webapps b8
f70074ae145572c85c00afa5be9c2abb938906238be1c958b51d02806975f8de
[root@iz8vbdmrir2n6xqzrbd93hz ~]# cd /opt/yangl
[root@iz8vbdmrir2n6xqzrbd93hz yangl]# ls
[root@iz8vbdmrir2n6xqzrbd93hz yangl]# mkdir ROOT
[root@iz8vbdmrir2n6xqzrbd93hz yangl]# cd ROOT/
[root@iz8vbdmrir2n6xqzrbd93hz ROOT]# vim index.html

九、Dockerfile自定义镜像【`重点`】

我们可以从中央仓库下载一个镜像，也可以自己手动去制作一个镜像，需要通过Dockerfile去指定自定义镜像的信息

9.1 Dockerfile

创建自定义镜像就需要创建一个Dockerfile，如下为Dockerfile的语言

from: 指定当前自定义镜像依赖的环境
copy: 将相对路径下的内容复制到自定义镜像中

# 制作SSM容器镜像，music.war要放在Dockerfile的同级目录下
# 右键创建文件，命名为：Dockerfile 该文件无后缀，然后在文件添加如下内容
from daocloud.io/library/tomcat:8.5.15-jre8
copy music.war /usr/local/tomcat/webapps

# 在root目录下创建一个目录，然后把Dockerfile文件和music.war都拷贝过来
[root@iz8vbdmrir2n6xqzrbd93hz ~]# mkdir myssm
[root@iz8vbdmrir2n6xqzrbd93hz ~]# cd myssm
[root@iz8vbdmrir2n6xqzrbd93hz myssm]# ls
Dockerfile  music.war

9.2 通过Dockerfile制作镜像

编写完Dockerfile后需要通过命令将其制作为镜像，并且要在Dockerfile的当前目录下，之后即可在镜像中查看到指定的镜像信息，注意最后的 .

docker build -t 镜像名称[:tag] .

[root@iz8vbdmrir2n6xqzrbd93hz myssm]# docker build -t music:1.0 .
Sending build context to Docker daemon  22.56MB
Step 1/2 : from daocloud.io/library/tomcat:8.5.15-jre8
8.5.15-jre8: Pulling from library/tomcat

[root@iz8vbdmrir2n6xqzrbd93hz myssm]# docker images
REPOSITORY                   TAG           IMAGE ID       CREATED         SIZE
music                        1.0           2c3a0c79af30   6 seconds ago   356MB
hello-world                  latest        feb5d9fea6a5   2 months ago    13.3kB
daocloud.io/library/tomcat   8.5.15-jre8   b8dfe9ade316   4 years ago     334MB
daocloud.io/library/mysql    5.7.4         aa5364eb3d85   7 years ago     252MB

#使用构建的music镜像的id运行容器
[root@iz8vbdmrir2n6xqzrbd93hz myssm]# docker run -d -p 8081:8080 --name music-ssm 2c
05d8bc176d23a596a9a2b11d1bac26e3338fb42bb52702af3ffa57f03bebfe8d

十. Docker-Compose【`重点`】

之前运行一个镜像，需要添加大量的参数,可以通过Docker-Compose编写这些参数。而且Docker-Compose可以帮助我们批量的管理容器。这些信息只需要通过一个docker-compose.yml文件去维护即可。

10.1 安装docker-compose

10.1.1 查看

访问 https://github.com/docker/compose/ 查看版本信息

10.1.2 下载

第一种方式：访问github网站，速度较慢

[root@iz8vbdmrir2n6xqzrbd93hz ~]# curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   664  100   664    0     0    326      0  0:00:02  0:00:02 --:--:--   326
100 12.1M  100 12.1M    0     0  22914      0  0:09:15  0:09:15 --:--:-- 27539

第二种方式：若github访问太慢，使用daocloud下载（推荐使用）

curl -L https://get.daocloud.io/docker/compose/releases/download/1.29.2/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

注：如果无法下载，可以找到课件中docker-compose文件目录下，把已经下载好的docker-compose拷贝到/usr/local/bin目录下即可

10.1.3 授权

设置该文件为可执行文件，设置之前可以切换到 /usr/local/bin目录下查看一下

[root@iz8vbdmrir2n6xqzrbd93hz ~]# chmod +x /usr/local/bin/docker-compose

10.1.4 查看版本

切换到 /usr/local/bin目录下

[root@iz8vbdmrir2n6xqzrbd93hz  bin]# docker-compose --version
docker-compose version 1.29.2, build 5becea4c

10.2 docker-compose管理MySQL和Tomcat容器

yml文件以key: value方式来指定配置信息，多个配置信息以换行+缩进的方式来区分，在docker-compose.yml文件中，不要使用制表符。

version: '3.1'
services:
  mysql:           # 服务的名称
    restart: always   # 代表只要docker启动，那么这个容器就跟着一起启动
    image: daocloud.io/library/mysql:5.7.4  # 指定镜像路径
    container_name: mysql  # 指定容器名称
    ports:
      - 3306:3306   #  指定端口号的映射
    environment:
      MYSQL_ROOT_PASSWORD: root   # 指定MySQL的ROOT用户登录密码
      TZ: Asia/Shanghai        # 指定时区
    volumes:
     - /opt/docker_mysql_tomcat/mysql_data:/var/lib/mysql   # 映射数据卷
  tomcat:
    restart: always
    image: daocloud.io/library/tomcat:8.5.15-jre8
    container_name: tomcat
    ports:
      - 8080:8080
    environment:
      TZ: Asia/Shanghai
    volumes:
      - /opt/docker_mysql_tomcat/tomcat_webapps:/usr/local/tomcat/webapps
      - /opt/docker_mysql_tomcat/tomcat_logs:/usr/local/tomcat/logs

10.3 使用docker-compose命令管理容器

在使用docker-compose的命令时，默认会在当前目录下找docker-compose.yml文件，由于docker-compose.yml文件的volumes指定的地址是 /opt/docker_mysql_tomcat，所以我们首先需要在opt目录下创建docker_mysql_tomcat目录，然后进入该目录创建docker-compose.yml文件，并粘贴以上写好的内容

注：如果vim命令用不了，需要安装一下，执行命令即可：yum -y install vim

[root@iz8vbdmrir2n6xqzrbd93hz ~]# cd /opt
[root@iz8vbdmrir2n6xqzrbd93hz opt]# ls
containerd  yangl
[root@iz8vbdmrir2n6xqzrbd93hz opt]# mkdir docker_mysql_tomcat
[root@iz8vbdmrir2n6xqzrbd93hz opt]# ls
containerd  docker_mysql_tomcat  yangl
[root@iz8vbdmrir2n6xqzrbd93hz opt]# cd docker_mysql_tomcat/
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# vim docker-compose.yml

# 停止之前的所有的容器并删除以及镜像
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker images
REPOSITORY                   TAG           IMAGE ID       CREATED       SIZE

# 使用docker-compose命令
# 1. 基于docker-compose.yml启动管理的容器
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose up -d
Creating network "docker_mysql_tomcat_default" with the default driver
Pulling mysql (daocloud.io/library/mysql:5.7.4)...
5.7.4: Pulling from library/mysql

# 2. 查看由docker-compose管理的容器
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose ps
 Name               Command               State                    Ports                  
------------------------------------------------------------------------------------------
mysql    /entrypoint.sh mysqld --da ...   Up      0.0.0.0:3306->3306/tcp,:::3306->3306/tcp
tomcat   catalina.sh run                  Up      0.0.0.0:8080->8080/tcp,:::8080->8080/tcp

# 3. 查看日志
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose logs -f

# 4. 关闭并删除容器
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose down
Stopping tomcat ... done
Stopping mysql  ... done
Removing tomcat ... done
Removing mysql  ... done
Removing network docker_mysql_tomcat_default

# 5. 开启|关闭|重启已经存在的由docker-compose维护的容器: docker-compose start|stop|restart
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose up -d
Creating network "docker_mysql_tomcat_default" with the default driver
Creating mysql  ... done
Creating tomcat ... done
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose restart
Restarting mysql  ... done
Restarting tomcat ... done
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose stop
Stopping mysql  ... done
Stopping tomcat ... done
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose ps
 Name               Command                State     Ports
----------------------------------------------------------
mysql    /entrypoint.sh mysqld --da ...   Exit 0          
tomcat   catalina.sh run                  Exit 143        
[root@iz8vbdmrir2n6xqzrbd93hz docker_mysql_tomcat]# docker-compose start
Starting mysql  ... done
Starting tomcat ... done

10.4 docker-compose配合Dockerfile使用

使用docker-compose.yml文件以及Dockerfile文件在生成自定义镜像的同时启动当前镜像，并且由docker-compose去管理容器

10.4.1 为了方便操作，在盘符下创建docker_ssm文件夹，在该目录下创建Dockerfile文件以及拷贝music.war

编写Dockerfile文件

from daocloud.io/library/tomcat:8.5.15-jre8
copy music.war /usr/local/tomcat/webapps

10.4.2 在docker_ssm目录下创建docker-compose文件夹，在docker-compose目录下创建docker-compose.yml

编写docker-compose.yml文件

version: '3.1'
services:
  wyy_music:  # mysql数据库的名称
    restart: always
    build:            # 构建自定义镜像
      context: ../      # 指定dockerfile文件的所在路径
      dockerfile: Dockerfile   # 指定Dockerfile文件名称
    image: music:1.0
    container_name: ssm-music
    ports:
      - 8081:8080
    environment:
      TZ: Asia/Shanghai

10.4.3 把docker_ssm目录拷贝到虚拟机上的opt目录下，然后测试

步骤如下：

[root@iz8vbdmrir2n6xqzrbd93hz ~]# cd /opt
[root@iz8vbdmrir2n6xqzrbd93hz opt]# ls
containerd  docker_mysql_tomcat  docker_ssm
[root@iz8vbdmrir2n6xqzrbd93hz opt]# cd docker_ssm/
[root@iz8vbdmrir2n6xqzrbd93hz docker_ssm]# ls
docker-compose  Dockerfile  music.war
[root@iz8vbdmrir2n6xqzrbd93hz docker_ssm]# cd docker-compose/
[root@iz8vbdmrir2n6xqzrbd93hz docker-compose]# ls
docker-compose.yml

# 可以直接启动基于docker-compose.yml以及Dockerfile文件构建的自定义镜像
[root@iz8vbdmrir2n6xqzrbd93hz docker-compose]# docker-compose up -d
Creating network "docker-compose_default" with the default driver
Building wyy_music
Sending build context to Docker daemon  22.56MB
Step 1/2 : from daocloud.io/library/tomcat:8.5.15-jre8
 ---> b8dfe9ade316
Step 2/2 : copy music.war /usr/local/tomcat/webapps
 ---> a2cb5f0640e4
Successfully built a2cb5f0640e4
Successfully tagged music:1.0
WARNING: Image for service wyy_music was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating ssm-music ... done

启动浏览器进行测试（注意：提前在mysql创建对应名字的数据库并导入数据）

10.5 docker-compose 搭建 Redis集群

10.5.1 搭建主从

1.创建docker_redis目录，在docker_redis目录下创建docker-compose.yml文件，并编写以下内容：

version: "3.1"
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:6379
    volumes:
      - ./conf/redis1.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis2:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis2
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7002:6379
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
    links:
      - redis1:master
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis3:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis3
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7003:6379
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
    links:
      - redis1:master
    command: ["redis-server","/usr/local/redis/redis.conf"]

2.在docker_redis目录下创建conf目录，在conf目录下分别编写对应的三个文件：

主节点 conf/redis1.conf

save 300 10
#开启aof
appendonly yes
appendfsync always

从节点 conf/redis2.conf conf/redis3.conf

save 300 10
#开启aof
appendonly yes
appendfsync always
# redis2和redis3从节点配置
replicaof master 6379

具体操作流程如下：

#启动测试
[root@localhost ~]# cd /opt
[root@localhost opt]# 
[root@localhost opt]# ls
containerd  docker_mysql_tomcat  docker_ssm
[root@localhost opt]# ls
containerd  docker_mysql_tomcat  docker_redis  docker_ssm
[root@localhost opt]# cd docker_redis/
[root@localhost docker_redis]# ls
conf  docker-compose.yml
[root@localhost docker_redis]# docker-compose up -d
Creating network "docker_redis_default" with the default driver
Pulling redis1 (daocloud.io/library/redis:5.0.7)...
5.0.7: Pulling from library/redis


#访问测试
[root@localhost docker_redis]# docker ps
CONTAINER ID   IMAGE                                    COMMAND                  CREATED          STATUS         PORTS                                       NAMES
830169dcaa85   daocloud.io/library/redis:5.0.7          "docker-entrypoint.s…"   9 seconds ago    Up 7 seconds   0.0.0.0:7003->6379/tcp, :::7003->6379/tcp   redis3
cdae15b806b5   daocloud.io/library/redis:5.0.7          "docker-entrypoint.s…"   9 seconds ago    Up 8 seconds   0.0.0.0:7002->6379/tcp, :::7002->6379/tcp   redis2
978ebeed9459   daocloud.io/library/redis:5.0.7          "docker-entrypoint.s…"   11 seconds ago   Up 9 seconds   0.0.0.0:7001->6379/tcp, :::7001->6379/tcp   redis1

#主节点读写数据
[root@localhost docker_redis]# docker exec -it 978 bash
root@978ebeed9459:/data# ls
appendonly.aof	dump.rdb
root@978ebeed9459:/data# redis-cli
127.0.0.1:6379> set name jack
OK
127.0.0.1:6379> get name
"jack"

#从节点只能读
[root@localhost docker_redis]# docker exec -it cda bash
root@cdae15b806b5:/data# redis-cli
127.0.0.1:6379> get name
"jack"
127.0.0.1:6379> set age 18
(error) READONLY You can't write against a read only replica.

10.5.2 Redis的去中心化模式

去中心化模式：有多个master 组成，每个maser 只负责一部分数据的存储查询。

三主三从，四主四从

重点：master选举

slot：数据槽主要用来数据的管理和迁移

1.创建在/opt目录下创建docker_redis_cluster目录，然后创建docker-compose.yml并编写以下内容：

version: "3.1"
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:7001
      - 17001:17001
    volumes:
      - ./conf/redis1.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis2:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis2
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7002:7002
      - 17002:17002
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis3:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis3
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7003:7003
      - 17003:17003
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis4:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis4
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7004:7004
      - 17004:17004
    volumes:
      - ./conf/redis4.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis5:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis5
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7005:7005
      - 17005:17005
    volumes:
      - ./conf/redis5.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis6:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis6
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7006:7006
      - 17006:17006
    volumes:
      - ./conf/redis6.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]

2.在docker_redis_cluster目录下创建conf目录，在conf目录下创建redis1.conf ~ redis6.conf（共六个文件），依次编写文件中的内容（注意：IP地址改成自己的）：

# redis.conf
# 指定redis的端口号
port 7001
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7001.conf
# 集群的对外ip地址 linux ip
cluster-announce-ip 192.168.25.138
# 集群的对外port
cluster-announce-port 7001
# 集群的总线端口
cluster-announce-bus-port 17001

# redis.conf
# 指定redis的端口号
port 7002
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7002.conf
# 集群的对外ip地址 linux ip
cluster-announce-ip 192.168.25.138
# 集群的对外port
cluster-announce-port 7002
# 集群的总线端口
cluster-announce-bus-port 17002

# redis.conf
# 指定redis的端口号
port 7003
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7003.conf
# 集群的对外ip地址 linux ip
cluster-announce-ip 192.168.25.138
# 集群的对外port
cluster-announce-port 7003
# 集群的总线端口
cluster-announce-bus-port 17003

# redis.conf
# 指定redis的端口号
port 7004
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7004.conf
# 集群的对外ip地址 linux ip
cluster-announce-ip 192.168.25.138
# 集群的对外port
cluster-announce-port 7004
# 集群的总线端口
cluster-announce-bus-port 17004

# redis.conf
# 指定redis的端口号
port 7005
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7005.conf
# 集群的对外ip地址 linux ip
cluster-announce-ip 192.168.25.138
# 集群的对外port
cluster-announce-port 7005
# 集群的总线端口
cluster-announce-bus-port 17005

# redis.conf
# 指定redis的端口号
port 7006
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7006.conf
# 集群的对外ip地址 linux ip
cluster-announce-ip 192.168.25.138
# 集群的对外port
cluster-announce-port 7006
# 集群的总线端口
cluster-announce-bus-port 17006

3.在docker_redis_cluster目录下启动

[root@localhost docker_redis_cluster]# docker-compose up -d
Creating network "docker_redis_cluster_default" with the default driver
Pulling redis1 (daocloud.io/library/redis:5.0.7)...
5.0.7: Pulling from library/redis
68ced04f60ab: Pull complete
7ecc253967df: Pull complete
765957bf98d4: Pull complete
52f16772e1ca: Pull complete
2e43ba99c3f3: Pull complete
d95576c71392: Pull complete
Digest: sha256:ee1d00c5250b5a886b09be2d5f9506add35dfb557f1ef37a7e4b8f0138f32956
Status: Downloaded newer image for daocloud.io/library/redis:5.0.7
Creating redis4 ... done
Creating redis2 ... done
Creating redis3 ... done
Creating redis1 ... done
Creating redis6 ... done
Creating redis5 ... done

4.随意进入一台容器，进行集群组网，执行以下命令（注意：端口号改成自己的）：

redis-cli --cluster create 192.168.25.142:7001 192.168.25.142:7002 192.168.25.142:7003 192.168.25.142:7004 192.168.25.142:7005 192.168.25.142:7006 --cluster-replicas 1

命令解释：--cluster-replicas 1 表示创建的集群每个master有 1 个从机（因为是6台，所以是三主三从，如果是：--cluster-replicas 2 则是二主四从）

[root@localhost docker_redis_cluster]# cd ~
[root@localhost ~]# docker exec -it redis1 bash
root@68f2f2212182:/data# redis-cli --cluster create 192.168.25.138:7001 192.168.25.138:7002 192.168.25.138:7003 192.168.25.138:7004 192.168.25.138:7005 192.168.25.138:7006 --cluster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.168.25.138:7005 to 192.168.25.138:7001
Adding replica 192.168.25.138:7006 to 192.168.25.138:7002
Adding replica 192.168.25.138:7004 to 192.168.25.138:7003
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: 0b1cb33fb1494f6eabf522e3a56a8f4c1623f69c 192.168.25.138:7001
   slots:[0-5460] (5461 slots) master
M: dbc83d01d336194407c6c085e5e668da1ef84262 192.168.25.138:7002
   slots:[5461-10922] (5462 slots) master
M: 8d1ffcd0028adfb7305495548274c609cc02b3b7 192.168.25.138:7003
   slots:[10923-16383] (5461 slots) master
S: 8dd0fd5edbd9464d95535f3efb62c7ef2308c308 192.168.25.138:7004
   replicates dbc83d01d336194407c6c085e5e668da1ef84262
S: 1e4e186a899066443137adc22028152a4c361866 192.168.25.138:7005
   replicates 8d1ffcd0028adfb7305495548274c609cc02b3b7
S: ae7047b36685bf12ea3bc5933a7a501d6180b55f 192.168.25.138:7006
   replicates 0b1cb33fb1494f6eabf522e3a56a8f4c1623f69c
Can I set the above configuration? (type 'yes' to accept):

输入：yes

Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 192.168.25.138:7001)
M: 0b1cb33fb1494f6eabf522e3a56a8f4c1623f69c 192.168.25.138:7001
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: dbc83d01d336194407c6c085e5e668da1ef84262 192.168.25.138:7002
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 8d1ffcd0028adfb7305495548274c609cc02b3b7 192.168.25.138:7003
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 1e4e186a899066443137adc22028152a4c361866 192.168.25.138:7005
   slots: (0 slots) slave
   replicates 8d1ffcd0028adfb7305495548274c609cc02b3b7
S: 8dd0fd5edbd9464d95535f3efb62c7ef2308c308 192.168.25.138:7004
   slots: (0 slots) slave
   replicates dbc83d01d336194407c6c085e5e668da1ef84262
S: ae7047b36685bf12ea3bc5933a7a501d6180b55f 192.168.25.138:7006
   slots: (0 slots) slave
   replicates 0b1cb33fb1494f6eabf522e3a56a8f4c1623f69c
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

5.集群搭建成功，然后进入redis 集群命令进行测试

-c 集群模式执行命令
-h 要登录哪一个节点 ip（对应自己IP地址）
-p 7001 节点对应的端口

root@68f2f2212182:/data# redis-cli -c -h 192.168.25.138 -p 7001
192.168.25.138:7001> set name jack
-> Redirected to slot [5798] located at 192.168.25.138:7002
OK
192.168.25.138:7002> get name
"jack"

十一. Docker CI、CD（扩展）

11.1 CI、CD引言

项目部署

将项目通过maven进行编译打包

将文件上传到指定的服务器中

将war包放到tomcat的目录中

通过Dockerfile将Tomcat和war包转成一个镜像，由DockerCompose去运行容器

项目更新后，需要将上述流程再次的从头到尾的执行一次，如果每次更新一次都执行一次上述操作，很费时，费力。我们就可以通过CI、CD帮助我们实现持续集成，持续交付和部署。

11.2 CI介绍

CI（continuous intergration）持续集成

持续集成：编写代码时，完成了一个功能后，立即提交代码到Git仓库中，将项目重新的构建并且测试。

快速发现错误。

防止代码偏离主分支。

11.3 搭建Gitlab服务器

实现CI，需要使用到Gitlab远程仓库，先通过Docker搭建Gitlab

11.3.1 准备工作

创建一个全新的虚拟机，并且至少指定4G的运行内存，4G运行内存是Gitlab推荐的内存大小。

并且安装Docker以及Docker-Compose

11.3.2 修改ssh的22端口

将ssh的默认22端口，修改为60022端口，因为Gitlab需要占用22端口

vi /etc/ssh/sshd_config
  PORT 22 -> 60022
systemctl restart sshd

11.3.3 编写docker-compose.yml

docker-compose.yml文件去安装gitlab（下载和运行的时间比较长的）

version: '3.1'
services:
 gitlab:
  image: 'twang2218/gitlab-ce-zh:11.1.4'
  container_name: "gitlab"
  restart: always
  privileged: true
  hostname: 'gitlab'
  environment:
   TZ: 'Asia/Shanghai'
   GITLAB_OMNIBUS_CONFIG: |
    external_url 'http://192.168.199.110'
    gitlab_rails['time_zone'] = 'Asia/Shanghai'
    gitlab_rails['smtp_enable'] = true
    gitlab_rails['gitlab_shell_ssh_port'] = 22
  ports:
   - '80:80'
   - '443:443'
   - '22:22'
  volumes:
   - /opt/docker_gitlab/config:/etc/gitlab
   - /opt/docker_gitlab/data:/var/opt/gitlab
   - /opt/docker_gitlab/logs:/var/log/gitlab

11.4 搭建GitlabRunner

查看资料中的gitlab-runner文件即可安装

11.5 整合项目入门测试

11.5.1 创建项目

创建maven工程，添加web.xml文件，编写html页面

11.5.2 编写.gitlab-ci.yml

编写.gitlab-ci.yml文件

stages:
  - test

test:
  stage: test
  script:
    - echo first test ci   # 输入的命令

11.5.3 将maven工程推送到gitlab中

执行git命令推送到Gitlab

git push origin master

11.5.4 查看效果

可以在gitlab中查看到gitlab-ci.yml编写的内容

效果图

11.6 完善项目配置

添加Dockerfile以及docker-compose.yml，并修改.gitlab-ci.yml文件

11.6.1 创建Dockerfile

# Dockerfile
FROM daocloud.io/library/tomcat:8.5.15-jre8
COPY testci.war /usr/local/tomcat/webapps

11.6.2 创建docker-compose.yml

# docker-compose.yml
version: "3.1"
services:
  testci:
    build: docker
    restart: always
    container_name: testci
    ports:
      - 8080:8080

11.6.3 修改.gitlab-ci.yml

# ci.yml
stages:
  - test

test:
  stage: test
  script:
    - echo first test ci
    - /usr/local/maven/apache-maven-3.6.3/bin/mvn package
    - cp target/testci-1.0-SNAPSHOT.war docker/testci.war
    - docker-compose down
    - docker-compose up -d --build
    - docker rmi $(docker images -qf dangling=true)

11.6.4 测试

测试效果

11.7 CD介绍

CD（持续交付，持续部署）

持续交付：将代码交付给专业的测试团队去测试

持续部署：可以直接将指定好tag的代码直接部署到生产环境中

CICD图

11.8 安装Jenkins

11.8.1 编写docker-compose.yml

官网：https://www.jenkins.io/

version: "3.1"
services:
  jenkins:
   image: jenkins/jenkins
   restart: always
   container_name: jenkins
   ports:
     - 8888:8080
     - 50000:50000
   volumes:
     - ./data:/var/jenkins_home

11.8.2 运行并访问Jenkins

第一次运行时，会因为data目录没有权限，导致启动失败

chmod 777 data

访问http://192.168.199.109:8888

访问速度奇慢无比。。。。。

访问成功后，需要输入密码，可在日志中查看

手动指定插件安装：指定下面两个插件即可

publish ssh.

git param.

安装成功后，需要指定上用户名和密码，登陆成功

11.9 配置Jenkins的目标服务器

执行过程为代码提交到Gitlab，Jenkins会从Gitlab中拉取代码，并在Jenkins中打包并发布到目标服务器中。

11.9.1 点击左侧的系统设置

左侧导航

11.9.2 选中中间区域的系统设置

系统设置

11.9.3 搜索Publish over SSH

Publish over SSH

11.9.4 点击上图新增

新增SSH连接

11.10 配置GitLab免密码登录

链接Gitlab需要使用密码，我们可以通过SSH的方式，免密码登陆Gitlab拉取代码，避免每次都输入密码。

11.10.1登录Jenkins容器内部

docker exec -it jenkins bash

11.10.2 输入生成SSH秘钥命令

ssh-keygen -t rsa -C "邮箱（随便写）"

11.10.3将秘钥复制到GitLab的SSH中

配置密钥

11.11 配置JDK和Maven

我们需要再Jenkins中将代码打包，需要依赖JDK和Maven的环境

11.11.1 复制软件到data目录下

效果

11.11.2 在监控界面中配置JDK和Maven

配置环境变量

11.11.3 手动拉取gitlab项目

使用SSH无密码连接时，第一次连接需要手动确定

手动拉取一次

11.12 创建maven任务

实现通过Jenkins的Maven任务，自动去Gitlab拉取代码，并在本地打包，发布到目标服务器上

11.12.1 创建maven工程，推送到GitLab中

随便创建一个即可……

11.12.2 Jenkins的监控页面中创建maven任务

指定GitLab地址

指定maven打包方式

11.12.3 执行maven任务

立即构建，并查看日志

控制台查看日志信息

11.12.4 最终效果

打包成功

11.13 实现持续交付持续部署

实现根据tag标签，实现持续交付和持续部署

11.13.1 安装Persistent Parameter的插件

安装插件

11.13.2 重新指定构建项目的方式

根据标签构建项目

自定义构建

11.13.3 构建项目成功后，需要将内容发布到目标服务器

发布服务器后执行的命令

11.13.4 添加程序代码

# Dockerfile 文件
FROM daocloud.io/library/tomcat:8.5.15-jre8
COPY testcd-1.0-SNAPSHOT.war /usr/local/tomcat/webapps

# docker-compose.yml文件
version: "3.1"
services:
  testcd:
    build: docker
    restart: always
    container_name: testcd
    ports:
      - 8081:8080

11.13.5 测试

根据标签修改发布版本

posted @ 2022-07-10 22:49 qtyanan 阅读(168) 评论(0) 编辑收藏举报

刷新页面返回顶部

Q_ANan

Docker

一、引言

1.1 环境不一致

1.2 隔离性

1.3 弹性伸缩

1.4 学习成本

二、Docker介绍

2.1 Docker的由来

2.2 Docker的思想

三、Docker的安装

3.1 下载Docker依赖的环境

3.2 指定Docker镜像源

3.3 安装Docker

3.4 启动Docker并测试

四、Docker的中央仓库【重点】

五、镜像的操作【重点】

5.1 拉取镜像

5.2 查看本地全部镜像

5.3 删除本地镜像

六、容器操作【重点】

6.1 运行容器

6.2 查看正在运行的容器

6.3 查看容器日志

6.4 进入容器内部

6.5 复制内容到容器

6.6 重启&启动&停止&删除容器

七、Docker应用

7.1 Docker安装Tomcat

7.2 Docker安装MySQL

7.3 部署SSM工程

八、数据卷【重点】

8.1 创建数据卷

8.2 查看数据卷详情

8.3 查看全部数据卷

8.4 删除数据卷

8.5 容器映射数据卷

九、Dockerfile自定义镜像【重点】

9.1 Dockerfile

9.2 通过Dockerfile制作镜像

十. Docker-Compose【重点】

10.1 安装docker-compose

10.1.1 查看

10.1.2 下载

10.1.3 授权

10.1.4 查看版本

10.2 docker-compose管理MySQL和Tomcat容器

10.3 使用docker-compose命令管理容器

10.4 docker-compose配合Dockerfile使用

10.4.1 为了方便操作，在盘符下创建docker_ssm文件夹，在该目录下创建Dockerfile文件以及拷贝music.war

10.4.2 在docker_ssm目录下创建docker-compose文件夹，在docker-compose目录下创建docker-compose.yml

10.4.3 把docker_ssm目录拷贝到虚拟机上的opt目录下，然后测试

10.5 docker-compose 搭建 Redis集群

10.5.1 搭建主从

10.5.2 Redis的去中心化模式

十一. Docker CI、CD（ 扩展 ）

11.1 CI、CD引言

11.2 CI介绍

11.3 搭建Gitlab服务器

11.3.1 准备工作

11.3.2 修改ssh的22端口

11.3.3 编写docker-compose.yml

11.4 搭建GitlabRunner

11.5 整合项目入门测试

11.5.1 创建项目

11.5.2 编写.gitlab-ci.yml

11.5.3 将maven工程推送到gitlab中

11.5.4 查看效果

11.6 完善项目配置

11.6.1 创建Dockerfile

11.6.2 创建docker-compose.yml

11.6.3 修改.gitlab-ci.yml

11.6.4 测试

11.7 CD介绍

11.8 安装Jenkins

11.8.1 编写docker-compose.yml

11.8.2 运行并访问Jenkins

11.9 配置Jenkins的目标服务器

11.9.1 点击左侧的系统设置

11.9.2 选中中间区域的系统设置

四、Docker的中央仓库【`重点`】

五、镜像的操作【`重点`】

六、容器操作【`重点`】

八、数据卷【`重点`】

九、Dockerfile自定义镜像【`重点`】

十. Docker-Compose【`重点`】

十一. Docker CI、CD（扩展）