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
安装vsftpd+Nignx(图片服务器)
环境搭建
代码测试
  
  
第八章 发布镜像到阿里云
步骤
 

 
第一章 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安装教程(Ubuntu) 本人腾讯云服务器安装成功
 
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.连接数据库的图形化界面
## Mysql 解决连接客户端时出现1251 client does not support ...问题
ALTER USER  'root'@'%' IDENTIFIED WITH mysql_native_password BY 'mysql密码';
ALTER USER  'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'mysql密码';

# 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
# 以带密码的方式启动, 密码设置为root
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  --requirepass "root"
# 或者不适用上面的容器卷, 使用docker 默认配置, 并设置自动重启
docker run --name redis -p 6379:6379 -d --restart=always redis:latest redis-server --appendonly yes --requirepass "root"

# 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 mongo

# 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
 
 
安装vsftpd+Nignx(图片服务器)
 
环境搭建
 
 
 
通过搭建Nginx和vfstpd 实现文件服务器
 
 
# 1. 安装docker-compose . 实现对相关软件的配置
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# 2. 编写docker-compose.yml 配置文件
## 需要需要修改的地方的是: 
## /data/ftp:/home/vsftpd/ftpuser(20行), /data/ftp 是ftp中图片存放的地址
## /data/ftp:/home/images(11行) , /data/ftp 是Nginx来对应ftp中图片存放的地址
## FTP_USER,FTP_PASS 代表ftp用户的账号和密码, 需要在Linux中提前添加用户 
## 添加用户命令 a. useradd ftpuser,b. passwd ftpuser 然后输入自定义密码  
## ~/pic/nginx/conf/nginx.conf(9行), 注意! 需要提前准备Nginx的配置文件nginx.conf, ~ 代表home目录
## PASV_ADDRESS: 192.168.40.21, PASV_ADDRESS后面填写的是ftp服务器的ip
----------------docker-compose.yml---------------------
version: '2'
services:
  nginx-image:
    image: nginx:1.15.8
    ports:
      - "80:80"
    volumes:
      - ~/pic/nginx/html:/usr/share/nginx/html
      - ~/pic/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
      - ~/pic/nginx/logs:/var/log/nginx
      - /data/ftp:/home/images
    restart: always
  vsftpd:
    image: fauria/vsftpd
    ports:
      - "20:20"
      - "21:21"
      - "21100-21110:21100-21110"
    volumes:
      - /data/ftp:/home/vsftpd/ftpuser
    environment:
      FTP_USER: ftpuser
      FTP_PASS: 1q2w3e4r
      PASV_ADDRESS: 192.168.40.21
      PASV_MIN_PORT: 21100
      PASV_MAX_PORT: 21110
      LOCAL_UMASK: 022
    restart: always
-------------------------------------

# 3. 分享上面需要nginx.conf文件放在下面了
vim /home/pic/nginx/conf/nginx.conf

# 4. docker-compose执行, 需要在docker-compose.yml所在的目录下执行
docker-compose up -d

# 5. docker ps(查看容器是否执行, 下图1)
 
图1
 
 
上面第三步所需的nginx.conf配置文件
 
# root   /data/ftp/, /data/ftp/代表的是我们上面配置的ftp图片存放的地址, 只需要修改这一处
location / { root   /data/ftp/;i ..... }
 
完整配置文件
 
#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       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  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   /data/ftp/; # /data/ftp/代表的是我们上面配置的ftp图片存放的地址, 只需要修改这一处
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }



}

 
代码测试
 
添加依赖
 
<!--文件上传与下载-->
         <dependency>
             <groupId>commons-net</groupId>
             <artifactId>commons-net</artifactId>
             <version>3.3</version>
         </dependency>
         <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
            <scope>compile</scope>
        </dependency>
 
工具类代码
 
package com.clife.common.utils;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;

import java.io.*;

/**
 * ftp上传下载工具类
 */
public class FtpUtil {

	private static   String hostname="192.168.40.21";
	private static   int port=21;
	private static   String ftpusername="ftpuser";
	private static   String ftppassword="ftpuser";
	private static   String basePath="/data/ftp";
	private static   String filePath="";

	//日志打印
	private static Logger logger = LoggerFactory.getLogger(FtpUtil.class);

	/**
	 * 文件上传封装方法
	 * @param sourceFileName 本地文件绝对地址,目录+文件名, eg:D:\\1.jpg
	 * @param targetFileName 上传到ftp服务器/data/ftp/目录下的文件名
	 * @return
	 * @throws FileNotFoundException
	 */
	public static boolean ftpUploadFile(String sourceFileName, String targetFileName) throws FileNotFoundException {
		FileInputStream in=new FileInputStream(new File(sourceFileName));
		boolean b = uploadFile(hostname, port, ftpusername, ftppassword, basePath, filePath, targetFileName, in);
		return b;
	}

	/**
	 * Description: 向FTP服务器上传文件
	 * @param host FTP服务器hostname
	 * @param port FTP服务器端口
	 * @param username FTP登录账号
	 * @param password FTP登录密码
	 * @param basePath FTP服务器基础目录
	 * @param filePath FTP服务器文件存放路径。例如分日期存放：/2015/01/01。文件的路径为basePath+filePath
	 * @param filename 上传到FTP服务器上的文件名
	 * @param input 输入流
	 * @return 成功返回true，否则返回false
	 */
public static boolean uploadFile(String host, int port, String username, String password, String basePath,
			String filePath, String filename, InputStream input) {
		boolean result = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(host, port);// 连接FTP服务器
			logger.info("连接ftp成功...");
			// 如果采用默认端口，可以使用ftp.connect(host)的方式直接连接FTP服务器
			ftp.login(username, password);// 登录
			logger.info("ftp用户登陆成功！！！");
			reply = ftp.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return result;
			}
			//切换到上传目录
			if (!ftp.changeWorkingDirectory(basePath+filePath)) {
				//如果目录不存在创建目录
				String[] dirs = filePath.split("/");
				String tempPath = basePath;
				for (String dir : dirs) {
					if (null == dir || "".equals(dir)) {continue;}
					tempPath += "/" + dir;
					if (!ftp.changeWorkingDirectory(tempPath)) {
						if (!ftp.makeDirectory(tempPath)) {
							return result;
						} else {
							ftp.enterRemotePassiveMode();
							ftp.changeWorkingDirectory(tempPath);
						}
					}
				}
			}
			//设置上传文件的类型为二进制类型
			ftp.setFileType(FTP.BINARY_FILE_TYPE);
			//上传文件
			if (!ftp.storeFile(filename, input)) {
				logger.info("文件 {} 上传失败!",filename);
				return result;
			}
			input.close();
			ftp.logout();
			result = true;
			logger.info("文件 {} 上传成功!",filename);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return result;
	}



	public static void main(String[] args) {
		//FileInputStream in=new FileInputStream(new File("D:\\1.jpg"));
		//boolean flag = uploadFile("192.168.40.21", 21, "ftpuser", "ftpuser", "/data/ftp","", "123.png", in);
		boolean flag = false;
		try {
			flag = ftpUploadFile("D:\\11.jpg", "6666.jpg");
			System.out.println(flag);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}


	}
}

 
图片访问
 http://192.168.40.21/6666.jpg
 
第八章 发布镜像到阿里云
 
步骤
 
# 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
 
Docker技术简介
Docker的应用场景
Docker 的组成
docker进程相关操作
docker加速
镜像操作
运行容器的相关操作
访问tomcat
镜像备份
容器之间的关联
  
 

 
Docker技术简介
 
 
Docker 如日中天，这不是单纯的炒的概念，Docker的确解决了开发和运费的痛点，比如版本的搬迁，从测试环境搬迁到预发、生产环境，在企业开发与测试中，得到了非常广泛的应用。
 
Docker 是一个开放源码的软件项目，基于GO语言
Docker 可以让开发打包他们的应用以及依赖包到一个轻量级、可移植的容器中
Docker 打包好容器，可以发布到任何流行的 Linux 机器上，也可以实现虚拟化
容器是完全使用沙箱机制，互相之间不会有任何接口
Docker 容器性能开销极低，这个才是关键
Docker 使用客户端-服务器（C/S）架构模式，使用远程API来管理和创建Docker容器
 
Docker的应用场景
 
Web应用自动化打包和发布
自动化测试和持续集成、发布
在服务器环境中部署和调整数据库或其他的后台应用
使用Docker可以实现开发环境、测试环境、生成环境的一致性
 

 Docker 借鉴了标准的集装箱的概念。标准的集装箱将货物运往世界各地，Docker 将这个模型运行到自己的设计中。唯一不同的是: 集装箱是运输货物，Docker是运输软件。
 
Docker和传统的VM的区别
 

 传统的虚拟机基于安装操作系统上的虚拟机管理系统，如 VirtualBox 和 VMWare等，创建虚拟机，在虚拟机上安装从操作系统，在从操作系统中安装部署各种应用。
 

 Docker容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面实现虚拟化。
 
docker 与传统的VM对比:
 
启动速度：vm 一般几十秒或者几分钟，docker几秒或者毫秒
大小：vm 一般几G，docker只有几兆
 
Docker 的组成
 

 Docker 需要分为三部分： 仓库、 镜像 容器
 
名称
说明
Docker镜像
Docker 镜像是用于创建Docker容器的模板。镜像是基于联合文件系统的一种层式结构，由一系列指令一步一步构建出来。
Docker容器
容器是独立运行的一个或多个应用。镜像相当于类，容易相当于类的实例
Docker客户端
Docker客户端通过命令行或者其他工具使用Docker API与Docker的守护进程通信
Docker主机
一个物理或者虚拟的机器用于执行Docker守护进程和容器
Docker守护进程
是Docker服务器端进程，负责支撑Docker容器的运行以及镜像的管理
Docker仓库
Docker仓库用来保存镜像，可以理解为代码控制中的代码仓库。Docker Hub提供了庞大的镜像集合供使用，用户也可以将自己本地的镜像推送到Docker仓库供其他人下载
docker进程相关操作
 
查看docker版本
 
docker -v
 
查看docker命令
 
docker --help
 
查看docker服务端与客户端版本详情
 
docker version
 
启动docker
 
systemctl start docker
 
关闭docker
 
systemctl stop docker
 
重启docker
 
systemctl restart docker
 
查看docker运行状态
 
systemctl status docker
 
关闭防火墙
 
systemctl stop firewalld
 
docker加速
 
默认情况下，docker下载镜像是从官网下载，下载速度特别慢，我们可以使用阿里云加速器可已提升获取Docker官网镜像的速度。
 
执行目录创建文件（如已存在请忽略此步）
 
touch /ect/docker/deamon.json
 
修改文件内容为
 
   {
     "registry-mirrors": ["https://v2c6fjn8.mirror.aliyuncs.com"]
   }
 
注意：此网址是从阿里云控制台复制过来的，每个登录用户都不一样。当然用这个也是可以的。
 
重启docker服务
 
systemctl restart docker
 
镜像操作
 
查看本地镜像
 
docker images
 
搜索镜像，这里以安装tomcat为例
 
[root@iZbp18425116ezmjdmbdgeZ ~]# docker search tomcat
NAME                          DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
tomcat                        Apache Tomcat is an open source implementati…   3193      [OK]       
tomee                         Apache TomEE is an all-Apache Java EE certif…   94        [OK]       
dordoka/tomcat                Ubuntu 14.04, Oracle JDK 8 and Tomcat 8 base…   58                   [OK]
kubeguide/tomcat-app          Tomcat image for Chapter 1                      31                   
consol/tomcat-7.0             Tomcat 7.0.57, 8080, "admin/admin"              18                   [OK]
cloudesire/tomcat             Tomcat server, 6/7/8                            15                   [OK]
aallam/tomcat-mysql           Debian, Oracle JDK, Tomcat & MySQL              13                   [OK]
arm32v7/tomcat                Apache Tomcat is an open source implementati…   11                   
rightctrl/tomcat              CentOS , Oracle Java, tomcat application ssl…   7                    [OK]
maluuba/tomcat7-java8         Tomcat7 with java8.                             6                    
arm64v8/tomcat                Apache Tomcat is an open source implementati…   6                    
unidata/tomcat-docker         Security-hardened Tomcat Docker container.      5                    [OK]
jelastic/tomcat               An image of the Tomcat Java application serv…   3                    
amd64/tomcat                  Apache Tomcat is an open source implementati…   3                    
cfje/tomcat-resource          Tomcat Concourse Resource                       2                    
fabric8/tomcat-8              Fabric8 Tomcat 8 Image                          2                    [OK]
oobsri/tomcat8                Testing CI Jobs with different names.           2                    
camptocamp/tomcat-logback     Docker image for tomcat with logback integra…   1                    [OK]
picoded/tomcat7               tomcat7 with jre8 and MANAGER_USER / MANAGER…   1                    [OK]
99taxis/tomcat7               Tomcat7                                         1                    [OK]
chenyufeng/tomcat-centos      tomcat基于centos6的镜像                              1                    [OK]
ppc64le/tomcat                Apache Tomcat is an open source implementati…   1                    
softwareplant/tomcat          Tomcat images for jira-cloud testing            0                    [OK]
secoresearch/tomcat-varnish   Tomcat and Varnish 5.0                          0                    [OK]
s390x/tomcat                  Apache Tomcat is an open source implementati…   0                    
[root@iZbp18425116ezmjdmbdgeZ ~]# 

 
找到所有的镜像，拉取镜像
 
docker pull 镜像ID  #最新版本 如： docker pull tomcat
docker pull tomcat:7 # 指定版本
 
删除镜像
 
docker rmi 容器名称
 
本地以有镜像，创建容器
 
docker create --name=容器名称 镜像名称
 
示例:
[root@iZbp18425116ezmjdmbdgeZ ~]# docker create --name=myTomcat tomcat
629104460e3fe485649e5784ec0c34f4dcc2277115937a54be00b968dc646510
 
查看容器
 
docker ps # 查看正在运行的容易
docker ps -a # 查看所有容器
 
运行容器
 
docker start myTomcat # start 后端可以跟容易id (前2-3位) 或者容器名称
 
停止容器
 
docker stop myTomcat
 
删除没有运行的容器
 
docker rm 容器id或者名称
 
删除正在运行的容器
 
docker -rm -f 容器id或者名称
 
删除所有容器
 
# 先停止所有的容器
docker stop $(docker ps -a -q)

# 删除
docker rm $(docker ps -a -q)
 
运行容器的相关操作
 
查看docker run 命令 ，创建并且启动容器
 
docker run --help
docker run 后面的参数
	-i # 运行容器
	-t # 容器启动后，进入命令行
	-v # 目录映射 --挂载
	-d # 守护进程 --后台运行
	-p # 端口映射 如容器里面有tomcat，你本地的windows想访问:
	# docker tomcat 端口号是8080，需要在虚拟机映射一个端口9099
	# windows才可以访问 http://虚拟机ip:9099
 
创建容器，并且进入命令行
 
docker run -it --name=myTomcat2 tomcat /bin/bash
 
退出
 
exit
 
退出之后，重新进入容器
 
# 创建一个守护的容器
docker run -id --name=myTomcat2 tomcat
# 进入
docker exec -it myTomcat2 /bin/bash
 
宿主机与docker容器的文件传递
 
1、在宿主机上创建一个文件
touch test.txt

2、把文件复制到容器里面去
docker cp test.txt myTomcat2:/

3、进入跟目标
cd /
 
从容器中的文件copy到宿主机中
 
touch abc.txt

# 退出容器
exit

# 将容器中的文件复制到宿主机
docker cp myTomcat2:abc.txt /root
 
访问tomcat
 
# 启动并作为守护进程
# -p 宿主机的端口: 容器里应用的端口8080
# war 挂载宿主机 -v 宿主机的路径: 容器路径
docker run -di --name --myTomcat -p 8080:8080 -v /usr/local/tomcat/webapps:/usr/local/tomcat/webapps tomcat

http://虚拟机ip:9999
 
 # 把war包放到宿主机的挂载目录中，直接刷新浏览器就出现项目的页面
# 微服务 k8s 容器式的性能测试
 
镜像备份
 
docker save -o tomcat.tar 镜像名称

# 把tomcat.tar 放到其他电脑，其他人变成镜像
docker load -i tomcat.tar
 
容器之间的关联
 
docker run -di --name=tomcat2 -p 8080:8080 --link mysql

 
 
 
  
 
   
 
   

    
   
 
  
 
  

   image
  
 
 
 
 
下载地址......
 
 
好书推荐、视频分享，公众号读书ReadBook与您一起进步，回复关键字 41219直接获取下载链接
 
 
内容简介 · · · · · ·
 
 
本书从Docker基本原理开始，深入浅出地讲解Docker的构建与操作，内容系统全面，可帮助开发人员、运维人员快速部署Docker应用。本书分为四大部分：基础入门、实战案例、进阶技能、开源项目，第一部分（第1～8章）介绍Docker与虚拟化技术的基本概念，包括安装、镜像、容器、仓库、数据卷，端口映射等；第二部分（第9～16章）通过案例介绍Docker的应用方法，包括与各种操作系统平台、SSH服务的镜像、Web服务器与应用、数据库的应用、各类编程语言的接口、容器云等，还介绍了作者在容器实战中的思考与经验总结；第三部分（第17～21章）是一些进阶技能，如Docker核心技术实现原理、安全、高级网络配置、libernetwork插件化网络功能等；第四部分（第22～28章）介绍与容器开发相关的开源项目，包括Etcd、Docker Machine、Docker Compose、Docker Swarm、Mesos、Kubernetes等。
 
 
第2版参照Docker技术的*新进展对全书内容进行了修订，并增加了第四部分专门介绍与容器相关的知名开源项目，利用好这些优秀的开源平台，可以更好地在生产实践中受益。
 
 
作者简介 · · · · · ·
 
 
杨保华：博士，毕业于清华大学，现为 IBM 资深研究员。主要负责核心系统方案的架构设计和研发，包括云计算、大数据、金融科技等领域。他热爱开源文化，是容器、软件定义网络、区块链等开源技术的早期推广者，曾为 OpenStack、HyperLedger 等开源项目作出了贡献。个人主页为 https://yeasy.github.com。
 
 
戴王剑：资深架构师，多年来一直从事系统平台、计算机网络、服务器架构设计，负责过多个省级项目的架构设计。热衷于开源事业，积极推动开源技术在生产实践中的应用。
 
 
曹亚仑：阿里云高级系统工程师（花名法喜），上云架构师，擅长云产品运维与云平台技术保障，对PaaS、IaaS层架构设计与实践有较丰富的实战经验。同时也是DevOps实践者与全栈开发者。微信allengaller，个人主页为allengaller.github.io。
 
 
目录 · · · · · ·
 
 
第2版前言
 第1版前言
 第一部分　基础入门
 第1章　初识容器与Docker 3
 1.1　什么是Docker 3
 1.2　为什么要使用Docker 5
 1.3　Docker与虚拟化 7
 1.4　本章小结 9
 第2章　核心概念与安装配置 10
 2.1　核心概念 10
 2.2　安装Docker 11
 2.2.1　Ubuntu环境下安装Docker 12
 2.2.2　CentOS环境下安装Docker 14
 2.2.3　通过脚本安装 14
 2.2.4　Mac OS环境下安装Docker 15
 2.2.5　Windows环境下安装Docker 20
 2.3　配置Docker服务 21
 2.4　推荐实践环境 22
 2.5　本章小结 22
 第3章　使用Docker镜像 23
 3.1　获取镜像 23
 3.2　查看镜像信息 25
 3.3　搜寻镜像 28
 3.4　删除镜像 29
 3.5　创建镜像 31
 3.6　存出和载入镜像 32
 3.7　上传镜像 33
 3.8　本章小结 33
 第4章　操作Docker容器 34
 4.1　创建容器 34
 4.2　终止容器 39
 4.3　进入容器 40
 4.4　删除容器 42
 4.5　导入和导出容器 42
 4.6　本章小结 44
 第5章　访问Docker仓库 45
 5.1　Docker Hub公共镜像市场 45
 5.2　时速云镜像市场 47
 5.3　搭建本地私有仓库 48
 5.4　本章小结 50
 第6章　Docker数据管理 51
 6.1　数据卷 51
 6.2　数据卷容器 52
 6.3　利用数据卷容器来迁移数据 53
 6.4　本章小结 54
 第7章　端口映射与容器互联 55
 7.1　端口映射实现访问容器 55
 7.2　互联机制实现便捷互访 57
 7.3　本章小结 59
 第8章　使用Dockerfile创建镜像 60
 8.1　基本结构 60
 8.2　指令说明 62
 8.3　创建镜像 67
 8.4　使用.dockerignore文件 67
 8.5　最佳实践 67
 8.6　本章小结 68
 第二部分　实战案例
 第9章　操作系统 71
 9.1　BusyBox 71
 9.2　Alpine 72
 9.3　Debian/Ubuntu 74
 9.4　CentOS/Fedora 76
 9.5　本章小结 77
 第10章　为镜像添加SSH服务 78
 10.1　基于commit命令创建 78
 10.2　使用Dockerfile创建 80
 10.3　本章小结 82
 第11章　Web服务与应用 83
 11.1　Apache 83
 11.2　Nginx 87
 11.3　Tomcat 88
 11.4　Jetty 92
 11.5　LAMP 93
 11.6　CMS 94
 11.6.1　WordPress 94
 11.6.2　Ghost 96
 11.7　持续开发与管理 96
 11.7.1　Jenkins 97
 11.7.2　Gitlab 98
 11.8　本章小结 99
 第12章　数据库应用 100
 12.1　MySQL 100
 12.2　MongoDB 102
 12.2.1　使用官方镜像 102
 12.2.2　使用自定义Dockerfile 104
 12.3　Redis 106
 12.4　Memcached 108
 12.5　CouchDB 108
 12.6　Cassandra 109
 12.7　本章小结 110
 第13章　分布式处理与大数据平台 111
 13.1　RabbitMQ 111
 13.2　Celery 113
 13.3　Hadoop 114
 13.4　Spark 115
 13.4.1　使用官方镜像 116
 13.4.2　验证 116
 13.5　Storm 117
 13.6　Elasticsearch 119
 13.7　本章小结 120
 第14章　编程开发 121
 14.1　C/C++ 121
 14.1.1　GCC 121
 14.1.2　LLVM 122
 14.1.3　Clang 122
 14.2　Java 123
 14.3　Python 124
 14.3.1　使用官方的Python镜像 124
 14.3.2　使用PyPy 124
 14.4　JavaScript 125
 14.5　Go 127
 14.5.1　搭建并运行Go容器 127
 14.5.2　Beego 130
 14.5.3　Gogs：基于Go的Git服务 130
 14.6　PHP 130
 14.7　Ruby 132
 14.7.1　使用Ruby官方镜像 132
 14.7.2　JRuby 133
 14.7.3　Ruby on Rails 134
 14.8　Perl 135
 14.9　R 136
 14.10　Erlang 138
 14.11　本章小结 140
 第15章　容器与云服务 141
 15.1　公有云容器服务 141
 15.1.1　AWS 141
 15.1.2　Google Cloud Platform 142
 15.1.3　Azure 143
 15.1.4　腾讯云 144
 15.1.5　阿里云 144
 15.1.6　华为云 144
 15.1.7　UCloud 145
 15.2　容器云服务 145
 15.2.1　基本要素与关键特性 146
 15.2.2　网易蜂巢 146
 15.2.3　时速云 147
 15.2.4　Daocloud 148
 15.2.5　灵雀云 148
 15.2.6　数人云 149
 15.3　阿里云容器服务 150
 15.4　时速云容器平台 151
 15.5　本章小结 153
 第16章　容器实战思考 154
 16.1　Docker为什么会成功 154
 16.2　研发人员该如何看容器 155
 16.3　容器化开发模式 156
 16.4　容器与生产环境 158
 16.5　本章小结 160
 第三部分　进阶技能
 第17章　Docker核心实现技术 163
 17.1　基本架构 163
 17.2　命名空间 165
 17.3　控制组 167
 17.4　联合文件系统 169
 17.5　Linux网络虚拟化 171
 17.6　本章小结 174
 第18章　配置私有仓库 175
 18.1　安装Docker Registry 175
 18.2　配置TLS证书 177
 18.3　管理访问权限 178
 18.4　配置Registry 181
 18.4.1　示例配置 181
 18.4.2　选项 183
 18.5　批量管理镜像 188
 18.6　使用通知系统 190
 18.6.1　相关配置 190
 18.6.2　Notif?ication的使用场景 192
 18.7　本章小结 193
 第19章　安全防护与配置 194
 19.1　命名空间隔离的安全 194
 19.2　控制组资源控制的安全 195
 19.3　内核能力机制 195
 19.4　Docker服务端的防护 197
 19.5　更多安全特性的使用 197
 19.6　使用第三方检测工具 198
 19.6.1　Docker Bench 198
 19.6.2　clair 199
 19.7　本章小结 199
 第20章　高级网络功能 201
 20.1　网络启动与配置参数 201
 20.2　配置容器DNS和主机名 203
 20.3　容器访问控制 204
 20.4　映射容器端口到宿主主机的实现 206
 20.5　配置docker0网桥 207
 20.6　自定义网桥 208
 20.7　使用OpenvSwitch网桥 209
 20.8　创建一个点到点连接 211
 20.9　本章小结 212
 第21章　libnetwork插件化网络功能 213
 21.1　容器网络模型 213
 21.2　Docker网络相关命令 215
 21.3　构建跨主机容器网络 216
 21.4　本章小结 219
 第四部分　开源项目
 第22章　Etcd——高可用的键值数据库 223
 22.1　简介 223
 22.2　安装和使用Etcd 224
 22.3　使用etcdctl客户端 228
 22.3.1　数据类操作 230
 22.3.2　非数据类操作 233
 22.4　Etcd集群管理 236
 22.4.1　构建集群 236
 22.4.2　集群参数配置 238
 22.5　本章小结 240
 第23章　Docker三剑客之Docker Machine 241
 23.1　简介 241
 23.2　安装Machine 241
 23.3　使用Machine 243
 23.4　Machine命令 244
 23.5　本章小结 247
 第24章　Docker三剑客之Docker Compose 248
 24.1　简介 248
 24.2　安装与卸载 249
 24.3　Compose命令说明 252
 24.4　Compose环境变量 257
 24.5　Compose模板文件 257
 24.6　Compose应用案例一：Web负载均衡 266
 24.7　Compose应用案例二：大数据Spark集群 271
 24.8　本章小结 273
 第25章　Docker三剑客之Docker Swarm 274
 25.1　简介 274
 25.2　安装Swarm 275
 25.3　使用Swarm 277
 25.4　使用其他服务发现后端 281
 25.5　Swarm中的调度器 282
 25.6　Swarm中的过滤器 284
 25.7　本章小结 286
 第26章　Mesos——优秀的集群资源调度平台 287
 26.1　简介 287
 26.2　Mesos安装与使用 288
 26.3　原理与架构 296
 26.3.1　架构 296
 26.3.2　基本单元 297
 26.3.3　调度 297
 26.3.4　高可用性 298
 26.4　Mesos配置项解析 299
 26.4.1　通用项 299
 26.4.2　master专属项 299
 26.4.3　slave专属项 301
 26.5　日志与监控 304
 26.6　常见应用框架 306
 26.7　本章小结 307
 第27章　Kubernetes——生产级容器集群平台 308
 27.1　简介 308
 27.2　核心概念 309
 27.2.1　集群组件 311
 27.2.2　资源抽象 312
 27.2.3　辅助概念 315
 27.3　快速体验 318
 27.4　安装部署 322
 27.5　重要组件 331
 27.5.1　Etcd 332
 27.5.2　kube-apiserver 332
 27.5.3　kube-scheduler 333
 27.5.4　kube-controller-manager 333
 27.5.5　kubelet 334
 27.5.6　kube-proxy 335
 27.6　使用kubectl 337
 27.6.1　获取kubectl 337
 27.6.2　命令格式 337
 27.6.3　全局参数 338
 27.6.4　子命令 339
 27.7　网络设计 351
 27.8　本章小结 353
 第28章　其他相关项目 354
 28.1　平台即服务方案 354
 28.1.1　Deis 354
 28.1.2　Flynn 355
 28.2　持续集成平台Drone 355
 28.3　容器管理 357
 28.3.1　Citadel 357
 28.3.2　Shipyard 358
 28.3.3　DockerUI 358
 28.3.4　Panamax 358
 28.3.5　Seagull 359
 28.3.6　Dockerboard 361
 28.4　编程开发 362
 28.5　网络支持 363
 28.5.1　pipework 363
 28.5.2　Flannel 364
 28.5.3　Weave Net 364
 28.5.4　Calico 365
 28.6　日志处理 366
 28.6.1　Docker-Fluentd 366
 28.6.2　Logspout 367
 28.6.3　Sematext-agent-docker 368
 28.7　服务代理工具 368
 28.7.1　Traefik 369
 28.7.2　Muguet 370
 28.7.3　nginx-proxy 370
 28.8　标准与规范 372
 28.9　其他项目 375
 28.9.1　CoreOS 375
 28.9.2　OpenStack支持 375
 28.9.3　dockerize 376
 28.9.4　Unikernel 378
 28.9.5　容器化的虚拟机 378
 28.10　本章小结 379
 附录
 附录A　常见问题总结 382
 附录B　Docker命令查询 388
 附录C　参考资源链接 393
 
 
下载地址......
 
 
好书推荐、视频分享，公众号读书ReadBook与您一起进步，回复关键字 41219直接获取下载链接
 
 
Python大礼包请回复 “python0426”即可获取
 

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到教程。
 
PS ：个人所有读书笔记只记录个人想要的内容，很可能原书大量内容没有纳入笔记中... ... 
 
以下全文内容出自书目：《 Docker 技术入门与实战 》
 
 
1. Docker 镜像：一个只读模板，是创建容器的基础 。
 
2. Docker 容器：从镜像创建运行的实例 ，可以看作是一个简易版本的 Linux 系统环境 。
 
3. Docker 仓库：集中存放镜像文件的场所 。
 
4. Docker 目前只能运行在 64 位平台上，并要求内核版本不低于 3.10 （可用 uname -a 或者 cat /proc/version 查看自己内核详情）。
 
5. Ubuntu 安装 Docker ：apt-get install -y docker-engine  ( 见书P12 ) 。
 
6. CentOS 安装 Docker :
 
 
7. docker 服务开启/重启方式：systemctl start docker.service   、 service docker restart  。
 
8. 查看 docker 版本信息：  docker version 。
 
9. 查看镜像 ： docker images 
 
    -a : 列出所有镜像。

    --digests=true|false :列出镜像数字摘要，默认为否。

    -f ,--filter=[] : 过滤列出镜像，如 dangling=true 只显示没有被使用的镜像 。

    --format="TEMPLATE"：控制输出格式，如 ID 代表 ID 信息， .Repository 代表仓库信息 。

    --no-trunc=true|false : 是否截断输出结果中太长的部分 。

    -q ，--quiet=true|false ： 仅输出 ID ，默认为否 。
 
--------------------------------------  以下更新于2018.7.9  --------------------------------------
 
10.  查看镜像创建过程： docker history  镜像名。
 
11.  删除镜像： docker rmi 镜像名、镜像ID（当镜像只剩下一个 tag 时会彻底删除镜像，命令 docker images 可查看镜像）。
 
12. 查看所有容器 ： docker ps -a 。
 
13. 镜像导出到本地文件：docker save -o xxx.tar 原镜像名。
 
14. 镜像导入： docker load <  镜像名 或 docker load --input  镜像名，如 docker load < xxx.tar 。
 
     ( A导出 + B导入 + run 可以把一个工程从服务器 A 拷贝到服务器 B 并部署运行，见第 20、21 点 。) 
 
15. 上传镜像到仓库 ：docker push ，默认是上传到 Docker Hub 官方仓库 。
 
16. 创建容器 ： docker  create 镜像名，参数如下：  （另一种创建方式见第 28 点。）
 
    -d：后台运行。

    -i：保持标准输入打开，默认为 false 。

    --net="bridge" ：指定容器网络模式 。

    --rm=true ：容器退出后自动删除 ( 不能和 -d 同时使用 )。

    -t： 分配一个伪终端，默认为 false 。

    -v | --volume=本机目录 : 容器目录 ： 挂载主机上文件卷到容器 。

    --volume-from=[ ]  ： 从其它容器挂载卷 。

    -w | --workdir=" "  ： 容器的默认工作目录 。 

    -e | --env=[ ] ：指定容器环境变量 。

    -h | --hostname=" "  ： 指定容器内的主机名 。 

    --link=[ < name or id >:alias ] ：链接到其它容器 。 

    --name=" " ：指定容器名 。 
 
17. 终止运行中的容器 ： docker stop 。
 
18. 进入容器以便可以执行任意命令： docker exec 容器名、id，如：docker exec -it 镜像id /bin/bash 。参数如下：
 
    --privileged=true ：给执行命令以最高权限，默认为 false 。

    -u | --user=" " ：执行命令的用户名或 ID 。

    -i : 开启标准输入 。 

    -t：分配伪终端，默认为 false 。
 
19 . 删除容器：docker rm ，参数如下：
 
    -f： 强行终止并删除运行中的容器 。

    -l | --link=false : 删除容器链接，但保留容器 。

    -v | --volumes=false ：删除容器挂载的数据卷 。
 
20. 导出容器：docker export  。    
 
-o 指定导出的 tar 文件，也可以直接重定向实现
 
    如： docker export -o test.tar 容器名、id  或 docker export 容器名、id > test.tar 。
 
21. 导入已导出的 tar 文件生成镜像：docker import 。   
 
 -c | --change=[ ] 导入时执行对容器进行修改的 Dockerfile 。
 
    如： docker import test.tar  -test/ubuntu:v1.o 。
 
22. docker load 和 docker impoer 区别： 
 
 load 命令导入镜像存储文件到镜像库，将保存完整记录，体积大。

 import 命令导入一个快照到本地镜像库，会丢弃所有历史记录和元数据信息。   
 
23. 搭建本地私有仓库：docker run -d -p 5000:5000 registry ，见书 P49 。
 
这会自动下载并启动一个 registry 容器，创建本地的私有仓库 。     
 
 -v ： 将镜像文件存放在本地指定路径，默认是将仓库创建在 /tmp/registry 目录下 。
 
如：docker run  -d  -p  5000:5000  -v  /opt/data/registry:tmp/registry  registry 则会将上传的镜像放到 /opt/data/registry 目录下 。
 
24. 数据卷是可供容器使用的特殊目录，它将主机操作目录直接映射进容器。
 
－v 可以在 docker run 运行的容器内创建一个数据卷。多次重复使用则创建多个数据卷。

- p 是将容器服务暴露的端口，是自动映射到本地主机的临时端口 。   
 
如：docker run -d -p --name web -v /webapp train python app.py 
 
用镜像 train  创建了容器 web ，并创建了一个数据卷挂载到容器的 /webapp 目录 。
 
－v 也可以指定挂载一个本地已有目录到容器中去作为数据卷 。
 
挂载数据卷的默认权限是 读写，可以用 ro 指定为只读，这样容器对所挂载数据卷内的内容就不能修改了 。 
 
如： docker run -d -p --name web -v /src/webapp : /opt/web : ro  train python app.py 
 
上面是加载主机的 /src/webapp 目录到容器的 /opt/web 目录 ，并且是只读 。
 
// 25. 利用数据卷容器来迁移数据见书 P55 。
 
26. 安装 ping ：apt-get install -yqq inetutils-ping 。
 
27. 通常 Dockerfile 分为四部分：基础镜像信息、维护者信息、镜像操作指令、容器启动时执行指令。
 
参数说明：
 
 
 
28. docker build 创建容器 ：docker build Dockerfile文件名  。
 
    -t：指定生成镜像的标签名，即 tag 。

    -f：若 Dockerfile 不在当前路径下，可使用 -f 来指定 Dockerfile 路径 。
 
如： docker build -t sshd:docker .    最后一个“.”表示使用当前路径下的 Dockerfile 文件 。
 
// 29. docker 安装和使用各个操作系统见书 P71 。
 
30. 安装 openssh-server : apt-get install openssh-server -y 。
 
31. 查看端口占用： netstat -tunlp 。
 
// 32. Docker Web 服务与应用（Apache、Nginx、Tomcat、Jetty、LAMP、CMS）见书 P83 。 
 
33. 安装运行 mysql ：( 使用官方镜像快速启动一个 mysql 服务实例 )
 
     docker run --name jy_mysql -e MYSQL_ROOT_PASSWORD=123 -d  mysql:latest 。
 
    执行完，mysql 就在 docker 中安装好了，可用 navicat 直接访问 。
 
    本地找不到的镜像会自动从Docker 仓库中下载最新版本。
 
    进入 mysql 容器： docker exec -it jy_mysql bash ，查看日志 ：docker logs jy_mysql 。
 
34. 安装运行 MongoDB： docker run --name mongoDB -d mongo 。
 
35. 安装运行 Redis：docker run --name redis -d redis 。
 
36. 安装运行  memcache : docker run --name memcache -d memcached 。
 
// 37. 搭建 cassandra 集群见书 P109 。
 
          Docker 快速部署 RabbitMQ、Celery、Hadoop、Spark、Elasticsearch 见书P112 。
 
 
 
--------------------------------------  以下更新于2018.7.28  --------------------------------------
 
 
 
38.   Docker Compose安装命令：sudo pip install -U docker-compose。
 
-f | --file ：指定 compose 模板文件，默认为 docker-compose.yml ,可多次指定。

-p | --projrct-name：指定项目名称，默认使用所在目录名称为项目名。

--x-networking ：使用 docker 可插拨网络后端特性。

--x-network-driver DRIVER ：指定网络后端驱动，默认为 brige。

-v | --version ：输出版本并退出。

--verbose ：输出更多调试信息。