1. Docker介绍

1.1 引言

1.2 Docker的由来

1.3 Docker的思想

2. Docker基本操作

2.1 安装Docker

在centos下安装docker，参考文档： https://docs.docker.com/engine/install/centos/

  1. # 1.下载关于Docker的依赖环境
  2. yum install -y yum-utils
  3. # yum -y install yum-utils device-mapper-persistent-data lvm2
  5. # 2.设置一下下载Docker的镜像源
  6. yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
  8. # 3.安装Docker 
  9. yum makecache fast && yum -y install docker-ce    
  11. # 4. 启动，并设置为开机自动启动，测试
  12. # 启动Docker服务 
  13. systemctl start docker
  14. # 设置开机自动启动 
  15. systemctl enable docker
  16. # 测试
  17. docker run hello-world

2.2 Docker的中央仓库

1.Docker官方的中央仓库∶这个仓库是镜像最全的，但是下载速度较慢。
https://hub.docker.com/

2.国内的镜像网站∶网易蜂巢，daoCloud。。。
https://c.163yun.com/hub#/home
http://hub.daocloud.io/ （推荐使用）

3.在公司内部会采用私服的方式拉取镜像。（添加配置）

  1. // 需要在/etc/docker/daemon.json中配置一下内容
  2. {
  3.     "registry-mirrors":["https://registry.docker-cn.com"],
  4.     "insecure-registries":["ip:port"]
  5. }
  1. # 重启两个服务
  2. systemctl daemon-reload 
  3. systemctl restart docker

2.3 镜像的操作

  1. # 1. 拉取镜像到本地 
  2. docker pul1 镜像名称[:tag]
  3. # 举个栗子
  4. docker pull daocloud.io/library/tomcat:8.5.15-jre8

image.png

2.3.2 查看全部本地的镜像

  1. # 2. 查看全部本地的镜像 
  2. docker images

image.png

2.3.3 删除本地镜像

  1. # 3. 删除本地镜像 
  2. docker rmi 镜像的标识
  3. # 注：如果当前镜像已经有容器在占用，那么需要将该容器停止后删除，才能删除此镜像

image.png

2.3.4 本地镜像的导出和加载

  1. # 4. 镜像的导入导出（不规范）
  2. # 将本地的镜像导出
  3. docker save -o 导出的路径+镜像名称 镜像id
  4. docker save -o ./hello_copy fce289e99eb9  # 将hello world镜像到处到本地目录下，并且镜像名称为hello_copy

image.png

  1. # 加载本地的镜像文件
  2. docker load -i 镜像文件
  3. # 修改镜像名称(注：加载后的镜像是没有名称的，需要修改名称)
  4. docker tag 镜像id 新镜像名称∶版本

image.png

2.4 容器的操作

2.4.1 运行容器

  1. # 简单操作
  2. # 如果使用 镜像名称[:tag] 的方式，那么如果本地没有这个镜像，则会先从仓库中下载，然后运行
  3. docker run 镜像的标识|镜像名称[:tag]
  5. # 常用的参数（推荐使用）
  6. docker run -d -p 宿主机端口（本机端口）:容器端口 --name 容器名称 镜像的标识|镜像名称[:tag]
  7. # 举个栗子
  8. docker run -d -p 8081:8080 --name container1 b8dfe9ade316
  10. # -d∶ 代表后台运行容器
  11. # -p:  宿主机端口∶容器端口∶ 为了映射当前Linux的端口和容器的端口
  12. # --name 容器名称∶指定容器的名称

2.4.2 查看正在运行的容器

  1. # 2.查看正在运行的容器 
  2. docker ps [-qa]
  3. # -a∶ 查看全部的容器，包括没有运行
  4. # -q∶ 只查看容器得到标识

2.4.3 查看容器的日志

  1. # 3. 查看容器的日志 
  2. docker logs -f 容器id
  3. # -f∶可以滚动查看日志的最后几行
  4. # Ctrl + z 退出

2.4.4 进入容器的内部（不建议动容器内部的文件）

  1. #4. 进入到容器内部 
  2. docker exec -it 容器id bash

2.4.5 删除容器

  1. #5. 删除容器
  2. #停止指定的容器
  3. docker stop 容器id
  4. #删除指定容器
  5. docker rm 容器id
  7. #停止全部容器 （删除容器前，需要先停止容器）
  8. docker stop $(docker ps -qa)
  9. #删除全部容器
  10. docker rm $(docker ps -qa)

2.4.6 重启容器

  1. # 启动stopped的容器 或 重新启动running中的容器
  2. docker start 容器id

3. Docker应用

3.1 准备SSM工程

  1. # 在linux本机中，准备ssm.war工程
  2. # MySQL数据库的连接用户名和密码改变了，修改db.properties

3.2 准备Mysql容器

  1. # 运行MySQL容器
  2. # 如果本地没有mysql镜像，则会默认下载daocloud.io/library/mysq1:5.7.4镜像
  3. # -e MYSQLR0T_PASSWORD=root 为mysql指定默认root用户密码
  4. docker run -d -p 3306:3306 --name mysql-container -e MYSQLR0T_PASSWORD=mysql daocloud.io/library/mysql:5.7.7

3.3 准备Tomcat容器

  1. # 运行Tomcat容器，前面已经搞定，只需要将SSM项目的war包部署到Tomcat容器内部即可
  3. # 可以通过命令将宿主机的内容复制到容器内部 
  4. docker cp 文件名称 容器id∶容器内部路径
  5. # 举个栗子
  6. docker cp ssm.war fe:/usr/local/tomcat/webapps/

4. Docker数据卷

数据卷：将宿主机的一个目录映射到容器的一个目录中
可以在宿主机中操作目录中的内容，那么容器内部映射的文件，也会跟着一起改变

4.1 创建数据卷

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

  1. #1.创建数据卷
  2. docker volume create 数据卷名称

4.2 查看数据卷详细信息

  1. #2.查看数据卷的详细信息 
  2. docker volume inspect 数据卷名称

4.3 查看所有数据卷

  1. #3.查看全部数据卷 
  2. docker volume ls

4.4 删除数据卷

  1. #4.删除数据卷 
  2. docker volume rm 数据卷名称

4.5 数据卷映射

补充：tomcat使用docker安装，默认项目路径为/usr/local/tomcat/webapps

  1. #5.应用数据卷
  2. # 当你映射数据卷时，如果数据卷不存在，Docker会帮你自动创建。(会同时映射目录以及目录下的文件)
  3. docker run -v 数据卷名称:容器内部的路径 镜像id
  4. # 直接指定一个路径作为数据卷的存放位置。(这种方式只会映射目录，并不会映射目录下的文件)
  5. docker run -v 路径∶容器内部的路径 镜像id
  7. # 举个栗子 ，注：以下方式会令创建一个容器，所以需要将之前的tomcat容器删除后重新一起创建
  8. docker run -d -p 8081:8080 -v tomcat_volume:/usr/local/tomcat/webapps --name container1 daocloud.io/library/tomcat:8.5.15-jre8

5. 自定义镜像

5.1 Dockerfile文件

中央仓库上的镜像，也是Docker的用户自己上传过去的

  1. # 1.创建一个Dockerfile文件(没有后缀名)，并且指定自定义镜像信息。
  2. # Dockerfile文件中常用的内容:
  3. # - from∶ 指定当前自定义镜像依赖的环境
  4. # - copy∶ 将相对路径下的内容复制到自定义镜像中（相对路径为需要复制的内容对于Dockerfile文件的相对路径）
  5. # - workdir∶ 声明镜像的默认工作目录
  6. # - cmd∶需要执行的命令，例如运行xx程序或者开启xx服务（在workdir下执行的，cmd可以写多的，只以最后一个为准）
  8. # 举个例子，自定义一个tomcat镜像，并且将ssm.war部署到tomcat中 
  9. from daocloud.io/library/tomcat:8.5.15-jre8 
  10. copy ssm.war /usr/local/tomcat/webapps
  1. # 2. 将准备好Dockerfile和相应的文件拖拽到Linux操作系统中，通过Docker的命令制作镜像
  2. docker build -t 镜像名称[:tag]

image.png

6. Docker-compose

6.1 准备

  1. # Step1: 下在docker-compose
  2. https://github.com/docker/compose/releases/dowmload/1.24.1/docker-compose-Linux-x86_64
  4. # Step2: 将下载好的文件，放到linux中
  6. # Step3: 更改名称，赋予权限
  7. mv docker-compose-Linux-x86_64 docker-compose 
  8. chmod 777 docker-compose
  10. # Step4: 添加环境变量，方便使用
  11. mv docker-compose /usr/local/bin 
  12. vi /etc/profile
  13.     export PATH=$JAVA_HOME:/usr/local/bin:$PATH 
  14. source /etc/profile
  16. # Step5: 测试一下,在任意目录下输入docker-compose

6.2 配置docker-compose.yml

使用 Docker-Compose 管理Tomcat和Mysql

  1. version:'3.1'
  2. services:
  3.   mysql:                     # 服务的名称
  4.     restart: always          # 代表只要Docker启动，那么这个容器就跟着一起启动
  5.     image: daocloud.io/library/mysql:5.7.4     # 指定镜像路径
  6.     container_name: mysql    # 指定容器名称
  7.     ports:
  8.       - 3306:3306        # 指定端口号的映射
  9.     environment:
  10.       MYSQL_ROOT_PASSWORD: root         # 指定MySQL的ROOT用户登录密码
  11.       TZ: Asia/Shanghai                 # 指定时区
  12.     volumes:
  13.       - /opt/docker_mysql-tomcat/mysql_data:/var/lib/mysql        # 映射数据卷
  14.   tomcat:
  15.     restart: always          # 代表只要Docker启动，那么这个容器就跟着一起启动
  16.     image: daocloud.io/library/tomcat:8.5.15-jre8     # 指定镜像路径
  17.     container_name: tomcat    # 指定容器名称
  18.     ports:
  19.       - 8080:8080       
  20.     environment:
  21.       MYSQL_ROOT_PASSWORD: root         # 指定MySQL的ROOT用户登录密码
  22.       TZ: Asia/Shanghai                 
  23.     volumes:
  24.       - /opt/docker_mysql-tomcat/tomcat_webapps:/usr/local/tomcat/webapps       
  25.       - /opt/docker_mysql-tomcat/tomcat_logs:/usr/local/tomcat/logs .

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

在使用docker-compose的命令时，默认会在当前目录下找docker-composeyml文件

  1. # 1. 基于docker-compose.yml启动管理的容器 
  2. # -d 后台启动
  3. docker-compose up -d
  5. # 2.关闭并删除容器 
  6. docker-compose down
  8. #3.开启关闭重启已经存在的由docker-compose维护的容器 
  9. docker-compose start|stop|restart
  11. # 4. 查看由docker-compose管理的容器 
  12. docker-compose ps
  14. # 5.查看日志 
  15. docker-compose logs -f

6.4 docker-compose搭配Dockerfile使用

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

6.4.1 docer-compose.yml

  1. # yml文件
  2. version: '3.1'
  3. services:
  4.   ssm:
  5.     restart: always
  6.     build:                           # 构建自定义镜像
  7.       context: ../                   # 指定Dockerfile文件所在路径
  8.       dockerfile: Dockerfile         # 指定Dockerfile文件名称
  9.     image: ssm:1.0.1
  10.     container_name: ssm
  11.     ports:
  12.       8081:8080
  13.     environment:
  14.       TZ: Asia/Shanghai

6.4.2 Dockerfile

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

6.4.3 build

  1. # 可以直接启动基于docker-compose.yml以及Dockerfile文件构建的自定义镜像
  2. docker-compose up -d
  3. # 如果自定义镜像不存在，会帮助我们构建出自定义镜像；
  5. # 重新构建自定义镜像
  6. docker-compose build 
  7. 或
  8. docker-compose up build

7. Docker CI CD

8. Jenkins