Docker的优势：
Docker的度量：（在保证隔离性的同时达到节省资源的目的）
Docker容器使用AUFS作为文件系统的优势：
区别及总结：
- 表面区别：（容器与虚拟机的区别）
- 本质区别：Docker容器是被隔离的进程
Docker基本概念
docker基本指令
Dockerfile 镜像描述文件
- Dockerfile 基础命令
制作基准镜像(基于centos:lastest)FROM centos #不依赖任何基准镜像base image FROM scratch # 基于采用openjdk8 + tomcat 9.0.22 的镜像 FROM tomcat:9.0.22-jdk8-openjdk
尽量使用官方提供的Base Image
复制到/root ADD hello /root #添加根目录并解压 ADD test.tar.gz /
ADD 除了复制,还具备添加远程文件功能
将容器内部端口暴露给物理机 EXPOSE8080
docker run -p 8000:8080 tomcat
- Dockerfile 执行指令
示例： RUN[“yum”,”install”,”-y”,”vim”] #Exec命令格式

Docker是开源的基于轻量级虚拟化技术的容器引擎项目,整个项目基于Go语言开发，遵从Apache 2.0协议。通过分层镜像标准化和内核虚拟化技术，提供资源隔离的应用运行环境。
Docker 是一个开源工具，它让创建和管理 docker 容器变得简单。容器就像是轻量级的虚拟机，并且可以以秒级的速度来启动或停止。
版本：Docker-ce-20.10.10-3.el7*86_64

Docker的优势：

1、交付物标准化；（标准化交付物称为”镜像”，它包含了应用程序及其所依赖的运行环境，大大简化了应用交付的模式）
2、应用隔离；（隔离不同应用程序之间的相互影响，比虚拟机开销小，容器技术部署速度快，开发、测试更敏捷；提高系统利用率，降低资源成本）
3、一次构建，多次交付；（类似一个集装箱，多次运输）

Docker的度量：（在保证隔离性的同时达到节省资源的目的）

1、隔离性；（通过内核的命名空间将容器的进程、网络、消息、文件系统和主机名进行隔离）
2、可度量性；（主要通过cgroups控制组来控制资源的度量和分配）
3、可移植性；（利用AUFS来实现对容器的快速更新）
4、安全性；（容器之间的安全性通过命名空间和从groups来保证，容器与托管主机之间的安全性主要通过内核能力机制来控制）
注:（AUFS是支持将不同目录挂载到同一个虚拟文件系统下的文件系统，支持对每个目录的读写权限管理，AUFS具有层的概念，且都只在已有的只写层进行增量修改，修改的内容不影响原有的层且会形成新的文件层）

Docker容器使用AUFS作为文件系统的优势：

1、节省存储空间；（多个容器可以共用同一个基础镜像）
2、快速部署；
3、升级方便；（升级基础镜像即可影响到所有基于它的容器，且已经运行的Docker容器不受影响）

区别及总结：

表面区别：（容器与虚拟机的区别）

1、容器占用体积小，虚拟机占用体积大
2、隔离性：容器提供了基于进程的隔离，而虚拟机提供了资源的完全隔离。
3、启动速度：虚拟机可能需要一分钟来启动，而容器只需要一秒钟或更短。
4、容器使用宿主操作系统的内核，而虚拟机使用独立的内核。
5、Docker 的局限性之一是，它只能用在64位的操作系统上

本质区别：Docker容器是被隔离的进程

Docker优点：部署方便、部署安全、隔离性好、快速回滚、成本低、管理成本低；
Docker缺点：容器隔离性不完全性（ 容器之间共享同一个操作系统内核及其它组件 ，容易被通过底层操作系统影响到其他容器）、容器会将高并发的问题放大（高并发问题成为系统瓶颈时）、容器提供解决存储问题的方案会造成一部分资源的浪费（利用volumes接口（存储卷）形成数据映射和转移，以实现数据持久化）

Docker基本概念

Docker系统：分为两个程序，服务端和客户端；
Docker服务端：一个服务进程，管理所有容器（docker engine）；
Docker客户端：docker服务端的远程控制器，用来控制docker的服务端进程；

Docker三大核心组件

Docker仓库—Docker registery
Docker镜像—Docker images
Docker容器—Docker containers

镜像的三个组成部分

镜像名称：仓库名称/镜像分类+tag名称(镜像版本) 例如：daocloud.io/library/nginx
1.存储对象：images
2.格式：库名/分类：tag
3.tag:表示镜像版本

容器的三大组成要素

命名空间—namespace 容器隔离（pid，net，mnt，user，hostname..）
资源限制—cgroups 资源（内存，cpu）
文件系统—overlay2 （UnionFS）

docker基本指令

OAFJV2$]662L]W]GR6ZV8ZI.png

查询：

docker version 查看版本 (docker -v 查看简短信息)
docker info 查看系统信息
docker images 查看本地镜像 docker images -q 查看所有镜像的id
docker (image) inspect daocloud.io/library/nginx：aaa 查看镜像详情（镜像名称也可换成镜像的id号）
docker history daocloud.io/library/nginx 查看镜像制作过程（使用镜像名或者镜像ID都可以）
docker ps 查看当前正在运行的容器 docker ps -a 查看所有容器 docker ps -a -q 查看所有容器id
docker inspect +容器名称或者id 查看容器的配置信息，包含容器名、环境变量、运行命令、主机配置、网络配置和数据卷配置等
docker top 容器名字/id
docker stats 查看容器资源使用统计信息的实时流
docker logs -f -t —tail 10 abc 实时查看容器名为abc的最后10行日志

下载上传：

docker pull daocloud.io/library/nginx 下载nginx镜像
docker push daocloud.io/library/nginx：aaa 上传nginx镜像到自己的仓库里
docker login —username=youngfit registry.cn-shanghai.aliyuncs.com 登陆仓库

启动停止：

docker run -it daocloud.io/library/nginx /bin/bash 启动以nginx镜像为基础的容器，
-i：以交互模式运行容器 -t：分配一个终端或控制台 -d：后台运行
docker create -it daocloud.io/library/nginx /bin/bash 创建容器但不启动
—restart=always 容器随着docker engine的重启而启动，容器默认为关闭
—rm 在容器结束时会自动清理其所产生的数据
docker run -it —name 指定名字
daocloud.io/library/nginx /bin/bash 可指定容器名称也可以指定，会随机生成
docker start/stop/kill +容器名称/id 启动/关闭/强制关闭容器
docker kill $(docker ps -q) 删除所有容器
docker pause/unpause +容器名称/id 暂停容器/恢复容器
docker restart +容器名称/id 重启容器

修改删除：容器启动时无法删除

docker tag daocloud.io/library/nginx：aaa daocloud.io/library/nginx：bbb 将镜像的aaa标签换成bbb标签
docker rmi daocloud.io/library/nginx：aaa 删除镜像（镜像名称也可换成镜像的id号）
docker rmi daocloud.io/library/nginx：aaa —force 强制删除
docker rmi $(docker images -q) 通过镜像id删除所有镜像
docker rm +容器名称/id 删除容器
docker rm $(docker ps -qf status=exited) 删除所有容器 -f 过滤状态为exited的容器
docker rename abc 123 修改容器名称将abc修改成123

连接容器：容器必须为运行状态

docker attach 容器id（必须在创建时指定交互shell）
docker exec -it 容器id /bin/bash （/bin/sh）进入交互模式
docker exec 容器id touch /test 不进入交互模式直接创建
在容器内输入 exit 或者 ctrl+p+q 退出容器
注：docker attach 进入容器，再退出会导致容器停止；docker exec 进入容器，再退出不会导致容器停止，建议使用exec

宿主机与容器之间相互copy文件

docker cp 容器名：容器内的文件路径宿主机的存放位置
docker cp 宿主机文件路径容器名：容器内的存放路径

Dockerfile 镜像描述文件

Dockerfile是一个包含用于组合镜像的命令的文本文档 Docker通过读取Dockerfile中的指令按步自动生成镜像
docker build -t 机构/镜像名<:tags> Dockerfile目录

Dockerfile 基础命令

FROM - 基于基准镜像

制作基准镜像(基于centos:lastest)FROM centos #不依赖任何基准镜像base image FROM scratch # 基于采用openjdk8 + tomcat 9.0.22 的镜像 FROM tomcat:9.0.22-jdk8-openjdk
尽量使用官方提供的Base Image

LABEL & MAINTAINER - 说明信息

MAINTAINER SvenAugustus LABEL version =”1.0”LABEL description =”XXX”

WORKDIR/usr/local #自动创建 WORKDIR/usr/local/newdir
尽量使用绝对路径

ADD & COPY - 复制文件

复制到/root ADD hello /root #添加根目录并解压 ADD test.tar.gz /
ADD 除了复制,还具备添加远程文件功能

ENV- 设置环境常量

ENVJAVA_HOME/usr/local/openjdk8 RUN ${JAVA_HOME}/bin/java -jar test.jar
尽量使用环境常量,可提高程序维护性

EXPOSE - 暴露容器端口

将容器内部端口暴露给物理机 EXPOSE8080
docker run -p 8000:8080 tomcat

Dockerfile 执行指令

RUN & CMD & ENTRYPOINT
- RUN : 在Build构建时执行命令
- ENTRYPOINT : 容器启动时执行的命令
- CMD : 容器启动后执行默认的命令或参数
RUN-构建时运行 RUN yum install -y vim #Shell 命令格式

示例： RUN[“yum”,”install”,”-y”,”vim”] #Exec命令格式

ENTRYPOINT启动命令

ENTRYPOINT(入口点)用于在容器启动时执行命令
Dockerfile中只有最后一个ENTRYPOINT会被执行
# 示例： ENTRYPOINT[“ps”] #推荐使用Exec格式

CMD默认命令

CMD用于设置默认执行的命令，如果docker run 携带了参数，那么 CMD 设置的参数命令就会被忽略
如Dockerfile中出现多个CMD,则只有最后一个被执行
如容器启动时附加指令,则CMD被忽略
# 示例： CMD[“ps”,”-ef”] #推荐使用Exec格式

Docker容器镜像的制作

容器文件系统打包

注：将容器的文件系统打包成tar文件，就把正在运行的容器直接导出为tar包的镜像文件
docker export -o 名称.tar 容器id tar名称自定义最好跟容器内进程有关联
docker export 容器名称 > 镜像.tar
导入镜像
docker import 名称.tar 名称：tag 名称自定义要有关联

通过容器创建本地镜像

使用commit把一个运行的容器提交为一个镜像，类似告诉svn服务我要生成一个新的版本
docker commit 容器id 自定义镜像名：tag
docker commit -m “添加注释” -a “作者” 容器id 镜像名称：tag （-pause=true；-p 提交时暂停容器运行）

镜像迁移

save将镜像打包，load将save打包的镜像导入本地
docker save -o 名称.tar 镜像名称：tag 名称自定义要有关联
docker load < 名称.tar
批量打包镜像
docker save $(docker images | grep -v REPOSITORY | awk ‘BEGIN{OFS=”:”;ORS=” “}{print $1,$2}’) -o 名称.tar

Dockerfile创建镜像

根据给定的Dockerfile构建Docker镜像，先创建Dockerfile文件，然后在Dockerfile文件中写入指令
例如：（每个指令与命令之间都要有空格，如：RUN +空格+ cd /root）

#This is a comment  #注释，标注作用
FROM daocloud.io/library/centos:7  #基于的基础镜像，以及镜像的下载地址
MAINTAINER soso soso@docker-server  #描述，镜像的创建人
RUN touch a.txt
RUN mkdir /test
RUN yum -y install vim

Dockerfile写好后，使用**docker build**创建；例：docker build -t 镜像名字：tag . （**最后有**一个**点**，在Dockerfile存在的目录下操作），以上述镜像创建的容器里，会存在vim运用，根目录下也会存在a.txt文件和test目录。

Dockerfile实例；容器化python的flask应用

用 Docker 部署一个Python 编写的 Web 应用。
基础镜像（python）–>flask–>部署python应用
代码功能：
如果当前环境中有”NAME”这个环境变量，就把它打印在”Hello”后，否则就打印”Hello world”，最后再打印出当前环境的 hostname。

# vim app.py
from flask import Flask
import socket
import os

app = Flask(__name__)
@app.route('/')
def hello():
    html = "<h3>Hello {name}!</h3>" \
           "<b>Hostname:</b> {hostname}<br/>"
    return html.format(name=os.getenv("NAME", "world"), hostname=socket.gethostname())

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)

应用依赖：定义在同目录下的 requirements.txt 文件里 vim requirements.txt，内容为：Flask

FROM python:2.7-slim
# 使用官方提供的 Python 开发镜像作为基础镜像 
# 指定"python:2.7-slim"这个官方维护的基础镜像，从而免去安装 Python 等语言环境的操作。：

WORKDIR /app     ---cd /app
# 将工作目录切换为 /app,意思是在这一句之后，Dockerfile 后面的操作都以这一句指定的 /app 目录作为当前目录。 

ADD . /app
# 将当前目录下的所有内容复制到 /app 下 Dockerfile 里的原语并不都是指对容器内部的操作。比如 ADD，指的是把当前目录（即 Dockerfile 所在的目录）里的文件，复制到指定容器内的目录当中。

RUN pip install --trusted-host pypi.python.org -r requirements.txt
# 使用 pip 命令安装这个应用所需要的依赖

EXPOSE 80
# 允许外界访问容器的 80 端口

ENV NAME World
# 设置环境变量

CMD ["python", "app.py"]
# 设置容器进程为：python app.py，即：这个 Python 应用的启动命令,这里app.py 的实际路径是 /app/app.py。CMD ["python", "app.py"] 等价于 "docker run python app.py

构建镜像 docker build -t 标签镜像名称 . （构建成功时会有Successfully的回显）

CMD与ENTRYPOINT区别

一、Dockerfile中的CMD
1、每个Dockerfile中只能有一个CMD如果有多个那么只执行最后一个，
2、CMD 相当于启动docker时候后面添加的参数，
例：镜像名称后面跟了一个/bin/bash -c ，其实等价于在dockerfile中的CMD [“/bin/bash”,”-c”]
如果dockerfile中的CMD中有了CMD[“/bin/bash”,”-c”],就不用在执行的时候再次添加，如果添加了参数就相当于直接执行你添加的参数，默认的CMD中的参数就无效了
二、Dockerfile中的ENTRYPOINT
1、一个Dockerfile中ENTRYPOINT也只能存在一个，若存在多个那么只执行最后一个，你可以理解为开机启动的意思，和CMD有点像，不过还是有区别。
例：Dockerfile中有ENTRYPOINT [“tail”,”-f”,”/var/log/nginx/access.log”]，那么启动的时候镜像就执行了这个里面的内容，如果你在后面带参数的话就相当于在这个执行的内容后面再加入参数，就相当于我们启动docker的时候执行了：tail -f /var/log/nginx/access.log /bin/bash -c

Dockerfile优化

1、RUN命令要尽量写在一条里，每次RUN命令都是在之前的镜像上封装，只会增大不会减小
2、每次进行依赖安装后，记得yum clean all #清理缓存中的rpm头文件和包文件
3、尽可能选择比较箫的基础镜像、alpine

部署私有仓库应用

registry —官方出品，没有图形界面。Docker hub官方已提供容器镜像registry,用于搭建私有仓库
docker pull daocloud.io/library/registry:latest #拉取镜像
docker run -itd -v /home/dockerdata/registry:/var/lib/registry —name “pri_registry” —restart=always -p 5000:5000 daocloud.io/library/registry:latest
参数解释:
/home/dockerdata/registry表示为宿主机的目录，如果不存在自动创建
-v映射目录：宿主机的目录:容器目录
把宿主机的目录挂载到容器中，将数据目录挂载出来就是为了防止docker私有仓库这个容器被删除的时候，仓库里面的镜像也被删除。
-p 端口映射：本地端口:容器端口
docker exec -it 容器id /bin/sh 进入容器后查看5000端口是否开启，退出后 curl -I http://127.0.0.1:5000 看一下状态码
注：tag后面可以使用镜像名称也可以使用id,我这里使用的镜像名称，如果使用官方的镜像，不需要加前缀，但是daocloud.io的得加前缀.
修改请求方式为http；

默认为https，不改会报以下错误:
Get https://master.up.com:5000/v1/_ping: http: server gave HTTP response to HTTPS client
[root@docker-server ~]# vim /etc/docker/daemon.json    #不存在则创建
{ "insecure-registries":["仓库ip地址:5000"] }
systemctl restart docker

然后上传一个镜像，上传前必须给镜像打tag 注明ip和端口 docker tag daocloud.io/library/nginx 仓库ip地址:5000/nginx
上传镜像docker push 仓库ip地址:5000/nginx ls /home/dockerdata/registry/docker/registry/v2/repositories/ #宿主机查看存放镜像目录
查看私有仓库里的所有镜像：

语法： # curl  http://ip:port/v2/repo名字/tags/list
[root@docker-server ~]# curl http://192.168.246.141:5000/v2/busybox/tags/list
{"name":"busybox","tags":["latest"]}

[root@docker-server ~]# curl http://192.168.246.141:5000/v2/daocloud.io/library/mysql/tags/list
{"name":"daocloud.io/library/mysql","tags":["latest"]} 

这条命令会查看仓库下面所有的镜像：
[root@docker-server ~]# curl http://192.168.246.141:5000/v2/_catalog

部署docker web ui应用

下载并运行容器：
docker pull uifd/ui-for-docker
docker run -it -d —name docker-web -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock docker.io/uifd/ui-for-docker
然后用浏览器访问ip:9000

系统压力测试工具stress

stress是一个linux下的压力测试工具，专门为那些想要测试自己的系统，完全高负荷和监督这些设备运行的用户。

Docker资源限制

使用 docker 运行容器时，一台主机上可能会运行几百个容器，容器虽然互相隔离，底层却使用着相同的 CPU、内存和磁盘资源。如果不对容器使用的资源进行限制，容器之间会互相影响，小的来说会导致容器资源使用不公平；大的来说，可能会导致主机和集群资源耗尽，服务完全不可用。
CPU 和内存的资源限制已经是比较成熟和易用，能够满足大部分用户的需求。磁盘限制也是不错的，虽然现在无法动态地限制容量，但是限制磁盘读写速度也能应对很多场景。
资源限制一方面可以让我们为容器（应用）设置合理的 CPU、内存等资源，方便管理；另外一方面也能有效地预防恶意的攻击和异常，对容器来说是非常重要的功能。

cpu资源限制

限制CPU Share
docker允许用户为每个容器设置一个数字，代表容器的 CPU share，默认情况下每个容器的 share 是 1024。这个 share 是相对的，本身并不能代表任何确定的意义。当主机上有多个容器运行时，每个容器占用的 CPU 时间比例为它的 share 在总额中的比例。docker 会根据主机上运行的容器和进程动态调整每个容器使用 CPU 的时间比例。
例：如果主机上有两个一直使用 CPU 的容器（为了简化理解，不考虑主机上其他进程），其 CPU share 都是 1024，那么两个容器 CPU 使用率都是 50%；如果把其中一个容器的 share 设置为 512，那么两者 CPU 的使用率分别为 70% 和 30%；如果删除 share 为 1024 的容器，剩下来容器的 CPU 使用率将会是 100%。
优点：能保证 CPU 尽可能处于运行状态，充分利用 CPU 资源，而且保证所有容器的相对公平；
缺点：无法指定容器使用 CPU 的确定值。
设置 CPU share 的参数： -c —cpu-shares，它的值是一个整数
4 核 CPU，运行一个stress容器,使用 stress 启动 4 个进程来产生计算压力：（无CPU限制）
docker run —rm -it -c 512 progrium/stress —cpu 4 （-c后面指定share为512、—cpu后面指定使用宿主机器的总核数为4）
限制CPU 核数
-c —cpu-shares 参数只能限制容器使用 CPU 的比例，或者说优先级，无法确定地限制容器使用 CPU 的具体核数；从 1.13 版本之后，docker 提供了 —cpus 参数可以限定容器能使用的 CPU 核数。这个功能可以让我们更精确地设置容器 CPU 使用量，是一种更容易理解也因此更常用的手段
—cpus 后面跟着一个浮点数，代表容器最多使用的核数，可以精确到小数点二位，也就是说容器最小可以使用 0.01 核 CPU
docker run —rm -it —cpus 1.5 progrium/stress —cpu 3 （—cpus 1.5意思每个 stress 进程 CPU 使用率大约在 50%，总共的使用率为 150%，符合 1.5 核的设置）
CPU绑定
限制容器运行在某些 CPU 核，一般不在生产中这样使用，docker允许调度的时候限定容器运行在哪个CPU上
docker run —rm -it —cpuset-cpus=0,1 progrium/stress —cpu 2 （这样可以设置docker容器只会使用前面两个核，且 CPU 达到了 100% 使用率）

mem资源限制

docker 默认没有对容器内存进行限制，容器可以使用主机提供的所有内存
不限制内存带来的问题：
这是非常危险的事情，如果某个容器运行了恶意的内存消耗软件，或者代码有内存泄露，很可能会导致主机内存耗尽，因此导致服务不可用。
可以为每个容器设置内存使用的上限，一旦超过这个上限，容器会被杀死，而不是耗尽主机的内存。
限制内存带来的问题：
限制内存上限虽然能保护主机，但是也可能会伤害到容器里的服务。如果为服务设置的内存上限太小，会导致服务还在正常工作的时候就被 OOM 杀死；如果设置的过大，会因为调度器算法浪费内存。
合理做法：
1. 为应用做内存压力测试，理解正常业务需求下使用的内存情况，然后才能进入生产环境使用
2. 一定要限制容器的内存使用上限，尽量保证主机的资源充足，一旦通过监控发现资源不足，就进行扩容或者对容器进行迁移
3. 尽量不要使用 swap，swap 的使用会导致内存计算复杂，对调度器非常不友好
docker 限制容器内存使用量
docker 启动参数中，和内存限制有关的包括（参数的值一般是内存大小，也就是一个正数，后面跟着内存单位 b、k、m、g，分别对应 bytes、KB、MB、和 GB)
-m —memory：容器能使用的最大内存大小，最小值为 4m
docker run —rm -it -m 64m progrium/stress —vm 1 —vm-bytes 64M —vm-hang 0
-m 64m：限制你这个容器只能使用64M
—vm-bytes 64M：将内存撑到64兆是不会报错，有64兆内存可用
hang:就是卡在这里。
—vm：生成几个占用内存的进程

io 资源限制(了解)

对于磁盘来说，考量的参数是容量和读写速度，因此对容器的磁盘限制也应该从这两个维度出发。目前 docker 支持对磁盘的读写速度进行限制，但是并没有方法能限制容器能使用的磁盘容量（一旦磁盘 mount 到容器里，容器就能够使用磁盘的所有容量）
第一种是：磁盘的读写速率的限制
第二种是：磁盘的读写频率的限制

端口转发

使用端口转发解决容器端口访问问题
-p:创建应用容器的时候，一般会做端口映射，这样是为了让外部能够访问这些容器里的应用。可以用多个-p指定多个端口映射关系
运行容器：使用-p作端口转发，把本地3307转发到容器的3306，其他参数需要查看发布容器的页面提示
docker run -d —name mysql1 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=abc@123! daocloud.io/library/mysql:5.7
-e MYSQL_ROOT_PASSWORD= 设置环境变量，这里是设置mysql的root用户的密码
-P（大P）:当使用-P标记时，Docker 会随机映射一个 32768~49900 的端口到内部容器开放的网络端口
例：docker run —name myredis -P -d daocloud.io/library/redis
然后通过docker ps查看映射的端口

Docker持久化/容器卷

把本地宿主机上面的某一个目录挂载到容器里面的目录去。这两个目录都不用提前存在，会自动创建
新卷只能在容器创建过程当中挂载 （-v 将宿主机目录/文件映射到容器内的目录/文件中，注：当宿主机映射的目录/文件中没有内容时，容器内映射的目录/文件也没有内容）
共享目录：docker run -it —name testnginx -v /test:/test2 daocloud.io/library/nginx /bin/bash
共享文件：docker run -it —name testnginx1 -v /dir/a.txt:/dir1/a.txt daocloud.io/library/nginx /bin/bash
共享其他容器的卷（其他容器用同一个卷）：docker run -it —name testnginx2 —volumes-from testnginx daocloud.io/library/nginx /bin/bash
实际应用中可以利用多个-v选项把宿主机上的多个目录同时共享给新建容器：docker run -it -v /abc:/abc -v /def:/def daocloud.io/library/nginx /bin/bash
systemd 整合:因为 systemd 要求 CAPSYSADMIN 权限，从而得到了读取到宿主机 cgroup 的能力，CentOS7 中已经用 fakesystemd 代替了 systemd
为了运行一个包含 systemd 的容器，需要使用—privileged选项，并且挂载主机的 cgroups 文件夹
docker run —privileged -tid -v /sys/fs/cgroup:/sys/fs/cgroup:ro -p 80:80 local/c7-systemd-httpd
—privileged:授权提权。让容器内的root用户拥有真正root权限(有些权限是没有的)
注：如果不加会运行在前台(没有用-d)，可以用ctrl+p+q放到后台去

Docker数据存储位置

查看存储路径：

docker info | grep Root
回显为：Docker Root Dir: /var/lib/docker

修改默认存储位置：

在dockerd的启动命令后面追加—data-root参数指定新的位置
vim /usr/lib/systemd/system/docker.service
ExecStart=/usr/bin/dockerd -H fd:// —containerd=/run/containerd/containerd.sock —data-root=/data
systemctl daemon-reload && systemctl restart docker

Docker网络

容器网络分类

查看当前网络：docker network list
docker安装后，默认会创建3种网络类型，bridge、host和none
1、bridge:网络桥接：默认情况下启动、创建容器都是用该模式，所以每次docker容器重启时会按照顺序获取对应ip地址
2、none：无指定网络：启动容器时，可以通过—network=none,docker容器不会分配局域网ip
3、host：主机网络：docker容器和主机共用一个ip地址
使用host网络创建容器：docker run -it —name testnginx —net host 98ebf73ab
4、固定ip：
创建固定Ip的容器：
1.创建自定义网络类型，并且指定网段
docker network create —subnet=192.168.0.0/16 staticnet
通过 docker network ls 可以查看到网络类型中多了一个staticnet
2.使用新的网络类型创建并启动容器
docker run -itd —name server —net staticnet —ip 192.168.0.2 daocloud.io/library/centos:7
通过 docker inspect 可以查看容器ip为192.168.0.2
docker inspect userserver | grep -i ipaddress
关闭容器并重启，发现容器ip并未发生改变
3.删除已创建网络：需要删除使用当前网络的容器。才能删除网络
docker network rm staticnet

异主容器互联

方式1、路由方式

Docker默认的内部ip为172.17.42.0网段，所以必须要修改其中一台的默认网段以免ip冲突

注:docker版本为1.13
1.在docker-server1上面操作----192.168.246.141
[root@docker-server1 ~]# docker pull daocloud.io/library/centos
[root@docker-server1 ~]# vim /etc/sysconfig/docker-network
DOCKER_NETWORK_OPTIONS=--bip=172.17.0.1/16
[root@docker-server1 ~]# vim /etc/sysctl.conf
net.ipv4.ip_forward=1
[root@docker-server1 ~]# sysctl -p
[root@docker-server1 ~]# reboot
[root@docker-server1 ~]# docker images
REPOSITORY                   TAG                 IMAGE ID            CREATED             SIZE
daocloud.io/library/centos   latest              0f3e07c0138f        3 weeks ago         220MB
[root@docker-server1 ~]# docker run -it --name centos daocloud.io/library/centos:latest /bin/bash
[root@ef1a4d6be97f /]#
[root@docker-server1 ~]# docker inspect centos | grep IPAddress
            "SecondaryIPAddresses": null,
            "IPAddress": "172.17.0.2",
                    "IPAddress": "172.17.0.2",
===============================================
2.docker-server2(192.168.246.143)上：
[root@docker-server2 ~]# vim /etc/sysconfig/docker-network
DOCKER_NETWORK_OPTIONS=--bip=172.18.0.1/16
[root@docker-server2 ~]# vim /etc/sysctl.conf
net.ipv4.ip_forward = 1
[root@docker-server2 ~]# sysctl -p
[root@docker-server2 ~]# reboot
[root@docker-server2 ~]# systemctl daemon-reload
[root@docker-server2 ~]# systemctl restart docker
[root@docker-server2 ~]# docker images
REPOSITORY                   TAG                 IMAGE ID            CREATED             SIZE
daocloud.io/library/centos   latest              0f3e07c0138f        3 weeks ago         220MB
[root@docker-server2 ~]# docker run -it --name centos daocloud.io/library/centos:latest /bin/bash 
[root@c84a8c704d03 /]#
[root@docker-server2 ~]# docker inspect centos| grep IPAddress
            "SecondaryIPAddresses": null,
            "IPAddress": "172.18.0.2",
                    "IPAddress": "172.18.0.2",
#添加路由：
[root@docker-server1 ~]# route add -net 172.18.0.0/16 gw 192.168.246.143
[root@docker-server2 ~]# route add -net 172.17.0.0/16 gw 192.168.246.141

方式2、open vswitch

如果要在生产和测试环境大规模采用docker技术，首先就需要解决不同物理机建的docker容器互联问题。
centos7环境下可以采用open vswitch实现不同物理服务器上的docker容器互联

Docker