每天5分钟玩转docker容器技术 pdf_docker 创建容器

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全家桶1年46，售后保障稳定

Docker简介和安装

Docker是什么

• Docker 是一个应用打包、分发、部署的工具

• 诞生于2013年初，基于G语言实现，dotCloud公司出品(后改名为Docker Inc)

• 容器性能开销极低

• Docker从17.03版本之后分为CE(CommunityEdition:社区版)和EE(Enterprise Edition:企业版)

• 可以把它理解为一个轻量的虚拟机，它只虚拟你软件需要的运行环境，多余的一点都不要，而普通虚拟机则是一个完整而庞大的系统，包含各种不管你要不要的软件。

Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口。

为什么使用Docker

我们写代码会接触到好几个环境：开发环境、测试环境以及生产环境。

为了解决不同环境之间、不同版本之间的依赖问题。采用docker较为方便。

和普通虚拟机的对比

特性	普通虚拟机	Docker
跨平台	通常只能在桌面级系统运行，例如 Windows/Mac，无法在不带图形界面的服务器上运行	支持的系统非常多，各类 windows 和 Linux 都支持
性能	性能损耗大，内存占用高，因为是把整个完整系统都虚拟出来了	性能好，只虚拟软件所需运行环境，最大化减少没用的配置
自动化	需要手动安装所有东西	一个命令就可以自动部署好所需环境
稳定性	稳定性不高，不同系统差异大	稳定性好，不同系统都一样部署方式

打包、分发、部署

打包：就是把你软件运行所需的依赖、第三方库、软件打包到一起，变成一个安装包
分发：你可以把你打包好的“安装包”上传到一个镜像仓库，其他人可以非常方便的获取和安装
部署：拿着“安装包”就可以一个命令运行起来你的应用，自动模拟出一摸一样的运行环境，不管是在 Windows/Mac/Linux。

小结

docker是一种容器技术，解决软件跨环境迁移的问题

Docker部署的优势

常规应用开发部署方式：自己在 Windows 上开发、测试 –> 到 Linux 服务器配置运行环境部署。

问题：我机器上运行没有问题，怎么到服务器就会出现各种问题？

用 Docker 开发部署流程：自己在 Windows 上开发、测试 –> 打包为 Docker镜像（可以理解为软件安装包） –> 各种服务器上只需要一个命令部署好

优点：确保了不同机器上跑都是一致的运行环境，不会出现我机器上跑正常，你机器跑就有问题的情况。

Docker通常用来做什么

• 应用分发、部署，方便传播给他人安装。特别是开源软件和提供私有部署的应用
• 快速安装测试/学习软件，用完就丢（类似小程序），不把时间浪费在安装软件上。例如 Redis / MongoDB / ElasticSearch / ELK
• 多个版本软件共存，不污染系统，例如 Python2、Python3，Redis4.0，Redis5.0
• Windows 上体验/学习各种 Linux 系统

重要概念：镜像、容器

镜像：可以理解为软件安装包，可以方便的进行传播和安装。
容器：软件安装后的状态，每个软件运行环境都是独立的、隔离的，称之为容器。

简单理解，镜像相当于下载了软件的安装包，容器就是安装了这个软件的环境(前提是已经安装了软件，才有环境)

安装

桌面版：https://www.docker.com/products/docker-desktop
服务器版：https://docs.docker.com/engine/install/#server

Ubuntu安装Docker

https://docs.docker.com/engine/install/ubuntu/

Windows安装Docker

启动报错解决

解决方法

控制面板->程序->启用或关闭 windows 功能，开启 Windows 虚拟化和 Linux 子系统（WSL2)

另一种常见错误

根据页面提示链接，更新。

命令行安装Linux子系统

这一步可能不需要，因为我们已经安装过了，如果没有安装，可以采用如下命令进行安装。

wsl --install -d Ubuntu

Jetbrains全家桶1年46，售后保障稳定

命令行安装可能太慢，你也可以打开微软商店 Microsoft Store 搜索 Linux 进行安装

设置开机启动Hypervisor

bcdedit /set hypervisorlaunchtype auto

注意要用管理员权限打开 PowerShell

确保 BIOS 已开启虚拟化，下图检查是否已开启好

如果是已禁用，请在开机时按 F2 进入 BIOS 开启一下，不会设置的可以网上搜索下自己主板的设置方法，Intel 和 AMD 的设置可能稍有不同

Docker架构

daemon:守护进程

• 镜像(Image)：Docker镜像(Image),就相当于是含了完整的一套Ubuntu16.04最小系统的root文件系统
• 容器(Container):镜像(Image)和容器(Container)的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等
• 仓库(Respository):仓库可以堪称一个代码控制中心，用来保存镜像。

镜像加速源

镜像加速器	镜像加速器地址
Docker 中国官方镜像	https://registry.docker-cn.com
DaoCloud 镜像站	http://f1361db2.m.daocloud.io
Azure 中国镜像	https://dockerhub.azk8s.cn
科大镜像站	https://docker.mirrors.ustc.edu.cn
阿里云	https://<your_code>.mirror.aliyuncs.com
七牛云	https://reg-mirror.qiniu.com
网易云	https://hub-mirror.c.163.com
腾讯云	https://mirror.ccs.tencentyun.com

linux配置加速器可以登录阿里云，参考容器镜像服务。

Docker命令

服务相关命令

启动Docker服务

systemctl start docker

停止docker服务

systemctl stop docker

重启docker服务

systemctl restart docker

查看docker服务状态

systemctl status docker

设置开机启动docker服务

systemctl enable docker

镜像相关命令

• 查看镜像：查看本地所有镜像
  • docker images
  • docker images -q #查看所用镜像的id
• 搜索镜像：从网络中查找需要的镜像
  • docker search 镜像名称
• 拉取镜像：从Docker仓库下载镜像到本地，镜像名称格式为 名称：版本号，如果版本号不指定则是最新的版本，如果不知道镜像版本，可以去docker hub搜索对应镜像查看
  • docker pull 镜像名称
• 删除镜像：删除本地镜像
  • docker rmi 镜像id
  • docker rmi docker images -q #删除所有本地镜像

容器相关命令

• 查看容器

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

• 创建并启动容器

  • docker run 参数

  • docker run -it --name rediscontainer1 redis:latest

    -i：保持容器运行。通常与-t同时使用，加入it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭

    -t:为容器分配一个伪输入终端，通常与-i同时使用

    -d:以守护(后台)模式运行容器，创建一个容器在后台运行，需要使用docker exec进入容器，退出后，容器不会关闭。

    -it:创建的容器一般称为交互式容器

    -id:创建的容器一般称为守护式容器

    –name:为创建的容器命名

• 进入容器

  • docker exec 参数 #退出容器，容器不会关闭
  • docker exec -it 容器id /bin/bash

• 停止容器

  • docker stop 容器名称
  • sudo docker stop $(sudo docker ps -aq)#停止所有容器

• 启动容器

  • docker start 容器名称

• 删除容器：如果容器时运行状态则删除失败，需要停止容器才能删除

  • docker rm 容器名称
  • docker rm $(docker ps -aq)#删除所有容器

• 查看容器信息

  • docker inspect 容器名称

数据卷

数据卷概念及其作用

思考

• Docker容器删除后，在容器中产生的数据也会随之销毁
• Docker容器和外部机器可以直接交换文件吗
• 容器之间想要进行数据交互

数据卷

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

数据卷作用

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

配置数据卷

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

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

  docker run -it --name c1 -v /home/anti/data:/root/data_container redis:latest

  • 目录必须是绝对路径
  • 如果目录不存在，会自动创建
  • 可以挂载多个数据卷

数据卷容器

多容器进行数据交换

• 方法1：多个容器挂载同一个数据卷，这个方法之前已经讲过
• 方法2：数据卷容器

简单来说，就是c3进行目录挂载，c1和c2继承c3

配置数据卷容器

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

• docker run -it --name c3 -v /volume redis:latest

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

• docker run -it --name c1 --volumes-from c3 redis:latest
• docker run -it --name c1 --volumes-from c3 redis:latest

应用部署

部署MySQL

需求：

• 在Docker容器中部署MySQL,并通过mysql客户端操作MySQLServer

实现步骤

• 搜索mysql镜像
• 拉取mysql镜像
• 创建容器
• 操作容器中的mysql

• 容器中的网络服务和外部机器不能直接通信
• 外部机器和宿主机可以直接通信
• 宿主机和容器可以直接通信
• 当容器中的网路服务需要被外部机器访问时，可以将容器中提供服务的端口映射到主机的端口上。外部机器访问宿主机的该端口，从而间接访问容器的服务。
• 这种操作称之为:端口映射

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 端口。
• -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 用户的密码。

4.进入容器，操作mysql

docker exec -it c_mysql /bin/bash

docker中进入mysql

mysql -uroot -p123456
create database db1;
show databases;

5.使用外部机器连接容器中的mysql

部署tomcat

案例

• 在Docker容器部署Tomcat，并通过外部机器访问Tomcat部署的项目

实现步骤

• 搜索tomcat镜像
• 拉取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

进入到创建的c_tomcat 容器中

sudo docker exec -it c_tomcat /bin/bash

ce webapps
mkdir test
cd test
vim index.html
<h1>安替来了</h1>

部署Nginx

1. 搜索nginx镜像

docker search nginx

2. 拉取nginx镜像

docker pull nginx

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

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

# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
mkdir conf
cd 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

• 参数说明：
  • -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

部署reids

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. 使用外部机器连接redis

./redis-cli.exe -h 192.168.149.135 -p 6379

镜像原理

思考

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

我们看一下操作系统的组成部分

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

Linux文件系统由bootfs和rootfs两部分组成

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

而docker镜像是由特殊的文件系统叠加而成

• 最低端是bootfs，并使用宿主机的bootfs，因此启动docker速度很快，因为复用的是宿主机的bootfs，而不是重新启动一个bootfs
• 第二层是root文件系统rootfs，称为base image
• 然后再往上可以叠加其他的镜像文件
• **统一文件系统(Unicon File System)**技术能够将不同的曾整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统
  • 实际上下载tomcat需要依赖底层的镜像，分别是jdk、rootfs等，因此实际安装tomcat镜像比较大
• 一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底层的镜像称为基础镜像。
• 当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器。

容器转为镜像

Docker镜像如何制作

1.容器转为镜像

docker commit 容器id 镜像名称:版本号
docker save -o 压缩文件名称 镜像名称:版本号
docker load -i 压缩文件名称

这种方式有个缺点，打包后的镜像，挂载目录下文件会丢失，不是挂挂载目录下文件才会保存

以上述tomcat挂载目录为例，新建的test的index.html，经过伤处命令生成镜像后，挂载目录的index.html文件没有被包括在内，因此，这种方式不推荐使用

2.dockerfile

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

可以看下官方如何写的，这里以centos为例

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"]

下面介绍下dockfile经常用到的一些关键字

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于那个image构建
MAINTAINER	作者信息	用来标明这个dockerfile谁写的
LABEL	标签	用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN	执行命令	执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,“param2”]
CMD	容器启动命令	提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,“param2”]
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中会使用
COPY	复制文件	build的时候复制文件到image中
ADD	添加文件	build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
ENV	环境变量	指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
ARG	构建参数	构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME	定义外部可以挂载的数据卷	指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME [“目录”]
EXPOSE	暴露端口	定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR	工作目录	指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
USER	指定执行用户	指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK	健康检查	指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
ONBUILD	触发器	当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL	发送信号量到宿主机	该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL	指定执行脚本的shell	指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

Dockfile案例

部署springboot项目

首先在本地使用springboot搭建一个hello word项目，并打包为jar包

我们先运行下，看看有无问题

java -jar ./springboot-hello-0.0.1-SNAPSHOT.jar

我们在linux进行镜像打包，将jar包传到ubuntu中

需求

• 定义dockfile，发布springboot项目

实现步骤

• 定义父镜像：FROM java:8

• 定义作者信息：MAINTAINER anti

• 将jar包添加到容器: ADD springboot-hello-0.0.1-SNAPSHOT.jar app.jar

• 定义容器启动执行的命令：CMD java -jar app.jar

• 通过dockfile构建镜像: docker build -f dockfile文件路径 -t 镜像名称:版本 .

  • docker build -f springboot_dockerfile -t springimage1:v1 .

• 查看下镜像是否生成：docker images

  

• 生成容器：docker run -p 8080:8080 --name test-springboot springimage1:v1

查看是否运行成功

自定义centos

docker自带的centos默认登录路径是/，并且不能使用vim编辑器

需求

• 自定义centos7镜像，要求
• 1.默认登录路径为/usr
• 可以使用vim

实现步骤

• 定义父镜像：FROM centos:7
• 定义作者信息：MAINTAINER anti
• 执行安装vim命令：RUN sudo apt install -y vim
• 定义默认的工作路径：WORKDIR /usr
• 定义容器启动执行的命令：CMD /bin/bash
• 生成镜像：docker build -f ./centos_dockfile -t anti_centos:v1 .
• 打包为容器：docker run --name test_centos anti_centos:v1

compose概述

服务编排

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

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

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

compose安装使用

安装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

6. 测试访问

http://192.168.149.135/hello

Docekr私有仓库搭建

# 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快速安装软件

直接安装软件的缺点

• 安装麻烦，可能有各种依赖，运行报错。例如：WordPress，ElasticSearch，Redis，ELK
• 可能对 Windows 并不友好，运行有各种兼容问题，软件只支持 Linux 上跑
• 不方便安装多版本软件，不能共存。
• 电脑安装了一堆软件，拖慢电脑速度。
• 不同系统和硬件，安装方式不一样

相同：

• 容器和虚拟机具有相似的资源隔离和分配优势

不同：

• 容器虚拟化的是操作系统，虚拟机虚拟化的是硬件
• 传统虚拟机可以运行不同的操作系统，容器只能运行同一类型操作系统

特性	容器	虚拟机
启动	秒级	分钟级
硬盘使用	一般为MB	一般为GB
性能	接近原生	弱于
系统支持量	单机支持上千个容器	一般几十个

Docker 安装的优点

• 一个命令就可以安装好，快速方便
• 有大量的镜像，可直接使用
• 没有系统兼容问题，Linux 专享软件也照样跑
• 支持软件多版本共存
• 用完就丢，不拖慢电脑速度
• 不同系统和硬件，只要安装好 Docker 其他都一样了，一个命令搞定所有

演示 Docker 安装 Redis

Redis 官网：https://redis.io/

官网下载安装教程只有源码安装方式，现在也有了 Windows 版本。

Docker 官方镜像仓库查找 Redis ：https://hub.docker.com/

一个命令跑起来

docker run -d -p 6379:6379 --name redis redis:6.2.6

命令参考：https://docs.docker.com/engine/reference/commandline/run/

name：打包的容器名称

也可以安装最新版本的redis

docker run -d -p 6379:6379 --name redis redis:latest

这时候在docker中也可以看到已经下载了镜像image

安装 WordPress

有两种安装方式，第一种是命令行

docker run --name some-wordpress --network some-network -d wordpress

按照官方提示，但是还需要配置一些参数，因为安装wordpress的过程还有mysql数据库也需要安装

• -e WORDPRESS_DB_HOST=...
• -e WORDPRESS_DB_USER=...
• -e WORDPRESS_DB_PASSWORD=...
• -e WORDPRESS_DB_NAME=...
• -e WORDPRESS_TABLE_PREFIX=...
• -e WORDPRESS_AUTH_KEY=..., -e WORDPRESS_SECURE_AUTH_KEY=..., -e WORDPRESS_LOGGED_IN_KEY=..., -e WORDPRESS_NONCE_KEY=..., -e WORDPRESS_AUTH_SALT=..., -e WORDPRESS_SECURE_AUTH_SALT=..., -e WORDPRESS_LOGGED_IN_SALT=..., -e WORDPRESS_NONCE_SALT=... (default to unique random SHA1s, but only if other environment variable configuration is provided)
• -e WORDPRESS_DEBUG=1 (defaults to disabled, non-empty value will enable WP_DEBUG in wp-config.php)
• -e WORDPRESS_CONFIG_EXTRA=... (defaults to nothing, non-empty value will be embedded verbatim inside wp-config.php – especially useful for applying extra configuration values this image does not provide by default such as WP_ALLOW_MULTISITE; see docker-library/wordpress#142 for more details)

另一种使用docker-compose来安装，直接在文件写入所有需要安装软件的配置信息。

docker-compose.yml

version: '3.1'

services:

  wordpress:
    image: wordpress
    restart: always
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - wordpress:/var/www/html

  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - db:/var/lib/mysql

volumes:
  wordpress:
  db:

从上面的配置文件来看，需要安装的image镜像是wordpress和mysql,还伴随着数据库的一些配置信息。

安装命令如下

切换到 docker-compose.yml 目录下

docker-compose up -d

-d 表示在后台安装

更多相关命令

• docker ps 查看当前运行中的容器
• docker image 查看镜像列表
• docker rm container-id 删除指定id的容器
• docker stop/start container-id 停止/启动指定id的容器
• docker rmi image-id 删除指定id的镜像
• docker volume ls 查看volume列表
• docker network ls 查看网络列表

制作自己的镜像

为自己的 Web 项目构建镜像

示例项目代码：https://github.com/gzyunke/test-docker
这是一个 Nodejs + Koa2 写的 Web 项目，提供了简单的两个演示页面。
软件依赖：nodejs
项目依赖库：koa、log4js、koa-router

如果没有安装node.js环境的话，需要安装下nodejs，并将地址写入环境变量中。

接下来需要编写Dockerfile来描述我们依赖的环境，进行镜像的打包

编写 Dockerfile

FROM node:11
MAINTAINER AnTi  #模型维护人

# 复制代码 将当前路径复制到容器的app路径
ADD . /app

# 设置容器启动后的默认运行目录
WORKDIR /app

# 运行命令，安装依赖
# RUN 命令可以有多个，但是可以用 && 连接多个命令来减少层级。
# 例如 RUN npm install && cd /app && mkdir logs
RUN npm install --registry=https://registry.npm.taobao.org

# CMD 指令只能一个，是容器启动后执行的命令，算是程序的入口。
# 如果还需要运行其他命令可以用 && 连接，也可以写成一个shell脚本去执行。
# 例如 CMD cd /app && ./start.sh
CMD node app.js

Dockerfile文档

实用技巧：
如果你写 Dockerfile 时经常遇到一些运行错误，依赖错误等，你可以直接运行一个依赖的底，然后进入终端进行配置环境，成功后再把做过的步骤命令写道 Dockerfile 文件中，这样编写调试会快很多。
例如上面的底是node:11，我们可以运行docker run -it -d node:11 bash，跑起来后进入容器终端配置依赖的软件，然后尝试跑起来自己的软件，最后把所有做过的步骤写入到 Dockerfile 就好了。
掌握好这个技巧，你的 Dockerfile 文件编写起来就非常的得心应手了。

Build 为镜像（安装包）和运行

编译 docker build -t test:v1 .

-t 设置镜像名字和版本号

. 表示当前路径

命令参考：https://docs.docker.com/engine/reference/commandline/build/

安装完成，image镜像会在docker中显示出来

生成容器container

运行

docker run -p 8080:8080 --name test-hello test:v1

-p 映射容器内端口到宿主机
--name 容器名字
-d 后台运行
命令参考文档：https://docs.docker.com/engine/reference/run/

这时候，在docker中看下容器已经生成

也有日志进行反馈

目录挂载

现存问题

• 使用 Docker 运行后，我们改了项目代码不会立刻生效，需要重新build和run，很是麻烦。
• 容器里面产生的数据，例如 log 文件，数据库备份文件，容器删除后就丢失了。

目录挂载解决以上问题

几种挂载方式

• bind mount 直接把宿主机目录映射到容器内，适合挂代码目录和配置文件。可挂到多个容器上
• volume 由容器创建和管理，创建在宿主机，所以删除容器不会丢失，官方推荐，更高效，Linux 文件系统，适合存储数据库数据。可挂到多个容器上
• tmpfs mount 适合存储临时文件，存宿主机内存中。不可多容器共享。

文档参考：https://docs.docker.com/storage/

挂载演示

bind mount` 方式用绝对路径 `-v D:/code:/app
volume` 方式，只需要一个名字 `-v db-data:/app

示例：

docker run -p 8080:8080 --name test-hello -v D:\temp\test-docker-main\test-docker-main:/app -d test:v1

这样，就重新根据镜像，运行了容器。

-p：镜像映射到宿主机的端口号

–name：容器名称

-d:后台运行

test:v1 镜像名称和版本号

这样，我们本地的目录就挂载到容器的app目录下了

说明目录已经挂载成功

我们接下来进行测试

在本地修改代码

我们看下，容器对应app目录代码有无改变，可以看到，对应挂载目录代码已经改变了

但是只是代码改变了，还需要重新启动才会显示。否则还是之前的状态。

多容器通信

学习目标

项目往往都不是独立运行的，需要数据库、缓存这些东西配合运作。
这节我们把前面的 Web 项目增加一个 Redis 依赖，多跑一个 Redis 容器，演示如何多容器之间的通信。

创建虚拟网络

要想多容器之间互通，从 Web 容器访问 Redis 容器，我们只需要把他们放到同个网络中就可以了。

文档参考：https://docs.docker.com/engine/reference/commandline/network/

演示

创建一个名为test-net的网络：

docker network create test-net

运行 Redis 在 test-net 网络中，并给这个网络起别名redis

docker run -d --name redis --network test-net --network-alias redis redis:latest

修改代码中访问redis的地址为网络别名

运行 Web 项目，使用同个网络

docker run -p 8080:8080 --name test -v D:/test:/app --network test-net -d test:v1

查看数据

http://localhost:8080/redis
容器终端查看数据是否一致，每次点击自增1

Docker-Compose

现存问题

在上节，我们运行了两个容器：Web 项目 + Redis
如果项目依赖更多的第三方软件，我们需要管理的容器就更加多，每个都要单独配置运行，指定网络。
这节，我们使用 docker-compose 把项目的多个服务集合到一起，一键运行。

安装 Docker Compose

• 如果你是安装的桌面版 Docker，不需要额外安装，已经包含了。
• 如果是没图形界面的服务器版 Docker，你需要单独安装 安装文档
• 运行docker-compose检查是否安装成功

编写脚本

要把项目依赖的多个服务集合到一起，我们需要编写一个docker-compose.yml文件，描述依赖哪些服务
参考文档：https://docs.docker.com/compose/

version: "3.7"

services:
  app:
    build: ./  #当前目录打包为镜像
    ports:     #端口号
      - 80:8080
    volumes:   #目录挂载
      - ./:/app
    environment: #时间
      - TZ=Asia/Shanghai
  redis:
    image: redis:5.0.13 #redis镜像版本
    volumes:  #目录挂载
      - redis:/data
    environment:
      - TZ=Asia/Shanghai

volumes:
  redis:

容器默认时间不是北京时间，增加 TZ=Asia/Shanghai 可以改为北京时间

跑起来

在docker-compose.yml 文件所在目录，执行：docker-compose up就可以跑起来了。

可以看到，docker redis不同版本可以共存

命令参考：https://docs.docker.com/compose/reference/up/

• 在后台运行只需要加一个 -d参数 docker-compose up -d

• 查看运行状态 docker-compose ps

• 停止运行：docker-compose stop

• 重启：docker-compose restart

• 重启单个服务：docker-compose restart service-name

• 进入容器命令行：docker-compose exec service-name sh

• 查看容器运行log:docker-compose logs[service-name]

发布和部署

镜像仓库介绍

镜像仓库用来存储我们 build 出来的“安装包”，Docker 官方提供了一个 镜像库，里面包含了大量镜像，基本各种软件所需依赖都有，要什么直接上去搜索。

我们也可以把自己 build 出来的镜像上传到 docker 提供的镜像库中，方便传播。
当然你也可以搭建自己的私有镜像库，或者使用国内各种大厂提供的镜像托管服务，例如：阿里云、腾讯云

上传我们的镜像

• 首先你要先 注册一个账号

  • antiantigakki
  • weilei8023…

• 创建一个镜像库
  

• 命令行登录账号：
  docker login -u antiantigakki

• 新建一个tag，名字必须跟你注册账号一样
  docker tag test:v1 antiantigakki/test:v1

  这时候会生成一个新的镜像

  

• 推上去
  docker push antiantigakki/test:v1

  这时候已经上传到docker上了

  

• 部署试下
  docker run -dp 8080:8080 --name hub_test antiantigakki/test:v1

docker-compose 中也可以直接用这个镜像了

version: "3.7"

services:
  app:
#    build: ./
    image: helloguguji/test:v1
    ports:
      - 80:8080
    volumes:
      - ./:/app
    environment:
      - TZ=Asia/Shanghai
  redis:
    image: redis:5.0.13
    volumes:
      - redis:/data
    environment:
      - TZ=Asia/Shanghai

volumes:
  redis:

阿里云容器托管

docker 官方的镜像托管有时候上传和下载都太慢了，如果你想要更快的速度，可以使用阿里云的免费镜像托管
登录 阿里云

备份和迁移数据

迁移方式介绍

容器中的数据，如果没有用挂载目录，删除容器后就会丢失数据。
前面我们已经讲解了如何 挂载目录
如果你是用bind mount直接把宿主机的目录挂进去容器，那迁移数据很方便，直接复制目录就好了
如果你是用volume方式挂载的，由于数据是由容器创建和管理的，需要用特殊的方式把数据弄出来。

备份和导入 Volume 的流程

备份：

• 运行一个 ubuntu 的容器，挂载需要备份的 volume 到容器，并且挂载宿主机目录到容器里的备份目录。
• 运行 tar 命令把数据压缩为一个文件
• 把备份文件复制到需要导入的机器

导入：

• 运行 ubuntu 容器，挂载容器的 volume，并且挂载宿主机备份文件所在目录到容器里
• 运行 tar 命令解压备份文件到指定目录

备份 MongoDB 数据演示

• 运行一个 mongodb，创建一个名叫mongo-data的 volume 指向容器的 /data 目录
  docker run -p 27018:27017 --name mongo -v mongo-data:/data -d mongo:4.4
• 运行一个 Ubuntu 的容器，挂载mongo容器的所有 volume，映射宿主机的 backup 目录到容器里面的 /backup 目录，然后运行 tar 命令把数据压缩打包
  docker run --rm --volumes-from mongo -v d:/backup:/backup ubuntu tar cvf /backup/backup.tar /data/

最后你就可以拿着这个 backup.tar 文件去其他地方导入了。

恢复 Volume 数据演示

• 运行一个 ubuntu 容器，挂载 mongo 容器的所有 volumes，然后读取 /backup 目录中的备份文件，解压到 /data/ 目录
  docker run --rm --volumes-from mongo -v d:/backup:/backup ubuntu bash -c "cd /data/ && tar xvf /backup/backup.tar --strip 1"

注意，volumes-from 指定的是容器名字
strip 1 表示解压时去掉前面1层目录，因为压缩时包含了绝对路径

参考文献

• Docker快速入门
• https://www.bilibili.com/video/BV11L411g7U1?spm_id_from=pageDriver
• 百度网盘资料
• 黑马程序员Docker容器化技术，从零学会Docker教程