Docker基本使用与项目部署

1.概述

1.1介绍

Docker 是一个开源的应用容器引擎， 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。也就是说会将所有需要的内容放到不同的集装箱中，谁需要这些环境就直接拿这个集装箱。具有隔离性，即在运行集装箱内的内容时，会在Linux的内核中， 单独的开辟一片空间， 这片空间不会影响到其他程序。

容器是完全使用沙箱机制，

1.2相关术语

注册中心：超级码头， 上面放的就是集装箱
镜像：相当于集装箱
容器：运行起来的镜像

2.下载与安装

2.1docker安装

1）下载关于docker的依赖环境

yum -y install yum-utils device-mapper-persistent-data lvm2

2）设置下载docker的镜像

yum-config-manager  --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3）安装docker

yum makecache fast
yum -y install docker-ce

4）启动

systemctl start docker

5）测试

docker run hello-world

6）设置开机启动

systemctl enable docker

7）安装完成，测试结果，看到下图说明安装成功

8）查看版本

docker -v

9）停止、重启

systemctl stop docker
systemctl restart docker

10）查看docker的状态

systemctl status docker

2.2中央仓库

国外的仓库访问很慢，我们使用国内的仓库http://hub.daocloud.io/

打开网址，搜索需要的容器，如tomcat

 点击搜索的内容

 选择版本后点击拉取

 复制拉取命令，后面可以直接使用

3.镜像的操作

Docker镜像是由文件系统叠加而成，可以认为镜像就是对某些运行环境或者软件打的包，用户可以从docker仓库中下载基础镜像到本地，保证开发人员的环境和测试人员的环境完全一致。

镜像id(镜像标识)也叫IMAGE ID，如果镜像id中前面一部分是唯一的，则可以使用其直接代替整个id。后面的容器id也是类似。实例如下：

可以看到只有两个镜像，对于tomcat镜像，就可以直接使用b8来代替b8dfe9ade316 ，显得非常简单。

3.1基本操作命令

1）拉取镜像到本地

命令语法：

docker pull tag

实例：拉取tomcat镜像到本地

docker pull daocloud.io/library/tomcat:8.5.15-jre8

2）查看本地全部的镜像

ducker images

3）删除本地镜像

命令语法：

docker rmi 镜像标识

实例：

docker rmi b8

4）镜像的导出

命令语法：

docker save -o 导出的路径 镜像id

实例：

docker save -o ./tomcat8.5.image b8

5）加载导出的镜像

命令语法：

docker load -i 镜像路径

实例：

docker load -i tomcat8.5.image

6）修改镜像的名称和tag

命令语法：

docker tag 镜像id 容器名称:版本

实例：

docker tag b8 tomcat:8.5

8）运行容器

命令简单语法：

docker run -d -p 宿主服务端口:容器端口 --name 容器名称 镜像标识或名称

参数分析：

-d:服务后台运行

-p 宿主服务端口:容器端口：指定映射端口。即linux对外暴露的端口:执行的容器的端口

--name 容器名称：指定容器的名称

实例1：

docker run -d -p 9001:8080 --name tomcat b8

实例2：

docker run -d -p 9001:8080 --name tomcat daocloud.io/library/tomcat:8.5.15-jre8

两个实例，运行一个即可。启动后，在浏览器通过ip:9001来访问tomcat。这里tomcat的默认端口是8080，在指定容器的端口时也必须是8080，否则外部无法访问。tomcat是指定容器启动后的名字，是自定义是，不能重复。

实例3：

docker run tomcat

上面的两个实例是在初始化容器，指定了一些参数，而实例3是直接启动，已经启动过并停止的容器，可以使用这种方式。而且上面两个实例都是在后台运行的，还有一种方式不在后台运行

docker run --rm -p 80:80 nginx:2.0

运行容器，关闭运行后会自动删除此容器。

9）查看正在运行的容器

docker ps

可以看到下图的信息，也标注了哪个是容器id

 

查看所有的容器

docker ps -a

10）停止容器的运行

命令语法：

docker stop 容器id

11）重启容器

命令语法：

docker start 容器id

12）查看容器的执行日志

命令语法：

docker logs -f 容器id

13）进入容器内部

命令语法：

docker exec -it 容器id bash

14）删除容器

命令语法：

docker rm 容器id

需要注意的是，删除之前，必须先停止容器的执行。删除之后，再次执行运行容器的命令来启动容器。

15）查看版本信息

docker version

16）查看docker的详细信息

docker info

3.2安装其他的镜像

以下直接使用一行命令拉取并启动容器。

3.2.1把项目部署到tomcat

1）先把项目打成war上传到linux中

2）启动tomcat容器（如果已经启动则不操作）

3）把宿主机的文件复制到容器中

命令语法：

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

实例：

docker cp test.war 222a:/usr/local/tomact/webapps

3.2.2安装mysql

mysql容器启动时需要添加额外的参数，来指明mysql服务的登录名和密码。

docker run -d -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=123456 daocloud.io/library/mysql:5.7.6

安装之后就可以使用连接工具进行连接测试。

3.3 dcoker run参数详解

在启动镜像时，带了很多的参数，下面对常用的进行说明 ：

参数名称	说明	样例
-d	后台启动此容器
-p	端口映射，宿主服务端口:容器端口	8080:8080
--name	指定启动的容器的名称，自定义	tomcat
-e	设置环境变量	MYSQL_ROOT_PASSWORD=123456
-v	目录映射，宿主服务目录:容器目录	/opt/tomcat/webapps:/usr/local/tomcat/webapps

4.数据卷

4.1介绍

数据卷就是把宿主机的目录与容器的某一个目录进行映射。容器中的文件操作起来比较麻烦，就直接操作宿主机的文件，容器可以动态的使用这些文件。

4.2操作

1）创建数据卷

创建的数据卷默认存放在/var/lib/docker/volumes/目录下。

命令语法：

docker volume create 数据卷名称　

实例：

docker volume create test

2）查看数据卷详细信息

命令语法：

docker volume inspect 数据卷名称

实例：

docker volume inspect test

3）查看全部的数据卷

docker volume ls

4）删除数据卷

命令语法：

docker volume rm 数据卷名称

实例：

docker volume rm test

5）映射数据卷

第一种：

命令语法：

docker run -v 数据卷名称:容器内部映射的路径 镜像id　

实例：

docker run -v tomcat:/usr/local/tomcat/webapps b8

可以看到webapps下的文件已经复制到指定的数据卷

　

这种方式直接映射数据卷时，如果数据卷不存在，Docker 会自动创建，将容器内部自带的文件存储在默认的存放路径中。

第二种：

命令语法：

docker run -v 路径:容器内部映射的路径 镜像id　

实例：　

docker run -v /usr/bk:/usr/local/tomcat/webapps b8

映射后里面是空的

在映射时直接指定一个路径作为数据卷的存放位置，映射后这个文件夹是空的。

5.Docker-Compose

5.1介绍

解决运行镜像输入大量参数的问题，批量管理容器。只需要配置docker-compose.yml即可。

5.2下载与安装

1）下载

下载地址：https://github.com/docker/compose/releases/tag/1.24.1,也可以使用其他的版本。

2）把下载的文件复制到linux的/usr/local/bin目录下

3）修改其名称并给与操作权限

mv docker-compose-Linux-x86_64 docker-compose
chmod 777 docker-compose

4）添加环境变量，可全局使用

vi /etc/profile
#在尾部追加
export PATH=$PATH:/usr/local/bin
#刷新
source /etc/profile

5）测试

在任意目录下输入

docker-compose

看到下图说明安装成功。

5.3基本配置

只需要在其目录下创建一个docker-compose.yml文件，然后输入相关配置即可。

一般会把映射的文件放在/opt目录下，因此先在/opt目录下新建一个文件夹，存放配置文件和其他文件

cd /opt
mkdir docker_mysql_tomcat
cd docker_mysql_tomcat
touch docker-compose.yml

docker-compose.yml中mysql和tomcat的配置如下，其他容器同：

version: '3.1'
services:
  #服务的名字
  mysql:
    #只要docker，此容器也启动
    restart: always
    #指定镜像路径
    image: daocloud.io/library/mysql:5.7.6
    #设置容器名称
    container_name: mysql
    #设置端口号映射
    ports:
      - 3306:3306
    environment:
      #设置服务登录的密码
      MYSQL_ROOT_PASSWORD: 123456
      #设置时区
      TZ: Asia/Shanghai

  tomcat:
    restart: always
    image: daocloud.io/library/tomcat:8.5.15-jre8
    container_name: tomcat
    ports:
      - 9001: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

在上述的配置中，environment中使用的是key: value方式，其实也可以使用列表（-和=）方式，关键代码如下：

    environment:
      #设置服务登录的密码
      - MYSQL_ROOT_PASSWORD=123456
      #设置时区
      - TZ=Asia/Shanghai

这两种方式都是可以的，可以相互替换。也就是说，对于凡是可以使用列表方式的地方，都可以使用key: value方式；对于凡是可以使用key: value方式的地方，都可以使用列表方式。可根据自己的想法选择。不过需要注意的是，使用key: value方式是，在冒号后面与value直角必须留一个空格。

5.4操作命令

1）启动管理的容器，需要在对应的yml目录中运行

docker-compose up -d

2）关闭并删除管理的容器

docker-compose down

3）开启（关闭stop、重启restart）已管理的容器

docker-compose start

4）查看由docker-compose管理的容器

docker-compose ps

5）查看日志

docker-compose logs -f

yml配置后在/opt/docker_mysql_tomcat目录执行上面的启动命令，就可以同时启动这两个容器，也是可以访问的。

6.自定义镜像Dockerfile

6.1介绍

在前面介绍了中央仓库，里面的镜像其实也有docker用户自己上传的，我们也可以自定义镜像。常用的命令如下，具体使用见后面：

命令	说明
from	指定镜像要依赖的环境，如tomcat
env	设置环境变量（可设置多条）
run	要执行的命令（可设置多条）
add	把宿主机的文件复制到容器内容,如果是压缩文件会自动解压
copy	同add，但是压缩文件不会自动解压
workdir	设置工作目录

6.2使用Dockerfile自定义镜像

1）先创建一个目录，存放Dockerfile文件

cd /opt
mkdir dockerfile

2）把自己的war包放到这个目录下

我的war可以下载后使用，链接：https://pan.baidu.com/s/1Nn17bKJeaxAspfQN_wAKig 提取码：1235

3）创建Dockerfile文件，内容如下

FROM daocloud.io/library/tomcat:8.5.15-jre8
RUN rm -rf /usr/local/tomcat/webapps/*
ADD springboot.war /usr/local/tomcat/webapps

上面的命令分析：从仓库中使用tomcat镜像，然后删除webapps下面的文件，把war包放到webapps下。

4）生成镜像

docker build -t springboot:1.0 .

springboot:1.0指定自定义镜像的名称和版本号，点表示war包和Dockerfile文件是在同一目录下。

5）启动镜像

docker run -d -p 8080:8080 --name springboot 33

6）测试

在浏览器之间访问对应的路径，这里是http://192.168.101.33:8080/springboot/api/user，可以看到返回的正常数据。

6.3结合docker-compose自定义镜像

1）结合上一步的操作，在/opt/dockerfile目录下新建docker-compose.yml，内容如下

version: '3.1'
services:
  #服务的名字
  springboot:
    #只要docker，此容器也启动
    restart: always
    #构建自定义镜像
    build:
      #设置dockerfile的路径
      context: .
      #指定dockerfile的名称
      dockerfile: Dockerfile
    #指定镜像路径,这里使用自己的镜像
    image: springboot:2.0
    #设置容器名称
    container_name: springboot
    #设置端口号映射
    ports:
      - 8080:8080
    environment:
      #设置时区
      TZ: Asia/Shanghai

其中version是指定docker-compose的版本。

2）使用docker-compose启动容器。如果上一步的镜像没有停止，请先停止后再启动。

docker-compose up -d

如果需要重新构建自定义镜像，可使用下面的命令

docker-compose build

7.安装Jenkins

7.1介绍

https://www.jenkins.io/

7.2安装与运行

1）在/opt目录下新建一个文件夹，映射jenkins

mkdir docker_jenkins

2）配置docker-compose.yml

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

3）启动运行，等待文件下载完成，查看日志发现data文件夹没有授权

docker-compose up -d

docker-compose logs -f

4）给data权限，然后再次运行后查看日志

chmod 777 data

docker-compose restart

看到下图说明运行成功

5）在浏览器访问http://192.168.1.161:8888即可看到jenkins在初始化网络，然后在登录页面输入上图中的密码

6）点击选择插件来安装

7）搜索安装必要的插件，这里安装git和publish

 

选择好后点击安装，会安装插件，这个过程需要一段时间，网络良好的话两个小时左右，

 8）创建管理员账户

 9）配置实例页面不用选择，直接下一步即可

10）进入首页，如下图

7.3配置

7.3.1配置docker集群

1）安装插件

打开系统管理->插件管理，选择可选插件后在搜索框输入docker

选择后进行安装，安装完成后需重启jenkins，同理需要安装SSH、Locale、Version Number和Maven插件。SSH是后面连接docker要用到的，Locale是中文插件，把语言切换为中文，Version Number。安装完成后需重启jenkins。

2）开启docker的2375端口，用于远程访问

打开docker的配置文件，添加参数

vi /usr/lib/systemd/system/docker.service

参数配置如图

可复制的参数

-H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock

配置后保存，重启docker

systemctl daemon-reload
systemctl restart docker

3）配置dcoker集群

打开系统管理->系统配置，找到下图的地方，点击

 选择docker详情

配置docker，点击测试，测试成功会显示版本号等信息。

7.3.2配置全局的jdk和maven

第一步：把jdk和maven的压缩包上传到linux，然后把文件都解压到/opt/docker_jenkins/data目录下，这个目录和/var/jenkins_home是映射关系（7.2中配置的）。

第二步：打开系统管理->全局工具配置，分别点击jdk安装和maven安装来配置jdk和maven，配置如下图

7.3.3添加凭据

由于后面要用到虚拟机，就先添加一个虚拟机的凭证。方法是在系统管理中，找到下图的安全凭证，

进去之后点击全局后面的三角，

添加一个凭证

 保存后在系统配置中配置SSH远程主机信息，配置后点击连接进行测试。

8.jenkins+docker实现SpringBoot项目自动化部署

8.1项目准备

新建一个springboot的项目，这是使用springboot-test来创建项目，但是指定的打包名是springboot（详见源码https://github.com/zhongyushi-git/springboot-test.git），写一个简单的测试接口。然后在项目的根目录下新建一个Dockerfile的文件，内容如下

#设置tomcat镜像
FROM daocloud.io/library/tomcat:8.5.15-jre8
#删除webapps下面之前的war包
RUN rm -rf /usr/local/tomcat/webapps/*.war
#把新的war包放webapps下面
ADD target/springboot.war /usr/local/tomcat/webapps
#切换到指定目录,如果不需要修改端口号可不加这两行
#WORKDIR /usr/local/tomcat/conf/
#设置tomcat的启动端口
#RUN sed -i 's|"8080"|"9020"|' server.xml

说明：

1）/usr/local/tomcat是官方给出的tomcat容器的目录，若使用不同的tomcat镜像，请参考官网。

2）springboot.war是我定义的名称，可自定义，接着把项目推送到github上。在这个配置文件中，后两行代码是来修改tomcat的启动端口的，也就是把tomcat默认的8080端口改为9020，可根据需要进行使用。如果这里改变了端口，那么在后面的任务配置中也要做相应的修改。

3）springboot的项目有内置的tomcat，要想在外部的tomcat中部署，需要做相应的打包准备，详见https://www.cnblogs.com/zys2019/p/11945450.html#_label13。

8.2任务配置

1）选择新建任务，创建一个maven任务

 2）配置源码

3）设置忽略test文件

-U clean install -DskipTests=true

如果pom.xml不是在项目的路径下，而是在下一层目录，则可写为下一层目录/pom.xml

4）配置版本规则

VERSION_NUMBER

${JOB_name}_${BUILD_DATE_FORMATTED,"yyyyMMdd"}

5）在Post Steps下点击add  post-build Stepst添加构建docker镜像

springboot:${VERSION_NUMBER}.${BUILD_NUMBER}

如果Dockerfile文件不是在当前目录下，而在docker目录下，那么上面的位置就是./docker

 6）再添加一个SSH，用于打包后启动tomcat容器，如图

配置命令：

docker rm -f springboot
docker run -d -p 8080:8080 --name springboot springboot:${VERSION_NUMBER}.${BUILD_NUMBER}

这样设置后，进行构建，版本信息显示格式是springboot_20200727.4。如果在Dockerfile文件中修改了tomcat的端口，那么这里也要做相应的修改，把容器的端口改为对应的端口

docker run -d -p 8080:9020 --name springboot springboot:${VERSION_NUMBER}.${BUILD_NUMBER}

8.3构建测试

在上面的任务中，选择左侧的立即构建

在下面看到在构建的任务，点击进行，选择控制台输出，可以看到构建过程中的部分日志信息。构建成功后就可以直接访问项目了，虚拟机ip:8080/项目请求的路径（这里是http://192.168.159.129:8080/springboot/test）。后期使用起来就很方便了，把更新后的项目提交到github，然后进行jenkins上，点击构建即可。

8.4加入mysql服务

在前面的springboot项目中，并没有使用数据库，但是在实际开发中会用数据库，就简单介绍一下。在源码中，并没有看到mysql的使用，因为我只写了一个简单的模板，可以根据需要自行添加，下面的创建表和访问数据接口也需要自行添加。

1）在docker中新建一个目录，编写docker-compose.yml文件，配置mysql服务并启动

version: '3.1'
services:
  #服务的名字
  mysql:
    #只要docker，此容器也启动
    restart: always
    #指定镜像路径
    image: daocloud.io/library/mysql:5.7.6
    #设置容器名称
    container_name: mysql
    #设置端口号映射
    ports:
      - 3306:3306
    environment:
      #设置服务登录的密码
      MYSQL_ROOT_PASSWORD: 123456
      #设置时区
      TZ: Asia/Shanghai

2）导入mysql和mybatis等相关的坐标

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

版本控制如下：

 <properties>
       <druid.version>1.1.9</druid.version>
        <fastjson.version>1.2.47</fastjson.version>
        <mybatis.version>1.3.2</mybatis.version>
 </properties>

3）编写配置文件和接口

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://172.17.0.1:3306/db2020?serverTimezone=CTT
spring.datasource.username=root
spring.datasource.password=123456

把配置文件的一部分单独拿出来，原因是ip必须是docker服务对应的ip，只有这个ip才能在本地访问容器中的mysql服务。

4）创建数据库。连接到docker中的mysql，数据库和表请自行创建。

5）测试。把项目提交到github上后进行构建，自定义的查询数据库的接口是正常的。

8.5加入redis服务

加入redis服务同mysql，在此略。

version: '3.1'
services:
  redis:
    restart: always
    image: redis
    container_name: redis
    ports:
      - 6379:6379
    command: redis-server --requirepass 123456
    environment:
      TZ: Asia/Shanghai
    volumes:
      - ./data:/data

9.jenkins+docker实现Vue项目自动化部署

9.1项目准备

1）新建一个vue的项目，写一个简单的测试页面。然后在项目的根目录下新建一个Dockerfile的文件，内容如下

FROM nginx
COPY dist /usr/share/nginx/html/
COPY nginx.conf /etc/nginx/nginx.conf

2）在根目录下创建一个nginx.conf，内容如下

worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    server {
        listen       9999;
        server_name  localhost;
        location / {
            root   /usr/share/nginx/html;
            try_files $uri $uri/ /index.html;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

红色的内容可自行修改。项目源码：https://github.com/zhongyushi-git/vue-print.git

9.2任务配置

1）下载nodeJs的压缩包，然后解压到/opt/jenkins_docker/data下

2）在jenkins中安装nodeJs插件，然后重启jenkins

3）配置全局工具nodeJs

4）新建一个自由风格的软件项目

5）源码配置

6）配置版本规则

VERSION_NUMBER

${JOB_name}_${BUILD_DATE_FORMATTED,"yyyyMMdd"}

7）配置ndoeJS

在构建环境中设置nodeJS的路径

 8）构建打包

配置：

echo $PATH
node -v
npm -v
npm config set registry https://registry.npm.taobao.org/
npm install
npm run build

9）构建镜像

 test:${VERSION_NUMBER}.${BUILD_NUMBER}

10）启动镜像

docker rm -f test
docker run -d -p 8080:9999 --name test test:${VERSION_NUMBER}.${BUILD_NUMBER}

11）构建测试

在上面的任务中，选择左侧的立即构建，构建成功后就可以测试，页面能正常访问。

10.常见问题

10.1 Bind for 0.0.0.0:80 failed: port is already allocated

这个问题的意思就是容器占用的port还没有完全释放。

查看进程，发现相关的容器并没有在运行，而 docker-proxy 却依然绑定着端口：

docker ps

查看被docker-proxy占用的端口

ps -aux | grep -v grep | grep docker-proxy

停止 doker 进程，删除所有容器，然后删除 local-kv.db 这个文件

service docker stop
docker rm $(docker ps -aq)
rm /var/lib/docker/network/files/local-kv.db
service docker start

10.2 Jenkins时区设置为北京时间

打开 【系统管理】->【脚本命令行】运行下面的命令

System.setProperty('org.apache.commons.jelly.tags.fmt.timeZone', 'Asia/Shanghai')

10.3如何进行jenkins容器内部

docker exec -it jenkins bash

如果需要进入其他容器内部，只要把jenkins换成对应的容器名称或容器id即可。

10.4怎么把外部文件复制到容器内部？

docker cp /opt/jenkins.sh fd:/usr/local/bin

上面就是把/opt下面的jenkins.sh复制到jenkins容器的/usr/local/bin目录下，复制的时候，要指定容器的id。同理也可以把容器内部的文件复制到外部。容器内部一般贸易vi命令，因此会把容器内部的文件复制出来修改后再复制到内部。

10.5若直接安装jenkins，则打包的文件在哪里？

在用户根目录下.jenkins/workspace/projectname/target/