Docker 入门及实战

初识 Docker

我们写的代码会接触好几个环境：开发环境、测试环境、生产环境，为了解决不同的环境下代码的运行环境及依赖包的统一（软件跨环境迁移问题），就有了 docker。

Docker 概念

• Docker 是一个开源的应用容器引擎
• Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 服务器上
• 容器是完全使用沙箱机制，相互隔离（微服务中大量使用 docker 的原因）
• 容器性能开销极低
• Docker 从 17.03 版本之后分为 CE（Community Edition:社区版）和 EE（Enterprise Edition:企业版）

总结：Docker 是一种容器技术，解决软件跨环境迁移问题

安装 Docker

# 1. yum 包更新到最新
yum update
# 2. 安装需要的软件包，yum-util 提供 yum-config-manager 功能，另外两个是 devicemapper 驱动依赖的
yum install -y yum-utils device-mapper-persistent-data lvm2
# 3. 设置 yum 源
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 4. 安装 docker, 出现输入的界面都按 y
yum install -y docker-ce
# 5. 查看 docker 版本，验证是否安装成功
docker -v

可能碰到的问题："yum-config-manager: command not found" 是因为系统默认没有安装这个命令，这个命令在 yum-utils 包里，可以通过命令yum -y install yum-utils 安装 yum-utils。

Docker 架构

这个图片要竖着看，也就是说架构总的分为三部分：Clients、Hosts(主机，docker的核心)、Registries(仓库，存放镜像文件)。Clients 就是 Docker 客户端，用来发送一些指令给到 daemon(docker 服务的守护进程)；Hosts 分为 local host 和 remote host，在 docker 安装完成后 docker 服务就会在后台运行（也就是图中的 daemon），docker 服务中（图中 daemon）包含了 Image 和 container；Registries 是存放镜像的仓库，分为官方仓库（Docker hub）和私有仓库（private registry，又称为私服）

• 镜像（Image）：Docker 镜像（Image）,就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.0.4 就包含了完整的一套 ubuntu16.0.4 最小系统的 root 文件系统。
• 容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
• 仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

配置 Docker 镜像加速器

官方仓库（Docker hub）服务器在国外，国内下载官方镜像有点慢，所以一般都会配置一个国内的镜像加速器：

• USTC：中科大镜像加速器（https://docker.mirrors.ustc.edu.cn）
• 阿里云（推荐）
• 网易云
• 腾讯云

阿里云容器镜像加速器配置

阿里云为每个用户都提供了一个不同的镜像加速器地址。

登录阿里云->点击左上角菜单选择产品与服务->搜索镜像

其它的都大同小异，只是把配置文件中的地址更换一下就可以

Docker 命令

由架构图可以看出，主机中的docker服务分为镜像和容器两部分，所以命令的总节就针对三部分来：docker 服务相关命令、镜像相关命令、容器相关命令

Docker 服务相关命令

针对架构图中的 daemon 部分

• 启动 docker 服务

  systemctl start docker

• 停止 docker 服务

  systemctl stop docker

• 重启 docker 服务

  systemctl restart docker

• 查看 docker 服务状态

  systemctl status docker

• 开机启动 docker 服务

  systemctl enable docker

Docker 镜像相关命令

• 查看镜像（针对本地）

  docker images

  REPOSITORY: 仓库名称
  TAG: 版本号，下载镜像文件时需要指定版本号，默认为 latest
  IMAGE ID: 镜像 ID 对镜像删除时使用
  CREATED: 创建时间
  SIZE: 镜像大小

• 搜索镜像（针对远程仓库）

  docker search redis
  NAME: 镜像名称
  DESCRIPTION: 描述信息
  STARS: 类似于 github 的 star
  OFFICIAL: 是否是官方, [OK]代表官方
  AUTOMATED: 是否自动流程构建的

  通过命令搜索不到镜像版本号，如何搜索镜像都有哪些版本呢？我们以 redis 为例：

  1. 进入 hub.docker.com 网站

  2. 搜索 redis 后进入这个页面，点击蓝色处，进入下一个页面，在下一个页面中就会展示版本
     

     

• 拉取镜像（针对远程仓库）

  docker pull redis
  命令最后不跟版本号，将下载最新的版本，版本号为 lastest。指定拉取版本如下：
  docker pull redis:5.0

• 删除镜像（针对本地）

  docker rmi [IMAGE ID]
  如果不同镜像之间 IMAGE ID 相同，我们可以通过 REPOSITORY:TAG 来删除
  docker rmi [REPOSITORY]:[TAG]
  

  删除所有镜像

  • docker images -q 可以罗列出所有镜像的 ID
  • docker rmi`docker images -q` 删除所有镜像

Docker 容器相关命令

• 查看容器

  docker ps # 查看现在正在运行的容器
  docker ps -a # 查看所有容器
  

  CONTAINER ID: 容器ID
  IMAGE: 创建该容器的镜像
  COMMAND: 进入容器初始化执行的命令，有些镜像会有默认命令，比如：centos 的默认命令为/bin/bash
  CREATED: 创建时间
  STATUS: 是否退出，例如：Up 23 seconds，Exited (0) 5 minutes ago
  PORTS: 映射端口
  NAMES: 创建镜像时起的名字

• 创建容器并启动容器

  docker run 参数

  • docker run -it --name=c1 centos:7 /bin/bash
    参数：

    • -i 表示容器一直运行
    • -t相当于给容器分配一个伪终端，通常与-i同事使用缩写为-it
    • --name=c1 也可以写为 --name c1 表示给容器起名字
    • cenos:7 这是在制定镜像名字和版本号
    • /bin/bash 打开一个bash交互界面

    注意：

    • -it创建的容器会立即进入容器内部，退出容器后，容器将关闭

  • docker run -id --name=c2 centos:7
    参数：

    • -d : 以守护（后台）模式运行容器。创建后不会立即进入容器，-id是-i与-d的缩写

    注意：

    • 此命令中加上/bin/bash会立即进入容器内部
    • 进入c2容器内部的命令docker exec -it c2 /bin/bash，进入后输入exit退出容器后，容器不会被关闭，这也是-it与-id的区别

  • 总结：-it创建的容器一般称为交互式容器，-id创建的容器一般称为守护式容器

• 进入容器

  docker exec -it c2 /bin/bash
  配合【创建并启动容器】部分看

• 启动容器

  docker start [CONTAINER ID] # 用容器id启动
  docker start [NAME] # 用容器name启动
  

• 停止容器

  docker stop [CONTAINER ID] # 用容器id停止
  docker stop [NAME] # 用容器name停止
  

• 删除容器

  docker rm [CONTAINER ID] # 用容器id删除一个容器
  docker rm [NAME] # 用容器name删除一个容器
  docker rm `docker ps -aq` # 删除所有容器
  

• 查看容器信息

  docker inspect [CONTAINER ID] # 用容器id查看容器信息
  docker inspect [NAME] # 用容器name查看容器信息
  

Docker 容器的数据卷

数据卷概念及作用

思考：

• Docker容器删除后，在容器中产生的数据还在么？

  ? docker 容器中的数据没了，但是数据卷目录中的数据还在

• Docker 容器和外部机器可以直接交换文件么？

  ? docker 容器可以通过宿主机的数据卷与外部服务器交换文件

• 容器之间想要进行数据交互？

  ? 容器与容器挂载同一个数据卷就可以实现

数据卷

• 数据卷是宿主机中的一个目录或文件
• 当容器目录和数据卷目录绑定后，双方的修改会立即同步
• 一个数据卷可以被多个容器同时挂载
• 一个容器也可以挂在多个数据卷

数据卷作用

• 容器数据持久化
• 外部机器和容器之间通信
• 容器之间数据交换

配置数据卷

• 创建启动容器时，使用 -v 参数设置数据卷

  docker run ... -v 宿主机目录(文件):容器内目录(文件) ...
  注意：

  • 数据卷是对【宿主机目录(文件)】的称呼

  • 两个目录(文件)必须是绝对路径
    docker run -it --name=c1 -v /root/data1:/root/data_container centos:7 /bin/bash

  • 如果目录不存在，会自动创建

  • 可以挂在多个数据卷

    docker run -it --name=c2 -v ~/data2:/root/data2 -v ~/data3:/root/data3 centos:7
    

  • 两个容器可以挂在同一个数据卷

    docker run -it --name=c3 -v ~/data1:/root/data centos:7
    docker run -it --name=c4 -v ~/data1:/root/data centos:7
    

数据卷容器概念及作用

思考：

• 多容器进行数据交换的方式

  1. 多个容器挂在同一个数据卷。操作比较麻烦，容器数量多时，需要每一个都配置数据卷

  2. 数据卷容器，下图中的 c3 就是数据卷容器

     

数据卷容器

• 创建一个容器，挂载在一个目录，让其他容器继承自该容器（--volumes-from）

配置数据卷容器

1. 创建启动 c3 数据卷容器，使用 -v 参数设置数据卷

   docker run -it --name=c3 -v /volume centos:7 /bin/bash
   

   注意：

   • -v /volume 这部分和之前设置数据卷不同，没有数据卷目录只有容器中挂载数据卷的目录，但是 docker 服务会在宿主机上创建一个一样的目录作为数据卷

2. 创建启动 c1 c2 容器，使用--volumes-from参数设置数据卷

   docker run -it --name=c1 --volumes-from c3 centos:7 /bin/bash
   docker run -it --name=c2 --volumes-from c3 centos:7 /bin/bash
   

Docker 应用部署

MySQL 部署

需求

在 Docker 容器中部署 MySQL, 并通过外部 MySQL 客户端操作 MySQL Server。

实现步骤

1. 搜索 MySQL 镜像

   docker search mysql

2. 拉取 MySQL 镜像

   docker pull mysql:5.6

3. 创建容器，设置端口映射、目录映射

   # 在 /root 目录下创建 mysql 目录用于存储 mysql 数据信息
   mkdir ~/mysql
   cd ~/mysql
   

   docker run -id -p 3307:3306 --name=c_mysql -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.6
   

   参数说明：

   • -p 3307:3306：将容器的 3306 端口映射到宿主机的 3307 端口。生产环境中都是3306
   • -v $PWD/conf:/etc/mysql/conf.d：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
   • -v $PWD/logs:/logs：将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
   • -v $PWD/data:/var/lib/mysql ：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
   • -e MYSQL_ROOT_PASSWORD=123456：初始化 root 用户的密码。-e是环境变量相关的参数

4. 进入容器，操作 MySQL

   # 进入容器
   docker exec –it c_mysql /bin/bash
   # 在容器内部执行，进入 mysql 交互式界面
   mysql -uroot -p123456
   

Tomcat 部署

1. 搜索 tomcat 镜像

docker search tomcat

2. 拉取 tomcat 镜像

docker pull tomcat

3. 创建容器，设置端口映射、目录映射

# 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir ~/tomcat
cd ~/tomcat

docker run -id --name=c_tomcat -p 8080:8080 -v $PWD:/usr/local/tomcat/webapps tomcat 

• 参数说明：

  • -p 8080:8080：将容器的8080端口映射到主机的8080端口

    -v $PWD:/usr/local/tomcat/webapps：将主机中当前目录挂载到容器的webapps

4. 使用外部机器访问 tomcat

   

Nginx 部署

1. 搜索 nginx 镜像

docker search nginx

2. 拉取 nginx 镜像

docker pull nginx

3. 创建容器，设置端口映射、目录映射

# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
vim nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  ‘$remote_addr - $remote_user [$time_local] "$request" ‘
                      ‘$status $body_bytes_sent "$http_referer" ‘
                      ‘"$http_user_agent" "$http_x_forwarded_for"‘;

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

docker run -id --name=c_nginx -p 80:80 -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf -v $PWD/logs:/var/log/nginx -v $PWD/html:/usr/share/nginx/html nginx

• 注意：
  • 执行这条命令是当前目录位置必须是 ~/nginx
• 参数说明：
  • -p 80:80：将容器的 80端口映射到宿主机的 80 端口。
  • -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
  • -v $PWD/logs:/var/log/nginx：将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录

4. 使用外部机器访问 nginx

   

Redis 部署

1. 搜索 redis 镜像

docker search redis

2. 拉取 redis 镜像

docker pull redis:5.0

3. 创建容器，设置端口映射

docker run -id --name=c_redis -p 6379:6379 redis:5.0

4. 使用 windows redis 客户端连接虚拟机中的 docker 服务中的 redis 服务

redis-cli.exe -h 192.168.149.135 -p 6379

Dockerfile

Docker 镜像原理

思考：

• docker 镜像的本质？
  • 是一个分层的文件系统
• docker 中一个 centos 镜像为什么只有 200MB，而一个 centos 操作系统的 iso 文件要几个G？
  • Centos 的 ios 镜像文件包含 bootfs 和 rootfs，而 docker 的 centos 镜像复用了操作系统的 bootfs, 只有 rootfs 和其他镜像层
• docker 中一个 tomcat 镜像为什么有 500MB，而一个 tomcat 安装包只有 70 多 MB？
  • 由于 docker 中镜像是分层的，tomcat 虽然只有 70 多 MB，但它需要依赖于父镜像和基础镜像，所有整个对外暴漏的 tomcat 镜像大小 500 多 MB

操作系统组成部分：

• 进程调度子系统
• 进程通信子系统
• 内存管理子系统
• 设备管理子系统
• 文件管理子系统
• 网络通信子系统
• 作业控制子系统

Linux 文件系统由 bootfs 和 rootfs 两部分组成（ps: fs 表示 file system）

• bootfs: 包含 bootloader（引导加载程序）和 kernel（内核）
• rootfs: root 文件系统，包含的就是典型 Linux 系统中的 /dev，/proc，/bin，/etc等标准目录和文件
• 不同的 Linux 发行版，bootfs 基本一样，而 rootfs 不同，比如 ubuntu，centos 等

原理

• docker 镜像是由特殊的文件系统叠加而成
• 最底端是 bootfs，并使用宿主机的 bootfs
• 第二层是 root 文件系统 rootfs，称为 base image
• 然后再往上可以叠加其他的镜像文件
• 统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供一个统一的视角，这样就隐藏了多层的存在，在用户角度看来，只存在一个文件系统
• 一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像称为基础镜像
• 当从一个镜像启动容器时，Docker 会在最顶层加载一个读写文件系统作为容器

Docker 镜像制作

1. 容器转为镜像

   • 将修改好的容器转换为镜像

     docker commit 容器id 镜像名称:版本号

   • 将镜像文件压缩为压缩包，方便传输

     docker save -o 压缩文件名 镜像名称:版本号

   • 其他人拿到压缩文件，进行解压缩

     docker load -i 压缩文件名

   注意：

   • 这种方式生成的新的镜像中，不会包含之前的挂载目录，但是出挂在目录外的更新都会带到新的镜像中

2. dockerfile

Dockerfile 概念及使用

• dockerfile 是一个文本文件
• 包含了一条条指令
• 每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
• 对于开发人员：可以为开发团队提供一个完全一致的开发环境
• 对于测试人员：可以直接拿开发时所构建的镜像或者通过 Dockerfile 文件构建一个新的镜像开始工作
• 对于运维人员：在部署时，可以实现应用的无缝移植

Dockerfile 关键字

案例

1.1需求

自定义 centos7 镜像。
要求：1.默认登陆路径为/user；2.可以使用vim；

1.2实现步骤：

1. 定义父镜像：FROM centos:7
2. 定义作者信息：MAINTAINER wuyognqiang wuyongqiang2012@163.com
3. 执行安装 win 命令：RUN yum install -y vim
4. 定义默认的工作目录：WORKDIR /usr
5. 定义容器启动执行的命令：CMD /bin/bash
6. 通过 dockerfile 构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本

2.1需求

定义 dockerfile，发布 springboot 项目

2.2实现步骤

1. 定义父镜像：FROM java:8
2. 定义作者信息：MAINTAINER wuyognqiang wuyongqiang2012@163.com
3. 将 jar 包添加到容器：ADD springboot.jar app.jar
4. 定义容器启动执行的命令：CMD java-jar app.jar
5. 通过 dockerfile 构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本

Docker 服务编排

服务编排概念

微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停，维护的工作量会很大。

• 要从 dockerfile build image 或者去 dockerhub 拉取 image
• 要创建多个 container
• 要管理这些 container（启动停止删除）

服务编排：按照一定的业务规则批量管理容器

Docker Compose 概述

Docker Compose 是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：

1. 利用 Dockerfile 定义运行环境镜像
2. 使用 docker-compose.yml 定义组成应用的各服务
3. 运行 docker-compose up 启动应用

安装 Docker Compose

# Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version

卸载 Docker Compose

# 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose

使用 docker compose 编排 nginx + springboot 项目

1. 创建docker-compose目录

mkdir ~/docker-compose
cd ~/docker-compose

2. 编写 docker-compose.yml 文件

version: ‘3‘
services:
  nginx:
   image: nginx
   ports:
    - 80:80
   links:
    - app
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: app
    expose:
      - "8080"

3. 创建./nginx/conf.d目录

mkdir -p ./nginx/conf.d

4. 在./nginx/conf.d目录下 编写itheima.conf文件

server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}

5. 在~/docker-compose 目录下 使用docker-compose 启动容器

docker-compose up # 如果添加 -d 参数表示后台启动

6. 测试访问

http://192.168.149.135/hello

Docker 私有仓库

Docker 官方的 Docker hub 是一个用于管理公共镜像的仓库，我们可以从上面拉取镜像到本地，也可以把我们自己的镜像推送上去。但是，有时候我们的服务器无法访问互联网，或者你不希望将自己的镜像放到公网当中，那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。

一、私有仓库搭建

# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json ? 
vim /etc/docker/daemon.json ? ?
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["私有仓库服务器ip:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

二、将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像 ? ? 
docker tag centos:7 私有仓库服务器IP:5000/centos:7
 
# 2、上传标记的镜像 ? ? 
docker push 私有仓库服务器IP:5000/centos:7

三、 从私有仓库拉取镜像

#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

Docker 与传统虚拟机比较

容器就是将软件打包成标准化单元，以用于开发、交付和部署

• 容器镜像是轻量的、可执行的独立软件包，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置
• 容器化软件在任何环境中都能够始终如一的运行
• 容器赋予了软件独立性，使其免受外在环境差异的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突

Docker 入门及实战

原文：https://www.cnblogs.com/wuyongqiang/p/12747589.html