Docker——容器虚拟化技术      
第一章 Docker介绍
诞生背景
Docker 介绍
虚拟机技术与容器虚拟化技术
虚拟机技术
容器虚拟化技术
官方网址
第二章 Docker安装
前提条件
安装Docker
Docker管理命令
Docker底层原理
Docker结构图
工作原理
Docker为什么比VM快
第三章 Docker常用命令
帮助命令
镜像命令
容器命令
基本命令
重要命令
Docker常用命令图解
第四章 Docker镜像
镜像 / UnionFS（联合文件系统）
特点
Docker镜像加载原理：
平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才220M
  Docker镜像Commit操作 
第五章 Docker容器数据卷
简介
容器内添加数据卷
1.直接命令添加
2.Docker添加
数据卷容器
第六章 DockerFile解析
介绍
构建步骤
格式
语法
Docker执行DockerFile的大致流程
DockerFile保留字指令
保留字整合案例
自定义镜像
自定义tomcat9
第七章 通过Docker安装软件
MySQL
Redis
RabbitMQ
MongoDB
第八章 发布镜像到阿里云
步骤

第一章 Docker介绍
诞生背景
一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。

作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，

特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验 .

Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案。
环境配置如此麻烦，换一台机器，就要重来一次，费力费时。

很多人想到，能不能从根本上解决问题，软件可以带环境安装？

也就是说，安装的时候，把原始环境一模一样地复制过来。

开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。
开发需要清楚的告诉运维部署团队，用的全部配置文件+所有软件环境。

不过，即便如此，仍然常常发生部署失败的状况。

Docker镜像的设计，使得Docker得以打破过去"程序即应用" 的观念。

透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，

由下而上打包，达到应用程式跨平台间的无缝接轨运作。

Docker 介绍
Docker的主要目标是“Build，Ship and Run Any App,Anywhere”，

也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，

使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。
Linux 容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。

将应用运行在 Docker 容器上面，而 Docker 容器在任何操作系统上都是一致的，

这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好， 大大简化了操作
 总结:

Docker是解决运行环境和配置问题的软件容器 , 方便做持续集中并有助于整体发布的容器虚拟化技术  

虚拟机技术与容器虚拟化技术
虚拟机技术

虚拟机（virtual machine）就是带环境安装的一种解决方案。

它可以在一种操作系统里面运行另一种操作系统，比如在Windows 系统里面运行Linux 系统。

应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样

缺点 :1    资源占用多               2    冗余步骤多                 3    启动慢


容器虚拟化技术

Linux 容器（Linux Containers，缩写为 LXC）。

Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。

有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。

容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。

系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。



二者区别

传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
而容器内的应用进程直接运行于宿主机( 即:所在主机,下面统称宿主机 ) 的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。

官方网址
官方网址 :  https://www.docker.com

Docker社区官方:https://hub.docker.com/
第二章 Docker安装

Docker支持以下的CentOS版本：CentOS 7 (64-bit) ,CentOS 6.5 (64-bit) 或更高的版本

前提条件
目前，CentOS 仅发行版本中的内核支持 Docker。

Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上。

Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本。
# 查看内核版本
uname -r 

安装Docker
Docker安装教程（CentOS 7）本人阿里云服务器装成功

Docker安装教程（CentOS 7）本人腾讯云服务器装成功

Docker安装教程（CentOS 6）
Docker管理命令
# 重新载入后台启动进程
systemctl daemon-reload

# 启动docker容器 ,每次关闭虚拟机/运服务器时需要启动( 重要!!! )
sudo service docker start

# 查看Docker容器状态
sudo service docker status (should see active (running))

# 运行hello-world镜像/测试Docker是否可以使用
sudo docker run hello-world

Docker底层原理
Docker结构图



工作原理
Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，

然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。

容器，是一个运行时环境，就是我们前面说到的集装箱。

Docker为什么比VM快
(1) docker有着比虚拟机更少的抽象层。

由亍docker不需要Hypervisor实现硬件资源虚拟化,

运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。

因此在CPU、内存利用率上docker将会在效率上有明显优势。


(2) docker利用的是宿主机的内核,而不需要Guest OS。

因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。

因而避免引寻、加载操作系统内核返个比较费时费资源的过程,

当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。

而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。

   通过下图着重了解二者的比较( 图很重要!!!)


第三章 Docker常用命令
帮助命令
# 查看docker版本信息
docker version

# 查看docker所有安装信息
docker info

# 查看docker帮助 ( 最为重要,学会利用帮助文档来学习 ,这是成为高手的必经之路!!! )
docker --help

镜像命令
# 1.列出本地镜像(图1)
docker images

# option说明
 -a :列出所有镜像
 -q:只列出镜像id
 -digests :显示镜像的摘要信息
--no-trunc :显示相信信息


# 2.搜索某个镜像名字 (会在docker社区搜索相关的镜像, 而我们配置的阿里源只是帮我们同步了docker社区的镜像,图2)
docker search 

# option说明
	- s显示收藏数不小于指定值的镜像
    --no-trunc :显示相信信息
    - automated :只列出automated类型的镜像

# 3. 下载镜像(图3)
docker pull 镜像的名字:[TAG](不写默认为 lasted)

# 4. 删除镜像
docker rmi  -f 镜像名/镜像id
docker rmi -f $(docker images -qa )
   


各个选项说明:

REPOSITORY：表示镜像的仓库源

TAG：镜像的标签

IMAGE ID：镜像ID

CREATED：镜像创建时间

SIZE：镜像大小

同一仓库源可以有多个 TAG，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。

如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像

图1



图2


图3


容器命令
基本命令
# 1. 新建并启动容器
docker run [OPTIONS] IMAGE [COMMOND] [ARGS...]

# OPTIONS 说明
	--name="容器新名字": 为容器指定一个名称；
	-d: 后台运行容器，并返回容器ID，也即启动守护式容器；
	-i：以交互模式运行容器，通常与 -t 同时使用；
	-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；
	-P: 随机端口映射；
	-p: 指定端口映射，有以下四种格式
	      ip:hostPort:containerPort
	      ip::containerPort
	      hostPort:containerPort
	      containerPort
	      
# eg: 使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。
docker run -it centos /bin/bash 

 
# 2. 查询当前正在运行的容器(类比虚拟中的查看进程)
docker ps [OPTIONS] 

# OPTIONS说明（常用）：
	-a :列出当前所有正在运行的容器+历史上运行过的
	-l :显示最近创建的容器。
	-n：显示最近n个创建的容器。
	-q :静默模式，只显示容器编号。
	--no-trunc :不截断输出。


# 3. 退出容器
exit  容器停止后退出
ctrl+p+q  容器不停止退出

# 4 .启动容器
docker start 容器ID/容器名

# 5. 重启容器 
docker restart

# 6. 停止容器
docker stop 容器ID/容器名

# 7. 强制停止容器
docker kill 容器ID/容器名

# 8. 删除已经停止的容器(如果没有停止,删除后悔停止)
docker rm 容器ID
删除多个容器(特别是第二种 ,先查询所有运行的进程, 然后通过管道传到后面的删除操作中)
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm

重要命令
# 1. 启动守护式容器(后台运行)
docker -d 容器名

# 使用镜像centos:latest以后台模式启动一个容器
docker run -d centos

问题：然后docker ps -a 进行查看, 会发现容器已经退出
很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程.
容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的。

这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下,我们配置启动服务只需要启动响应的service即可。例如service nginx start
但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,
这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.
所以，最佳的解决方案是,将你要运行的程序以前台进程的形式运行

# 2. 查看容器日志
docker logs -f -t --tail 容器ID

eg :(图1)
docker run -d centos /bin/sh -c "while true;do echo hello testLogs;sleep 2;done"
docker logs -tf --tail 10 02c81778b0e0

-t 是加入时间戳
-f 跟随最新的日志打印
--tail 数字 显示最后多少条


# 3. 查看容器内运行的进程(图2)
docker top 容器ID

# 4. 查看容器内部细节(图3)
docker inspect 容器ID

# 5.进入正在运行的容器并进行交互(图4)
docker exec -it 容器ID bashShell

# 6. 重新进入容器(图5)
docker attach 容器ID bashShell(不写的话默认 /bin/bash下)

# 比较5与6的区别
attach 直接进入容器启动命令终端, 不会启动新的线程
exec 是在容器中打开新的终端, 并且可以启动新的线程

图1


图2



图3



图4



图5


Docker常用命令图解

第四章 Docker镜像
镜像 / UnionFS（联合文件系统）
Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，

它支持对文件系统的修改作为一次提交来一层层的叠加，

同时可以将不同目录挂载到同一个虚拟文件系统下。Union 文件系统是 Docker 镜像的基础。

镜像可以通过分层来进行继承. 基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
特性

一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，

联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录


   总结:

镜像就像洋葱圈 ,就像莲花卷 ,一层套一层 ,对外只显示一个文件系统.

而且, 这种分层镜像还可以复用
特点
Dcoker镜像都是只读的 , 当启动容器时, 一个新的可写层被加载到镜像的顶部

这一层被称为"容器层", "容器层"执行的都称为"镜像层"
Docker镜像加载原理：
docker的镜像实际上由一层一层的文件系统组成，这种层级的文件构成文件系统UnionFS。



bootfs(boot file system) 主要包含bootloader和kernel,

bootloader主要作用是引导加载kernel, Linux刚启动时会加载bootfs文件系统，Docker镜像的最底层是bootfs。

这一层与典型的Linux/Unix系统是一样的，包含boot加载器和内核。

当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。
rootfs (root file system) ，在bootfs之上。

包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。

rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。
平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才220M


对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，

因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。

由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。
  Docker镜像Commit操作 
# 提交容器副本实质成为一个新的镜像
docker commit -m="提交的描述信息" -a="作者"	容器ID 要创建的目标镜像名:[标签名]


eg: 同时docker运行tomcat案例
# 1.  创建交互式界面 ( 相当于前台启动)
docker run -it -p 8888:8080 tomcat   # 端口映射将8888作为docker的入口,映射到tomcat镜像的8080(图1,图2)
docker run -it -P  tomcat  #自动端口映射(通过 docker ps查看端口, 图3)
#后台启动(不会占用当前页面)
docker run -d -p 8888:8080 tomcat 


# 2. 进入tomcat (如果前置启动,另开一个窗口 ,后置启动则直接进入)
# 查看运行容器ID
docker ps  
# 进入根目录
docker exec -it 容器ID /bin/bash
/usr/local/tomcat# rm -rf webapps/docs/ 
# 删除后访问tomcat ,可以看到访问主页下的文档出现404(图4)

# 3. 提交容器副本实使之为一个新的镜像
# 查看运行容器ID
docker ps  
# 提交容器
docker commit -m="del tomcat docs" -a="timepaus" 容器ID tomcat:v1.2
# 查看镜像(图5)
docker images

# 4.同时启动新镜像并和原来的对比
可以看到我们自己提交的新镜像也没有文档()
但是我们重新下载的tomcat是有的

图1



图2



图3



图4


图5


第五章 Docker容器数据卷
简介

类似Redis中的rdb文件和aof文件

  用于容器的持久化和荣期间的继承与共享数据 

容器内添加数据卷
1.直接命令添加
# 通过-v命令直接添加 (需要在根目录下创建 containerData  )
# 创建后修改容器内containerData 会同步到hostData ,反之亦是如此
docker run -it -v /hostData:/containerData  镜像名/ID

# 创建只读权限的文件 , 容器内只能读取这个文件, 但是不能修改. ro: readonly
docker run -it -v /宿主机绝路路径目录:/容器内目录:ro 镜像名

2.Docker添加
DockerFile的简单理解


# 1. 宿主机根目录下创建mydocker文件夹并进入


# 2. 在mydocker文件想创建DockerFile文件并编辑,内容如下(图1)

# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,--------success1"
CMD /bin/bash

说明：
出于可移植和分享的考虑，用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。
由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。


3. 使用docker build命令创建一个镜像, 并挂载指定宿主机指定文件
docker build -f /mydocker/DockerFile -t 定义的新镜像名称

4. 查看镜像
docker images

5.运行新镜像
docker run -it 定义的新镜像ID /bin/bash

6.通过镜像运行后生成的容器ID查看 (图2), 对应的主机映射的数据卷地址
docker ps
docker inspect 容器ID

7.测试添加卷和主机是否互通有无
在容器中创建文件, 看看主机中是否创建对应的文件

注意: 
Docker挂载主机目录(第3步)Docker访问出现cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个--privileged=true参数即可

图1


图2, 查看运行的容器id相关信息 docker inspect 容器ID



对比与总结


数据卷容器

命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，

挂载数据卷的容器，称之为数据卷容器

实现步骤
# 1. 以上一步所建镜像为模板 ,首先启动一个父容器dc01 ,在创建容器的数据卷文夹中创建一个文件(图1)
docker run -it --name 	dc01 zzyy/centos
touch dc01_add.txt

# 2. 创建子容器dc02,dc03继承自dc01 , 在创建容器的数据卷文夹中创建一个文件(图2)
docker run -it --name dc02 --volumes-from dc01 zzyy/centos
touch dc02_add.txt
docker run -it --name dc03 --volumes-from dc01 zzyy/centos
touch dc01=3_add.txt


# 3. 回到dc01可以看到所有数据都被共享了(图3)
# 4. 删除dc01, dc02修改后dc03是否可访问,可以 (图4)
# 5. 删除dc02dc03是否可以访问, 可以(图5)
# 6. 新建dc04继承dc03是否可以访问, 可以(图6)

结论
容器之间配置信息的传递, 数据卷的生命周期一直持续到没有容器使用它为止

图1



图2



图3



图4


图5



图6


第六章 DockerFile解析
介绍

Dockerfile是用来构建Docker镜像文件 ,是有一系列命令和参数构成的脚本

构建步骤
1.编写Dockerfile文件

2.docker build

3.docker run
格式
以centos的文件为例
FROM scratch
ADD centos-8-container.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="20190927"

CMD ["/bin/bash"]

语法

每条保留字指令都必须为答谢字母且后面至少跟一个参数
指令从上到下, 顺序执行
#表示注释
每条指令都会创建一个一个新的镜像层, 并提交

Docker执行DockerFile的大致流程

docker从基础镜像运行一个容器
执行一条指令并对容器做出修改
执行类似docker commit 的操作提交一个新的镜像层
docker 再基于刚提交的镜像运行一个新容器
执行dockerfile 中的下一条执行, 直至所有指令都完成

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

Dockerfile是软件的原材料
Docker镜像是软件的交付品
Docker容器则可以认为是软件的运行态。

Dockerfile面向开发，Docker镜像成为交付标准，

Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。


1 Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;

2 Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;

3 Docker容器，容器是直接提供服务的

DockerFile保留字指令
查看tomcat的DockerFile文件 ,更好理解保留字


保留字整合案例
自定义镜像

我们安装的centos精简版是没有vim和ifconfig命令的支持的

我们可以通过编写Dockerfile令其支持这些功能

# 1.搜索centos镜像并下载
docker search centos
docker pull centos

# 2.编写创建一个文件( /mydoker/dockerfile_centos ),编写Dockerfile ,内容如下
--------------------------------------------------------------------
FROM centos
MAINTAINER timepause<qq_43371556@csdn.net>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "install vim and ifconfig commond plug-in components success"
CMD /bin/bash
-----------------------------------------------------------------------



# 3. 编译运行centos( 注意最后的空格和点号,图1 )
docker build -f /mydoker/dockerfile_centos -t mycentos:1.3 .

# 4. 测试功能( 图2 )
# 查看是否新增镜像
docker ps
# 运行新镜像 
docker run -it mycentos:1.3
# 在容器中使用vim 与if config命令


图1


图2


自定义tomcat9
# 1. 创建存放生成镜像文件的目录
mkdir -p /myuse/mydocker/tomcat9

# 2.创建相关文件(c.txt用于测试)
touch c.txt 


# 3.上传tomcat和jdk(一定要注意版本, 根据版本修改Dockerfile文件, 图1)

#. 4.创建并编辑Dockerfile(需要提前下载centos)
vim Dockerfile
---------------------Dockerfile-------------------------------
FROM         centos
MAINTAINER    chy<chy@qq.com>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u11-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.27.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.27
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.27
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE  8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.27/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.27/bin/logs/catalina.out
---------------------Dockerfile-------------------------------




# 5.构建镜像(在存放这些文件的目录下,图2)
# 如果Dockerfile文件名称就是Dockerfile,可以省略参数 -f /Dockerfile所在位置的书写
docker build -t mytomcat9 .

# 6.查看镜像并运行镜像( 图3)
docker images
# 运行镜像 (后台启动, 成功后如图4)
docker run -d -p 8080:8080 --name myt9 -v /myuse/mydocker/tomcat9/test:/usr/local/apache-tomcat-9.0.27/webapps/test -v /myuse/mydocker/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.27/logs --privileged=true  mytomcat9

# 注意这里配置了容器卷的映射,宿主机的test文件夹映射到tomcat的webapps目录下的test文件,且二者可以互通有无. 
docker exec -it 容器ID /bin/bash #进入容器根目录 ,可以访问相关页面

# 7. 访问成功后, 添加jsp文件与web.xml文件( a.jsp用于访问测试 ,web.xml用于令jsp页面可以编译)
vim a.jsp
mkidr WEB-INF
vim /WEB-INF/web.xml
------------------------------------------a.jsp---------------------------
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
  </head>
  <body>

    -----------welcome------------
    <="i am in docker tomcat self "%>
    <br>
    <br>
    <% System.out.println("=============docker tomcat self");%>
  </body>
</html>
------------------------------------------a.jsp---------------------------



------------------------------------------web.xml-----------------------------------
<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  version="4.0"
  metadata-complete="true">
</web-app>
------------------------------------------web.xml-----------------------------------

# 8. 重启服务, 访问a.jsp(图5)
# 查看当前容器id
docker ps (查看当前容器ID)
docker ps -a (查看所有运行过的容器ID)
# 重启服务
docker restart 容器ID
# 访问a.jsp页面

图1



图2


图3



图4


图5

第七章 通过Docker安装软件
MySQL
# 1. 以安装mysql5.6为例(不知道什么原因5.7下不来)
docker pull mysql:5.6

# 2. 运行镜像,启动容器(端口3306,root用户密码:root,运行镜像:mysql5.6)
docker run -p 3306:3306 --name mysql -v /datebase/mysql/conf:/etc/mysql/conf.d -v /datebase/mysql/logs:/logs -v /datebase/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.6

# 3. 进入msql内部测试登陆
docker ps
## 进入mysql的当前目录下
docker exec -it MySQL运行成功后的容器ID/name     /bin/bash
## 输入账号密码
mysql -u 账号 -p(然后根据提示输入密码)

# 4.连接数据库的图形化界面

# 5. 备份数据库数据,之后我们可以通过直接读取这个sql文件恢复数据
docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"root" ' > /datebase/all-databases.sql


Redis
# 1.下载最新版redis镜像
docker pull redis

# 2.运行镜像(redis端口2333, -d后的redis不加参数默认为redis:latest)
# 注意本地数据卷与容器内数据卷目录的对应
docker run -p 2333:6379 -v /myuse/myredis/data:/data -v /myuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf  -d redis redis-server /usr/local/etc/redis/redis.conf --appendonly yes

# 3.上传redis.conf到本地数据卷所在目录
本地数据卷坐在目录 : /myuse/myredis/conf
文件地址(太大了 ,这里放不下) : https://download.csdn.net/download/qq_43371556/11889084

# 4. 运行redis的cil----shell命令行
docker exec -it 运行着Rediis服务的容器ID redis-cli
# 远程连接 docker redis
docker exec -it redis_s redis-cli -h 192.168.1.100 -p 6379 -a your_password //如果有密码 使用 -a参数


RabbitMQ
# 1.下载镜像
docker pull rabbitmq:3.7.7-management

# 2.运行镜像
docker run -d --name rabbitmq3.7.7 -p 5672:5672 -p 15672:15672 -v `pwd`/data:/var/lib/rabbitmq --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=/ -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin df80af9ca0c9

-d 后台运行容器；
--name 指定容器名；
-p 指定服务运行的端口（5672：应用访问端口；15672：控制台Web端口号）；
-v 映射目录或文件；
--hostname  主机名（RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据，默认为主机名）；
-e 指定环境变量；（RABBITMQ_DEFAULT_VHOST：默认虚拟机名；RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的密码）


# 3.访问 (如下图)
http://ip:15672
账号 :admin
密码: admin


MongoDB
# 1.查看docker+MongoDB版本(图1)
docker search

# 2.下载最新的MongoDB
docker pull MongoDB

# 3.将镜像运行成容器
docker run -itd --name mongo -p 27017:27017 mongo --auth
## 参数说明：
-p 27017:27017 ：映射容器服务的 27017 端口到宿主机的 27017 端口。外部可以直接通过 宿主机 ip:27017 访问到 mongo 的服务。
--auth：需要密码才能访问容器服务。

# 4.使用以下命令添加用户和设置密码，并且尝试连接。
$ docker exec -it mongo mongo admin
# 创建一个名为 admin，密码为 123456 的用户。
>  db.createUser({ user:'admin',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'}]});
# 尝试使用上面创建的用户信息进行连接。
> db.auth('admin', '123456')

图1


图2
第八章 发布镜像到阿里云
步骤
# 1.登陆阿里云, 进入容器镜像服务(可以通过下方地址注册登录跳转到容器镜像服务)
https://cr.console.aliyun.com/cn-hangzhou/instances/repositories

# 2. 创建镜像仓库(图1)
# 3. 在docker中登陆 ,根据图2,图3中的操作指南进行操作

# 5. 将正在运行的容器创建成一个镜像(图4)
docker commit 

OPTIONS说明：
-a :提交的镜像作者；
-m :提交时的说明文字；

# 4.将镜像推送到阿里云的镜像仓库(最好是根据阿里云上的操作指南)
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/timepause/mydocker:[镜像版本号]
sudo docker push registry.cn-hangzhou.aliyuncs.com/timepause/mydocker:[镜像版本号]

# 5. 搜索镜像 ,下载镜像(图5,图6)
docker pull 复制的镜像地址

图1



图2



图3

图4



图5



图6


点击本博客相关学习视频地址

Docker技术实践
centos7 安装 docker17.03.2
采用国内阿里云安装

# Set up repository
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# Use Aliyun Docker
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 不指定版本号 默认安装最新版
sudo yum install docker-ce



安装结果如图
启动docker
# Start docker service
systemctl enable docker
systemctl start docker


# 重新加载设置  重启引擎
systemctl daemon-reload
systemctl restart docker



可见能够正常启动docker
运行Helloworld
执行run hello world
docker run hello-world


运行ubuntu镜像
执行命令
docker run -it ubuntu bash


成功的安装并运行了ubuntu镜像
尝试输入指令成功


显示docker信息
本地镜像库内容

运行中的docker信息


显示所有容器

Mysql镜像
首先下载对应的镜像



创建文件dockfile
FROM ubuntu
ENTRYPOINT ["top", "-b"]
CMD ["-c"]


构建镜像


运行镜像

启动服务器



启动客户端


查看sql数据库文件


查看卷


创建卷并挂载




启动客户端并链接到服务器

Docker技术文档
名词解释
什么是虚拟化技术？
什么是Docker?
Linux容器技术
如何理解Docker？
Docker在开发和运维中的优势
Docker与虚拟机比较
Docker不足
总结
Docker的核心概念和安装
Docker三大核心概念
Docker镜像
Docker容器
Docker仓库
Docker引擎
Docker架构
安装Docker
CentOS
CentOS 6.5以上的安装
CentOS 7.0以上的安装
MacOS安装
Windows安装
镜像
配置加速器
阿里云加速器
获取镜像
查看镜像信息
搜寻镜像
删除镜像
使用镜像的标签删除镜像
使用镜像ID删除镜像
存出和载人镜像
存出镜像
载入镜像
上传镜像
容器
创建容器
新建容器
新建并启动容器
案例：启动一个bash终端，允许用户进行交互：
案例2：很多的时候，需要让Docker容器在后台以守护态(Daemonized)形式运行，如下执行命令：
进入容器
终止容器
删除容器
导出和导入容器
导出容器
导入容器
仓库
AliYun docker（阿里容器服务器）
数据管理
数据卷
在容器内创建一个数据卷
挂载一个主机目录作为数据卷
挂载一个本地主机文件作为数据卷
数据卷容器
通过数据卷和数据卷容器对容器内数据进行共享等操作，通过这些机制，即使容器在运行中出现故障，用户也不必担心数据发生丢失，只需要快速创建容器即可。
在生产环境中，在使用数据卷或数据卷容器之外，定期将主机的本地数据备份，或者使用支持容错的存储系统，包括RAID或分布式文件系统。
网络配置
端口映射实现访问容器
从外部访问容器应用
映射所有端口地址
映射到指定地址的指定端口
映射到指定地址的任意端口
查看映射端口配置
查看所有网络配置信息
容器互联实现容器间通信
自定义容器命名
容器互联
编写者
修改者
版本
修改日志
参考资源


这是关于docker虚拟化技术的文档。旨在用于给初学者快速搭建docker环境以及学习相关知识。

 Windows_Mac OS_CentOS
 Docker
 Tomcat
 MySQL
 Nginx
 等等
名词解释
什么是虚拟化技术？
虚拟化技术是一个通用的概念。在计算领域，一般指的是计算虚拟化，或者通常说的服务器虚拟化。
维基百科的定义如下：

在计算机技术中，虚拟化(Virtualization)是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存以及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以用比原来的组态更好的方式来应用这些资源。

从大类上分，虚拟化技术可分为基于硬件的虚拟化和基于软件的虚拟化。我们常用的是基于软件的虚拟化。
基于软件的虚拟化从对象所在层次，又可以分为应用虚拟化和平台虚拟化。其中前者是指一些模拟器设备软件。后者又可以细分为如下几个子类：
完全虚拟化
硬件辅助虚拟化
部分虚拟化
超虚拟化
操作系统级虚拟化
本文档所指的Docker虚拟化，就是属于操作系统级虚拟化的技术范畴。

什么是Docker?
Docker是基于GO语言实现的云开源项目，诞生于2013年初，最初的发起者是dotCloud公司。
现在主流的Linux操作系统都已经支持Docker。例如，RedHat RHEL、CentOS,Ubuntu等操作系统，都已经默认带有Docker软件包。(受版本问题，可能有些低版本的操作系统，需要自行安装)。
Docker的主要目标是“Build Ship and Run Any App,Anywhere”，即通过对应用组件的封装(Packaging)、分支(Distribution)、部署(Deployment)、运行(Runtime)等生命周期的管理，达到应用组件级别的“一次封装，到处运行”。
Linux容器技术
Docker引擎的基础是Linux容器技术。IBM给出关于容器技术的准确描述：

容器有效地将由单个操作系统管理的资源划分到孤立的组中，以便更好地在孤立的组之间平衡有冲突的资源使用需求。与虚拟化相比，这样既不需要指令级模拟，也不需要即时编译。容器可以在核心CPU本地运行指令，而不需要任何专门的解释机制。此外，也避免了准虚拟化和系统调用替换中的复杂性。

如何理解Docker？
我们可以简单地将Docker容器理解为一种沙盒(SandBox)。每个容器内运行一个应用。不同的容器相互隔离，容器之间也可以建立通信机制。容器的创建和停止都十分快速，容器自身对资源的需求也十分有限，远低于虚拟机。
Docker在开发和运维中的优势
对开发和运维(DevOps)过程中，具有如下几个优势：
 更快速的交付和部署
 更高效的资源利用
 更轻松的迁移和扩展
 更简单的更新管理
Docker与虚拟机比较
Docker容器很快，启动和停止可以在秒级实现，这相比传统的虚拟机方式要快很多。
Docker容器对系统资源需求很少，一台主机上可以同时运行数千个Docker容器。
Docker通过类似Git的操作来方便用户获取、分发和更新应用镜像，指令简明，学习成本较低。
Docker通过DockerFile配置文件来支持灵活的自动化创建和部署机制，提高工作效率。

Docker不足
LXC是基于cgroup等linux kernel功能的，因此container的guest系统只能是linux base的
隔离性相比KVM之类的虚拟化方案还是有些欠缺，所有container公用一部分的运行库
网络管理相对简单，主要是基于namespace隔离
cgroup的cpu和cpuset提供的cpu功能相比KVM的等虚拟化方案相比难以度量(所以dotcloud主要是按内存收费)
container随着用户进程的停止而销毁，container中的log等用户数据不便收集
总结
Docker是面向应用的，其终极目标是构建PAAS平台，而现有虚拟机主要目的是提供一个灵活的计算资源池，是面向架构的，其终极目标是构建一个IAAS平台，所以它不能替代传统虚拟化解决方案。目前在容器可管理性方面，对于方便运维，提供UI来管理监控各个containers的功能还不足，还都是第三方实现如DockerUI、Dockland、Shipyard等。
Docker的核心概念和安装
Docker三大核心概念
镜像(Image)
容器(Container)
仓库(Repository)
Docker镜像
Docker镜像(Image)类似于虚拟机镜像，可以将它理解为一个面向Docker引擎的只读模板，包含了文件系统。
镜像是创建Docker容器的基础。通过版本管理和增量文件的文件系统，Docker提供了一套十分简单的机制来创建和更新现有的镜像，用户甚至可以从网上下载一个已经做好的应用镜像，并通过简单的命令就可以直接使用。
Docker容器
Docker容器(Container)类似于一个轻量级的沙箱，Docker利用容器来运行和隔离应用。
容器是从镜像创建的应用运行实例，可以将其启动、开始、停止、删除，而这些是相互隔离、互不可见。
镜像自身是只读的。容器从镜像启动的时候，Docker会在镜像的最上层创建一个可读写层，镜像本身将保持不变。
Docker仓库
Docker仓库(Repository)类似于代码仓库，是Docker集中存放镜像文件的场所。
注册服务器是存放仓库的地方，其上往往存放着多个仓库。每个仓库集中存放某一类镜像，往往包括多个镜像文件，通过不同的标签(tag)来进行区分。
如下图：

根据所存储的镜像公开分享与否，Docker仓库可以分为公开仓库(Public)和私有仓库(Private)两种形式。
目前，最大的公开仓库是Docker Hub，存放了数量庞大的镜像供用户下载。
在国内比较稳定的是阿里云仓库。
当用户创建了自己的镜像之后就可以使用push命令将它上传到指定的公有或私有仓库。这样用户下次在另外一台机器上使用该镜像时，只需将其从仓库上pull下拉就可以使用了。
注意：Docker利用仓库管理镜像的设计理念与Git非常相似。
Docker引擎
Docker引擎是一个客户端–服务器应用，由如下主要组件组成：
一个后台守护进程(daemon process.)
一个REST API 指定特定的接口，程序可以使用这些接口告诉和指导守护进程做什么.
一个命令行端口(CLI)，client.
如下图：

CLI使用Docker的REST API 来和Docker的守护进程交互，通过脚本或直接的CLI命令。
守护进程(daemon process)创建和管理Docker对象(objects).Docker对象包括镜像(images)、容器(containers)、网络(networks)、数据卷(data volumes)等等.
Docker架构
Docker使用客户端-服务器(client-server)架构. Docker client 告诉Docker daemon 建立、运行、和分发你你的Docker容器. Docker client和daemon可以运行在同一个系统中，或者可以使用Docker client 和远程的Docker  daemon 取得联系。docker客服端和docker守护进程之间通过sockets 或者REST API 交互。
如下图：

安装Docker
Docker支持在主流的操作系统平台上使用，包括Ubuntu、CentOS、Windows以及MacOS系统等。本文档主要讲解三个平台的安装，包括：CentOS,Windows以及MacOS系统。
CentOS
docker容器最早受到RHEL完善的支持是从最近的CentOS 7.0开始的，官方说明是只能运行于64位架构平台，内核版本为2.6.32-431及以上（即>=CentOS 6.5，运行docker时实际提示3.8.0及以上）。
需要注意的是CentOS 6.5与7.0的安装是有一点点不同的，CentOS-6上docker的安装包叫docker-io，并且来源于Fedora epel库，这个仓库维护了大量的没有包含在发行版中的软件，所以先要安装EPEL，而CentOS-7的docker直接包含在官方镜像源的Extras仓库（CentOS-Base.repo下的[extras]节enable=1启用）。前提是都需要联网，具体安装过程如下。
CentOS 6.5以上的安装
查看内核版本
# uname -r
2.6.32-431.el6.x86_64 

注意：必须要大于等于这个版本号
安装 Fedora EPEL
yum -y install http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm 

安装Docker-io
# yum install docker-io
Dependencies Resolved

===========================================================================================
 Package                        Arch               Version          Repository     Size
===========================================================================================
Installing:
 docker-io                      x86_64         1.1.2-1.el6          epel          4.5 M
Installing for dependencies:
 lua-alt-getopt                 noarch         0.7.0-1.el6          epel          6.9 k
 lua-filesystem                 x86_64         1.4.2-1.el6          epel           24 k
 lua-lxc                        x86_64         1.0.6-1.el6          epel           15 k
 lxc                            x86_64         1.0.6-1.el6          epel          120 k
 lxc-libs                       x86_64         1.0.6-1.el6          epel          248 k

Transaction Summary
===========================================================================================
Install       6 Package(s)

启动Docker
# service docker start 

CentOS 7.0以上的安装
更新系统包到最新
# yum -y update

添加yum仓库
# cat >/etc/yum.repos.d/docker.repo <<-EOF
[dockerrepo]
name=Docker Repository
baseurl=https://yum.dockerproject.org/repo/main/centos/7
enabled=1
gpgcheck=1
gpgkey=https://yum.dockerproject.org/gpg
EOF

安装Docker包
yum install -y docker-engine
yum install -y docker-selinux

启动Docker
# systemctl start docker.service

设置Docker为开机自启动
#  systemctl enable docker.service

MacOS安装
下载Docker for Mac
安装即可
Windows安装
略
镜像
镜像是Docker的三大核心概念之一。
Docker运行容器前需要本地存在对应的镜像，如果镜像不存在本地，Docker会尝试从默认仓库下载（默认使用Docker Hub公共注册服务器中的仓库），用户也可以通过配置，使用自定义的镜像仓库。
本节内容将围绕着镜像这一核心概念的具体操作，包括如何使用pull命令从Docker仓库中下载镜像到本地；如何查看本地已有的镜像信息；如何在远端仓库使用search命令进行搜索和过滤；如何删除镜像标签和镜像文件；如何创建用户定制的镜像并且保存为外部文件等等。
配置加速器
Docker默认下载镜像是通过默认仓库下载，其默认仓库是在国外的站点，在访问速度上比较慢，不稳定。为了改变这一情况，国内一些大的容器服务站点，例如：阿里云，daocloud等，提供了访问加速器。我们可以通过配置访问加速器，提高稳定性和下载速度。
阿里云加速器
登录（阿里云开发平台）
进入管理中心
获得加速地址，如下图：

获取镜像
镜像是Docker运行容器的前提。
可以使用docker pull命令从网络中下载镜像。该命令的格式为：
docker pull Name[:TAG]

如果不显示地指定TAG,则默认下载latest标签，即下载仓库中最新版本的镜像。
例如：
docker pull centos

该命令相当于从默认注册服务器(Registry.hub.docker.com)中的centOS仓库下载标记为latest的镜像。
docker pull registry.cn-hangzhou.aliyuncs.com/acs-sample/centos

该命令相当于从阿里云注册服务器(registry.cn-hangzhou.aliyuncs.com/acs-sample)中的centOS仓库下载标记为latest的镜像。
我们来看一下，下载过程，如下图：

下载过程中可以看出，镜像文件一般是由若干层组成，首行a3ed95caeb92这样的字符串代表了各层的ID。下载过程中会获取并输出镜像的各层信息。层(Layer)其实是AUFS(高级联合文件系统)中的重要概念，是现实增量保存与更新的基础。
下载完成后，既可以使用该镜像了。例如：
docker run -ti centos /bin/bash

查看镜像信息
使用docker images命令可以列出本地主机上已有的镜像。
例如：
docker images

如下图：

列出信息依次为：
来自于那个仓库
镜像的标签信息
镜像的ID号(唯一)
创建时间
镜像大小
其中镜像的ID信息十分重要，它唯一标识了镜像。
为了方便使用某个镜像，我们可以修改标签值，例如：
docker tag mysql mysql2

修改后，如下图：

如上图，我们已经将mysql改为mysql2并创建了一个新的image，但是，这里要注意，mysql和mysql2其实实际上是一个镜像，只不过是同时指向了同一个镜像ID。
我们也可以使用，
docker rmi mysql2

删除它。如图：

使用docker inspect [镜像名]命令可以获得该镜像的详细信息。
例如：
docker inspect mysql

如下图：

搜寻镜像
使用docker search命令可以搜索远端仓库中共享的镜像，默认搜索Docker Hub官方仓库的镜像。
例如：
docker search centos

如下图：

其实，我们还可以在阿里云容器服务站点中搜索
地址如下：https://dev.aliyun.com
删除镜像
使用镜像的标签删除镜像
命令格式如下：
docker rmi [IMAGE]

其中IMAGE可以是标签或ID
例如：
docker rmi mysql2

这条命令删除了该镜像多个标签中的一个指定标签而已，并不影响镜像文件。但是，当镜像只剩下一个标签的时候，就会彻底删除该镜像。
使用镜像ID删除镜像
当使用docker rmi命令后面跟上镜像的ID时，会先尝试删除所有指向该镜像的标签，然后删除该镜像文件本身。
如下图：

案例：
首先先运行镜像，创建一个简单的容器：
docker run -ti centos2 /bin/bash

使用docker ps -a命令查看本机上存在的所有容器
docker ps -a

删除镜像
docker rmi centos2

如下图，显示错误：

Docker会提示有容器正在运行，无法删除。
如果要强制删除，可以使用-f参数：
docker rmi -f centos2

但不建议强制删除的方式删除容器依赖的镜像。正确的方式是，先删除依赖该镜像的所有容器，再删除镜像。
可以使用如下命令，删除容器：
docker rm [CONTAINER ID]

存出和载人镜像
存出镜像
如果要存出镜像到本地文件，可以使用docker save命令。
例如：
docker save -o centos.tar centos

载入镜像
如果要导入镜像到Docker中，可以使用docker load
例如：
docker load --input centos.tar

上传镜像
使用docker push命令上传镜像到仓库。默认上传到DockerHub，命令格式如下：
docker push NAME[:TAG]

第一次使用时，会提示输入登录信息或进行注册。
容器
容器是Docker的另外一个核心概念。
简单地说，容器是镜像的一个运行实例，所不同的是，它带有额外的可写文件层。
本节将具体介绍容器的重要操作，包括创建一个容器、启动容器、终止一个容器、进入容器内执行操作、删除容器和导入导出容器来实现容器迁移等。
创建容器
Docker的容器十分轻量级，用户可以随时创建或删除容器。
新建容器
可以使用docker create 命令新建一个容器，例如：
docker create -ti centos

使用docker create 命令新建的容器处于停止状态，可以使用docker start命令启动它。
新建并启动容器
启动容器有两种方式：
基于镜像新建一个容器并启动（docker run）
将在停止状态的容器重新启动（docker start）
例如：
docker run centos /bin/echo "hello world"

如图结果：

当利用docker run 来创建并启动容器时，Docker后台要进行如下过程：
检查本地是否存在指定的镜像，不存在就从默认仓库下载。
利用镜像创建并启动一个容器。
分配一个文件系统，并在只读的镜像层外面挂载一层可读写层。
从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中。
从地址池配置一个IP地址给容器。
执行用户指定的应用程序。
执行完毕后容器被终止。
通过docker ps 命令可以查看所有运行的容器信息。
docker ps

结果如图：

我们可以看出，当执行完“hello world“后，容器着被终止，通过docker ps 命令看不到任何运行的容器信息。
通过-a 可以查看存在的容器，包括运行的和终止的容器信息。
docker ps -a

结果如图：

结果信息列如下：
CONTAINER ID:容器ID（唯一）
IMAGE:依赖的镜像
COMMAND:执行的命令
STATUS:当前容器的状态
PORTS：容器端口信息
NAMES:容器别名（可自定义）
通过结果截图，我们看到了刚刚我们执行的“hello world”容器的信息。目前它的状态是终止。
案例：启动一个bash终端，允许用户进行交互：
docker run -t -i centos /bin/bash

其中，-t选项让Docker分配一个伪终端并绑定到容器的标准输入上，-i则让容器的标准输入保持打开。
结果如图：

案例2：很多的时候，需要让Docker容器在后台以守护态(Daemonized)形式运行，如下执行命令：
docker run -d centos /bin/sh -c "while true; do echo hello world; sleep 1; done"

结果如图：

我们可以通过docker logs [容器ID]查看容器日志。
docker logs 3a

进入容器
在使用-d 参数时，容器启动后进入后台，用户无法看到容器中的信息。某些时候如果需要进入容器进行操作，我们可以使用docker attach命令，docker exec命令，以及nesenter工具等，比较常用的还是docker exec命令。
下面我们来介绍一下使用：
docker exec -ti 3adb27e44229 /bin/bash

其中，“3adb27e44229”为容器ID。
这样我们就可以进入一个后台运行的容器内部操作了。
终止容器
可以使用docker stop命令来终止一个运行的容器。
docker stop 3adb27e44229

同时，也可以使用docker restart命令来重启一个容器。
docker restart 3adb27e44229

删除容器
使用docker rm命令删除处于终止状态的容器。例如：
docker rm 3adb27e44229

如果该容器在运行中强制删除，需要使用-f参数。
导出和导入容器
导出容器
使用docker export命令导出容器。例如：
docker export 3adb27e44229 >testexport.tar

导入容器
使用docker import命令导入，成为镜像。例如：
cat testexport.tar | docker import - test

仓库
仓库(Respository)是集中存放镜像的地方。
仓库又分为公共仓库和私有仓库。本部分的内容主要是讲解，如何在注册服务器(Registry)中下载某个仓库的某个版本的镜像。
AliYun docker（阿里容器服务器）
注册地址：https://dev.aliyun.com



执行复制命令：

以上完成了从公有仓库下载镜像的步骤。对于创建私有仓库的方式，暂略。
数据管理
在使用Docker的过程中，往往需要能查看容器内应用产生的数据，或者需要把容器内的数据进行备份，甚至多个容器之间进行数据的共享，这必然涉及容器的数据管理操作。
容器中管理数据主要有两种方式：
 数据卷(Data Volumes)
 数据卷容器(Data Volume Containers)
本节将首先讲解如何在容器内创建数据卷，并且把本地的目录或文件挂载到容器内的数据卷。而后，会讲解如何使用数据卷容器在容器和主机、容器和容器之间共享数据。
数据卷
数据卷是一个可供容器使用的特殊目录，它绕过文件系统，可以提供很多有用的特性。
 数据卷可以在容器之间共享和重用。
 对数据卷的修改会马上生效。
 对数据卷的更新，不会影响镜像。
 卷会一直存在，知道没有容器使用。
数据卷的使用，类似于Linux下对目录或文件进行mount(挂载)操作。
在容器内创建一个数据卷
在用docker run命令的时候，使用**- v标记可以在容器内创建一个数据卷。多次使用-v**标记可以创建多个数据卷。
挂载一个主机目录作为数据卷
使用**-v**标记也可以制定挂载一个本地的已有目录到容器中去作为数据卷。
docker run -d -P --name web -v /yundata/webapps:/opt/webapp mycentos

解释命令：该命令是将mycentos镜像运行，并将其后台运行，同时暴露所有容器需要暴露的端口，同时将容器的别名设置为“web“，最后将本地（宿主）主机的_yundata_webapps目录挂载到容器内_opt_webapp目录上。
-P暴露所有容器需要暴露的端口(比如：8080,80等)
—name将容器设置别名
-v挂载数据卷,**😗*冒号前为本地（宿主）主机的目录，冒号后为容器内目录
这个命令演示测试的时候十分方便，比如：用户可以放置一些程序或数据到本地目录中，然后在容器内运行、访问使用。
注意：本地目录的路径必须要是绝对路径，如果目录不存在Docker会自动创建。
Docker挂载的数据卷默认权限是读写(rw)，用户也可以，ro指定为只读。
docker run -d -P --name web -v /yundata/webapps:/opt/webapp:ro  mycentos

加入了**:ro**之后，容器内挂载的数据卷的数据就无法修改了。
挂载一个本地主机文件作为数据卷
这种方式目前已经不建议使用了，从Docker1.1.0起，推荐的方式是直接挂载文件所在的目录。
数据卷容器
如果用户需要在容器之间共享一些持续更新的数据，最简单的方式是使用数据卷容器，数据卷容器其实就是一个普通的容器，专门用它提供数据卷供其他容器挂载使用。
案例：创建一个数据卷容器，并将其挂载到两个容器中，共享。
第一步：创建数据卷容器，并创建数据卷dbdata目录，同时，将数据卷容器命名为dbdata
docker run -d -v /dbdata --name dbdata mycentos

第二步：将数据卷容器，挂载到两个容器中，使用—volumes-from来挂载dbdata容器中的数据卷
docker run -d --volumes-from dbdata --name db1 mycentos
docker run -d --volumes-from dbdata --name db2 mycentos

此时，容器db1和db2都挂载同一个数据卷到相同的**/dbdata目录**。三个容器任何一方在该目录下的写入，其他容器都可以看到。
多次使用**—volumes-from**参数来从多个容器挂载多个数据卷。还可以从其他已经挂载了容器卷的容器来挂载数据卷。例如：
docker run -d --name db3 --volumes-from db1 mycentos


注意：使用**—volumes-from**参数所挂载数据卷的容器自身并不需要保持在运行状态。

如果删除了挂载的容器（包括dbdata、db1和db2），数据卷并不会自动删除。如果要删除一个数据卷，必须在删除最后一个还挂载着它的容器时显示使用docker rm -v命令来指定同时删除关联的容器。
通过数据卷和数据卷容器对容器内数据进行共享等操作，通过这些机制，即使容器在运行中出现故障，用户也不必担心数据发生丢失，只需要快速创建容器即可。
在生产环境中，在使用数据卷或数据卷容器之外，定期将主机的本地数据备份，或者使用支持容错的存储系统，包括RAID或分布式文件系统。
网络配置
大量的互联网应用服务包括多个服务组件，这往往需要更多个容器之间通过网络通信进行相互配合。
Docker目前提供了映射容器端口到宿主主机和容器互联机制来为容器提供网络服务。
本节将讲解如何使用Docker的网络功能。包括使用端口映射机制来将容器内应用服务提供给外部网络，以及通过容器互联系统让多个容器之间进行快捷的网络通信。
端口映射实现访问容器
从外部访问容器应用
在启动容器的时候，如果不指定对应参数，在容器外部是无法通过网络来访问容器内的网络应用和服务的。
当容器中运行一些网络应用，例如：tomcat,nginx等，要让外部访问这些应用时，可以通过**-P或-p参数来指定端口映射。当使用-P标记时，Docker会随机映射一个30000-49900**的端口至容器内部开发的网络端口.
例如：
docker run -d -P mytomcat

结果如图：

可以看出，容器的8080端口映射到了本地32772端口，我们可以通过这个端口访问到容器中的tomcat服务。
例如：
http://127.0.0.1:32772

如图：

-p(小写的)则可以指定要映射的端口，并且，在一个指定端口上只可以绑定一个容器。支持的格式如下：
ip:hostPost:containerPort

ip::containerPort

hostPost:containerPort

映射所有端口地址
docker run -d -p 8080:8080 mytomcat

映射到指定地址的指定端口
docker run -d -p 127.0.0.1:8080:8080 mytomcat

映射到指定地址的任意端口
docker run -d -p 127.0.0.1::8080 mytomcat

查看映射端口配置
docker port (容器ID/容器别名) 5000

查看所有网络配置信息
docker inspect (容器ID/容器别名)

结果截图：

容器互联实现容器间通信
容器的连接(linking)系统是除了端口映射外另外一种可以与容器中应用进行交互的方式。它会在源和接收容器之间创建一个隧道。接收容器可以看到源容器指定的信息。
自定义容器命名
使用**—name**标记可以为容器自定义命名：
docker run -d -P --name tomcat mytomcat

注意：容器的名称是唯一的。如果已经命名了一个叫tomcat的容器，当你要再次使用tomcat这个名称的时候，需要先用docker rm来删除之前创建的同名容器。
容器互联
使用**—link**参数可以让容器之间安全的进行交互。
格式：
—link name:alias，其中name是要链接的容器的名称，alias是这个连接的别名。
案例：
1.先创建一个数据库容器(db)
docker run -d --name db -e MYSQL_ROOT_PASSWORD=qaz123  mysql

2.创建一个web容器(tomcat)，并将它连接到db容器
docker run -d -P --name web --link db:db mytomcat

docker常用命令
# 查看docker的版本信息
$ docker version

# 查看安装docker的信息
$ docker info

# 查看本机Docker中存在哪些镜像
$ docker images

# 检索image
$ docker search ubuntu:14.04

# 在docker中获取ubuntu镜像
$ docker pull ubuntu:14.04

# 显示一个镜像的历史
$ docker history birdben/ubuntu:v1

# 列出一个容器里面被改变的文件或者目
$ docker diff birdben/ubuntu:v1

# 从一个容器中取日志
$ docker logs birdben/ubuntu:v1

# 显示一个运行的容器里面的进程信息
$ docker top birdben/ubuntu:v1

# 从容器里面拷贝文件/目录到本地一个路径
$ docker cp ID:/container_path to_path

# 列出当前所有正在运行的容器
$ docker ps

# 列出所有的容器
$ docker ps -a

# 列出最近一次启动的容器
$ docker ps -l

# 查看容器的相关信息
$ docker inspect $CONTAINER_ID

# 显示容器IP地址和端口号，如果输出是空的说明没有配置IP地址（不同的Docker容器可以通过此IP地址互相访问）
$ docker inspect --format='{{.NetworkSettings.IPAddress}}' $CONTAINER_ID

# 保存对容器的修改 
$ docker commit -m "Added ssh from ubuntu14.04" -a "birdben" 6s56d43f627f3 birdben/ubuntu:v1

# 参数：
# -m参数用来来指定提交的说明信息；
# -a可以指定用户信息的；
# 6s56d43f627f3代表的时容器的id；
# birdben/ubuntu:v1指定目标镜像的用户名、仓库名和 tag 信息。

# 构建一个容器 
$ docker build -t="birdben/ubuntu:v1" .

# 参数：
# -t为构建的镜像制定一个标签，便于记忆/索引等
# . 指定Dockerfile文件在当前目录下，也可以替换为一个具体的 Dockerfile 的路径。

# 在docker中运行ubuntu镜像
$ docker run <相关参数> <镜像 ID> <初始命令>

# 守护模式启动
$ docker run -it ubuntu:14.04

# 交互模式启动
$ docker run -it ubuntu:14.04 /bin/bash

# 指定端口号启动
$ docker run -p 80:80 birdben/ubuntu:v1

# 指定配置启动
$ sudo docker run -d -p 10.211.55.4:9999:22 birdben/ubuntu:v1 '/usr/sbin/sshd' -D

# 参数：
# -d：表示以“守护模式”执行，日志不会出现在输出终端上。
# -i：表示以“交互模式”运行容器，-i 则让容器的标准输入保持打开
# -t：表示容器启动后会进入其命令行，-t 选项让Docker分配一个伪终端（pseudo-tty）并绑定到容器的标准输入上
# -v：表示需要将本地哪个目录挂载到容器中，格式：-v <宿主机目录>:<容器目录>，-v 标记来创建一个数据卷并挂载到容器里。在一次 run 中多次使用可以挂载多个数据卷。
# -p：表示宿主机与容器的端口映射，此时将容器内部的 22 端口映射为宿主机的 9999 端口，这样就向外界暴露了 9999 端口，可通过 Docker 网桥来访问容器内部的 22 端口了。
# 注意：这里使用的是宿主机的 IP 地址：10.211.55.4，与对外暴露的端口号 9999，它映射容器内部的端口号 22。ssh外部需要访问：ssh root@10.211.55.4 -p 9999
# 不一定要使用“镜像 ID”，也可以使用“仓库名:标签名”

# start 启动容器
$ docker start 117843ade696117843ade696
# stop 停止正在运行的容器
$ docker stop 117843ade696117843ade696
# restart 重启容器
$ docker restart 117843ade696117843ade696
# rm 删除容器
$ docker rm 117843ade696117843ade696
# rmi 删除镜像
$ docker rmi ed9c93747fe1Deleted

# 登录Docker Hub中心
$ docker login

# 发布上传image（push）
$ docker push birdben/ubuntu:v1

修改密码：
echo 'newpassword' |passwd root --stdin

映射端口和服务
docker run -d -p 8888:22 myssh4:latest /usr/sbin/sshd -D

提交修改：
docker commit 81041ab6b5f6 myssh4

运行：
docker run -it 3b5e50532f20 /bin/bash

执行容器某个应用：
docker exec 81041ab6b5f6 /bin/bash

查看当前运行容器列表：
docker ps

查看所有镜像列表:
docker images

停止某个容器：
docker stop [name/容器id]

ssh登录:
ssh root@192.168.203.134 -p 8888

阿里docker仓库以及加速器:
https://cr.console.aliyun.com/

删除容器：
docker rm [CONTAINER ID(容器id)]

删除镜像：
docker rmi [IMAGE ID(镜像id)]

centos7下安装docker:
curl -sSL http://acs-public-mirror.oss-cn-hangzhou.aliyuncs.com/docker-engine/internet | sh -

获得镜像：
docker pull NAME[:TAG]

在aliyun仓库获得镜像：https://dev.aliyun.com
DOCKER容器时区问题解决
[root@ab374724d6b0 ~]# rm -rf /etc/localtime 
[root@ab374724d6b0 ~]# ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

Dockerfile中，ADD和COPY都是拷贝本机文件到container制作image。
那么ADD和COPY有什么区别呢？
ADD比COPY多了2个功能：
① ADD 的可以为URL
② ADD 到container的tar文件会被自动解压，并删除原tar文件。
编写者
 zzxb
修改者
再难也要坚持
版本
V 1.0.1

V 1.0.0
修改日志
 2020-3-16 修改部分错别字
 2016-9-2:
 [x] 初次创建文档
 2016-9-8：
 [x] 新增了idea中Maven骨架生成慢问题的解决方案
参考资源
以下是在编写文档中收集的资源,对深入理解与运用有帮助
在Windows下安装Maven

文章目录
一、Docker技术简介
1、docker 概述
2、虚拟机技术（VM）与容器虚拟技术（docker）
二、Docker安装
1.卸载旧版本
2.安装 Docker Engine-Community使用 Docker 仓库进行安装
3.安装 Docker Engine-Community
4.启动docker
三、Docker 相关操作命令
1、进程
2、镜像
3、容器
war挂载宿主机
镜像导出与恢复

一、Docker技术简介
1、docker 概述
 Docker是解决运行环境和配置问题的软件容器 , 方便做持续集成并有助于整体发布的容器虚拟化技术。

 

作用：

 Docker技术通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的应用及其运行环境“一次封装，到处运行”，实现了跨平台、跨服务器，解决了不同版本环境的兼容问题。

 

docker组成：

1、镜像仓库

存放镜像的地方
2、镜像

相当于python里面类的概念，是静态的，不能直接使用
3、容器

是通过镜像创建的，相当于实例的概念，是动态的，可以访问的
 
2、虚拟机技术（VM）与容器虚拟技术（docker）
区别：





VM
docker




机制
虚拟一套硬件，并在其上运行一个完整操作系统及应用
应用运行于宿主机内核，无自己的内核，不进行硬件虚拟


启动速度
几十秒或几分钟
几秒或几十毫秒


大小
几个G或几十G
mb


由上对比可知，容器要比传统虚拟机更为轻便
二、Docker安装
1.卸载旧版本
较旧的 Docker 版本称为 docker 或 docker-engine 。如果已安装这些程序，请卸载它们以及相关的依赖项。
sudo yum remove  docker \         
                 docker-client \         
                 docker-client-latest \         
                 docker-common \         
                 docker-latest \         
                 docker-latest-logrotate \         
                 docker-logrotate \         
                 docker-engine

2.安装 Docker Engine-Community使用 Docker 仓库进行安装
在新主机上首次安装 Docker Engine-Community 之前，需要设置 Docker 仓库。之后，您可以从仓库安装和更新 Docker。
设置仓库

安装所需的软件包。yum-utils 提供了 yum-config-manager ，并且 device mapper 存储驱动程序需要device-mapper-persistent-data 和 lvm2。
sudo  yum install -y yum-utils \ 
                     device-mapper-persistent-data \ 
                     lvm2

使用以下命令来设置稳定的仓库。

阿里云
sudo  yum-config-manager \
      --add-repo \  
      http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3.安装 Docker Engine-Community
安装最新版本的 Docker Engine-Community 和containerd，或者转到下一步安装特定版本：
sudo yum install docker-ce docker-ce-clicontainerd.io

4.启动docker
sudo systemctl start docker

一直输入y回车即可。
三、Docker 相关操作命令
1、进程




命令
命令解释




docker -v
查看docker版本


docker --help
查看docker命令


docker version
查看docker 服务端与客户端版本详情


systemctl start docker
启动docker进程


systemctl stop docker
关闭docker进程


systemctl restart docker
重启docker进程


systemctl status docker
查看docker运行状态


systemctl stop firewalld
关闭防火墙


2、镜像
docker加速

默认情况下，docker下载镜像是从官网下载，下载速度特别特别的慢。使用阿里云加速器可以提升获取Docker官方镜像的速度。
① 在指定目录创建文件（如已存在请忽略此步）：

vi  /etc/docker/daemon.json

② 修改文件内容

{“registry-mirrors”:[“https://v2c6fjn8.mirror.aliyuncs.com”]}

③ 重启docker服务

systemctl restart docker





命令
命令解释




docker images
查看本地镜像


docker search 镜像名
搜索镜像


docker pull 镜像名
拉取镜像


docker pull 镜像名:版本号
拉取指定版本的镜像


docker rmi 镜像id
删除镜像


3、容器




命令
命令解释




docker create --name=容器名 镜像名
在指定镜像下创建容器（用的频率不多）


docker ps
查看运行中的镜像


docker ps -a
查看所有镜像


docker start 容器名或容器id(前2-3位就可以)
运行容器


docker stop 容器名或容器id(前2-3位就可以)
停止运行容器


docker rm 容器id或容器名
删除没有运行的容器


docker rm -f 容器id或容器名
强行删除容器


docker start$(docker ps -a -q)
启用所有容器


① docker stop$(docker ps -a -q)  ②docker rm $(docker ps -a -q)
删除所有容器


docker run 参数 --name=容器名 镜像名
表示创建容器并进行其他的操作  （-i  运行容器 -t 容器启动后进入命令行 -v 目录映射/挂载 -d 守护进程/后台运行 -p 端口映射）


docker exec -it  容器名 /bin/bash
进入容器


docker cp a.txt 容器名:/
将宿主机的a.txt文件copy到容器的根目录下


exit
退出容器


war挂载宿主机

docker run -di --name=容器名 -v 宿主机路径:容器路径 -p 7070:8080 tomcat

镜像导出与恢复




命令
命令解释




docker save -o 新镜像名.tar 镜像名
镜像导出


docker load -i sqtomcat1.tar
镜像导入