docker学习

一、介绍

1、简介

Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的 Go 语言实现。 项目后来加入了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在 GitHub 上进行维护。

Docker 项目的目标是实现轻量级的操作系统虚拟化解决方案。 Docker 的基础是 Linux 容器（LXC）等技术。

在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的容器就像操作一个快速轻量级的虚拟机一样简单。

2、变迁

 上述图片比较了 Docker 和传统虚拟化方式的不同之处，可见容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统方式则是在硬件层面实现。

3、特点

更快速的交付和部署
对开发和运维（devop）人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。

开发者可以使用一个标准的镜像来构建一套开发容器，开发完成之后，运维人员可以直接使用这个容器来部署代码。 Docker 可以快速创建容器，快速迭代应用程序，并让整个过程全程可见，使团队中的其他成员更容易理解应用程序是如何创建和工作的。 Docker 容器很轻很快！容器的启动时间是秒级的，大量地节约开发、测试、部署的时间。

更高效的虚拟化
Docker 容器的运行不需要额外的 hypervisor 支持，它是内核级的虚拟化，因此可以实现更高的性能和效率。

更轻松的迁移和扩展
Docker 容器几乎可以在任意的平台上运行，包括物理机、虚拟机、公有云、私有云、个人电脑、服务器等。 这种兼容性可以让用户把一个应用程序从一个平台直接迁移到另外一个。

更简单的管理
使用 Docker，只需要小小的修改，就可以替代以往大量的更新工作。所有的修改都以增量的方式被分发和更新，从而实现自动化并且高效的管理。

二、架构

Docker 包括三个基本概念

• 镜像（Image）
• 容器（Container）
• 仓库（Repository）

理解了这三个概念，就理解了 Docker 的整个生命周期

1、 镜像（Image）——一个特殊的文件系统

操作系统分为内核和用户空间。对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持。而Docker 镜像（Image），就相当于是一个 root 文件系统。

Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。 镜像不包含任何动态数据，其内容在构建之后也不会被改变。

Docker 设计时，就充分利用 Union FS的技术，将其设计为 分层存储的架构 。 镜像实际是由多层文件系统联合组成。

镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。　比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。

分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。

2 、容器（Container)——镜像运行时的实体

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类 和 实例 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等 。

容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 命名空间。前面讲过镜像使用的是分层存储，容器也是如此。

容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。

按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据 ，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷（Volume）、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主(或网络存储)发生读写，其性能和稳定性更高。数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此， 使用数据卷后，容器可以随意删除、重新 run ，数据却不会丢失。

3 、仓库（Repository）——集中存放镜像文件的地方

镜像构建完成后，可以很容易的在当前宿主上运行，但是， 如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry就是这样的服务。

一个 Docker Registry中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。所以说：镜像仓库是Docker用来集中存放镜像文件的地方类似于我们之前常用的代码仓库。

通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本 。我们可以通过<仓库名>:<标签>的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签。

这里补充一下Docker Registry 公开服务和私有 Docker Registry的概念：

Docker Registry 公开服务 是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像。

最常使用的 Registry 公开服务是官方的 Docker Hub ，这也是默认的 Registry，并拥有大量的高质量的官方镜像，网址为：https://hub.docker.com/ 。在国内访问Docker Hub 可能会比较慢国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 时速云镜像库、网易云镜像服务、DaoCloud 镜像市场、阿里云镜像库等。

除了使用公开服务外，用户还可以在 本地搭建私有 Docker Registry 。Docker 官方提供了 Docker Registry 镜像，可以直接使用做为私有 Registry 服务。开源的 Docker Registry 镜像只提供了 Docker Registry API 的服务端实现，足以支持 docker 命令，不影响使用。但不包含图形界面，以及镜像维护、用户管理、访问控制等高级功能。

三、部署

1、安装

（1）docker-ce旧版本卸载

#列出docker安装过的相关包
yum list installed | grep docker
 
#删除相关安装包
yum -y remove docker-ce

（2）安装指定版本docker

#安装所需工具和配置
yum install -y yum-utils
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#查看版本
yum list docker-ce --showduplicates|sort -r

#安装指定版本
yum -y install docker-ce-18.06.1.ce-3.el7

#同时启动并设置开机自启
systemctl enable docker && sudo systemctl start docker

#最后，测试一下
docker --version

2、镜像

Docker 镜像是怎么实现增量的修改和维护的？ 每个镜像都由很多层次构成，Docker 使用 Union FS 将这些不同的层结合到一个镜像中去。

通常 Union FS 有两个用途, 一方面可以实现不借助 LVM、RAID 将多个 disk 挂到同一个目录下,另一个更常用的就是将一个只读的分支和一个可写的分支联合在一起，Live CD 正是基于此方法可以允许在镜像不变的基础上允许用户在其上进行一些写操作。 Docker 在 AUFS 上构建的容器也是利用了类似的原理。

（1）镜像基础运用

#获取镜像
docker pull 镜像名
#查看镜像
docker images
docker inspect 镜像名
#删除镜像
docker rmi 镜像名或者镜像id

（2）镜像制作

　　•　利用 docker commit 来创建镜像

$ sudo docker commit -m "Added json gem" -a "Docker Newbee" 0b2616b0e5a8 ouruser/sinatra:v2 4f177bd27a9ff0f6dc2a830403925b5360bfe0b93d476f7fc3231110e7f71b1c

其中，-m 来指定提交的说明信息，跟我们使用的版本控制工具一样；-a 可以指定更新的用户信息；之后是用来创建镜像的容器的 ID；最后指定目标镜像的仓库名和 tag 信息。创建成功后会返回这个镜像的 ID 信息。

　　•　利用 Dockerfile 来创建镜像

使用 docker commit 来扩展一个镜像比较简单，但是不方便在一个团队中分享。我们可以使用 docker build 来创建一个新的镜像。为此，首先需要创建一个 Dockerfile，包含一些如何创建镜像的指令。

#新建一个目录和一个 Dockerfile
$ mkdir sinatra
$ cd sinatra
$ touch Dockerfile

#Dockerfile 中每一条指令都创建镜像的一层，例如：
# This is a comment
FROM ubuntu:14.04
MAINTAINER Docker Newbee <newbee@docker.com>
RUN apt-get -qq update
RUN apt-get -qqy install ruby ruby-dev
RUN gem install sinatra

Dockerfile 基本的语法是：

　　使用#来注释
　　FROM 指令告诉 Docker 使用哪个镜像作为基础
　　接着是维护者的信息
　　RUN开头的指令会在创建中运行，比如安装一个软件包，在这里使用 apt-get 来安装了一些软件
编写完成 Dockerfile 后可以使用 docker build 来生成镜像。

#开始制作
$ sudo docker build -t="ouruser/sinatra:v2" .

其中 -t 标记来添加 tag，指定新的镜像的用户信息。 “.” 是 Dockerfile 所在的路径（当前目录），也可以替换为一个具体的 Dockerfile 的路径。

可以看到 build 进程在执行操作。它要做的第一件事情就是上传这个 Dockerfile 内容，因为所有的操作都要依据 Dockerfile 来进行。 然后，Dockfile 中的指令被一条一条的执行。每一步都创建了一个新的容器，在容器中执行指令并提交修改（就跟之前介绍过的 docker commit 一样）。当所有的指令都执行完毕之后，返回了最终的镜像 id。所有的中间步骤所产生的容器都被删除和清理了。

*注意一个镜像不能超过 127 层

此外，还可以利用 ADD 命令复制本地文件到镜像；用 EXPOSE 命令来向外部开放端口；用 CMD 命令来描述容器启动后运行的程序等。例如:

# put my local web site in myApp folder to /var/www
ADD myApp /var/www
# expose httpd port
EXPOSE 80
# the command to run
CMD ["/usr/sbin/apachectl", "-D", "FOREGROUND"]

#现在可以利用新创建的镜像来启动一个容器。
$ sudo docker run -t -i ouruser/sinatra:v2 /bin/bash
root@8196968dac35:/#

#还可以用 docker tag 命令来修改镜像的标签。
$ sudo docker tag 5db5f8471261 ouruser/sinatra:devel
$ sudo docker images ouruser/sinatra
REPOSITORY          TAG     IMAGE ID      CREATED        VIRTUAL SIZE
ouruser/sinatra     latest  5db5f8471261  11 hours ago   446.7 MB
ouruser/sinatra     devel   5db5f8471261  11 hours ago   446.7 MB
ouruser/sinatra     v2      5db5f8471261  11 hours ago   446.7 MB

[root@localhost ~]# mkdir mkimage
[root@localhost mkimage]# cd mkimage
[root@localhost mkimage]# vim Dockerfile
#####this is a comment
FROM centos
MAINTAINER test1
RUN ["/bin/bash","-c","tail -f /dev/null &"]
[root@localhost ~]# docker build -t="test" mkimage/

（3）镜像存出、载入与上传

　　•　载入镜像

#比如，先下载了一个 ubuntu-14.04 的镜像，之后使用以下命令导入：
sudo cat ubuntu-14.04-x86_64-minimal.tar.gz  |docker import - ubuntu:14.04

　#可以使用 docker load 从导出的本地文件中再导入到本地镜像库，例如

  $ sudo docker load --input ubuntu_14.04.tar

  #或者

  $ sudo docker load < ubuntu_14.04.tar
  #这将导入镜像以及其相关的元数据信息（包括标签等）。

　　•　存出镜像

#如果要导出镜像到本地文件，可以使用 docker save 命令。
$ sudo docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu              14.04               c4ff7513909d        5 weeks ago         225.4 MB
...
$sudo docker save -o ubuntu_14.04.tar ubuntu:14.04

　　•　上传镜像

#用户可以通过 docker push 命令，把自己创建的镜像上传到仓库中来共享。例如，用户在 Docker Hub 上完成注册后，可以推送自己的镜像到仓库中。
$ sudo docker push ouruser/sinatra

3、容器

（1）容器基础运用

#例如，下面的命令输出一个 “Hello World”，之后终止容器。
$ sudo docker run ubuntu:14.04 /bin/echo 'Hello world'
Hello world

#下面的命令则启动一个 bash 终端，允许用户进行交互。
$ sudo docker run -t -i ubuntu:14.04 /bin/bash
root@af8bae53bdd3:/#
#其中，-t 选项让Docker分配一个伪终端（pseudo-tty）并绑定到容器的标准输入上， -i 则让容器的标准输入保持打开。

#删除容器
docker rm 容器名或者容器id

#可以利用 docker start 命令，直接将一个已经终止的容器启动运行。
docker start 容器名或者容器id

#可以利用 docker stop命令，直接将一个已经启动的容器终止运行。
docker stop 容器名或者容器id

#可以利用 docker restart命令，直接将一个容器重新运行。
docker restart 容器名或者容器id

#查看容器 docker ps或者docker ps -a

#要获取容器的输出信息，可以通过 docker logs 命令。 $ sudo docker logs 容器名或者容器id

（2）容器进入

在使用 -d 参数时，容器启动后会进入后台。 某些时候需要进入容器进行操作，有很多种方法，包括使用 docker attach 命令或 nsenter 工具等。

　　• 　attach 命令

　　docker attach 容器名或者容器id

　　•　exec命令

　　docker exec 容器名或者容器id

　　• 　nsenter 命令

（3）容器载入和导出

#如果要导出本地某个容器，可以使用 docker export 命令。
$ sudo docker export 7691a814370e > ubuntu.tar

#可以使用 docker import 从容器快照文件中再导入为镜像
$ cat ubuntu.tar | sudo docker import - test/ubuntu:v1.0

#此外，也可以通过指定 URL 或者某个目录来导入，例如
$sudo docker import http://example.com/exampleimage.tgz example/imagerepo

*注：用户既可以使用 docker load 来导入镜像存储文件到本地镜像库，也可以使用 docker import 来导入一个容器快照到本地镜像库。这两者的区别在于容器快照文件将丢弃所有的历史记录和元数据信息（即仅保存容器当时的快照状态），而镜像存储文件将保存完整记录，体积也要大。此外，从容器快照文件导入时可以重新指定标签等元数据信息。

4、库

（1）Docker Hub

仓库（Repository）是集中存放镜像的地方。

一个容易混淆的概念是注册服务器（Registry）。实际上注册服务器是管理仓库的具体服务器，每个服务器上可以有多个仓库，而每个仓库下面有多个镜像。从这方面来说，仓库可以被认为是一个具体的项目或目录。例如对于仓库地址 dl.dockerpool.com/ubuntu 来说，dl.dockerpool.com 是注册服务器地址，ubuntu 是仓库名。

大部分时候，并不需要严格区分这两者的概念。

目前 Docker 官方维护了一个公共仓库 Docker Hub，其中已经包括了超过 15,000 的镜像。大部分需求，都可以通过在 Docker Hub 中直接下载镜像来实现。

　　•　登录

可以通过执行 docker login 命令来输入用户名、密码和邮箱来完成注册和登录。 注册成功后，本地用户目录的 .dockercfg 中将保存用户的认证信息。

　　•　基本操作

用户无需登录即可通过 docker search 命令来查找官方仓库中的镜像，并利用 docker pull 命令来将它下载到本地。

（2）私有仓库

（3）配置文件

Docker 的 Registry 利用配置文件提供了一些仓库的模板（flavor），用户可以直接使用它们来进行开发或生产部署。

　　•　模板

在 config_sample.yml 文件中，可以看到一些现成的模板段：

• common：基础配置
• local：存储数据到本地文件系统
• s3：存储数据到 AWS S3 中
• dev：使用 local 模板的基本配置
• test：单元测试使用
• prod：生产环境配置（基本上跟s3配置类似）
• gcs：存储数据到 Google 的云存储
• swift：存储数据到 OpenStack Swift 服务
• glance：存储数据到 OpenStack Glance 服务，本地文件系统为后备
• glance-swift：存储数据到 OpenStack Glance 服务，Swift 为后备
• elliptics：存储数据到 Elliptics key/value 存储

用户也可以添加自定义的模版段。

默认情况下使用的模板是 dev，要使用某个模板作为默认值，可以添加 SETTINGS_FLAVOR 到环境变量中，例如：

export SETTINGS_FLAVOR=dev

另外，配置文件中支持从环境变量中加载值，语法格式为 _env:VARIABLENAME[:DEFAULT]。

四、数据管理

卷(Volume)是容器中的一个数据挂载点，卷可以绕过联合文件系统，从而为Docker 提供持久数据，所提供的数据还可以在宿主机-容器或多个容器之间共享。通过卷，我们可以可以使修改数据直接生效，而不必重新构建镜像。

1、数据卷

数据卷是一个可以绕过联合文件系统的，专门指定的可在一或多个容器间共享目录。卷为提供为持久化或共享数据提供了一些有用的特性。
数据卷设计的初哀是提供持久化数据，而与容器的生命周期无关。因此，在删除容器时，Docker不会自动删除卷，直到没有容器再引用。

（1）添加数据卷

可以在docker run命令创建容器时，通过-v参数为容器添加数据卷。-v参数参数可以多次使用，以添加多个数据卷。
下面创建一个 web 容器，并加载一个数据卷到容器的 /webapp 目录。
　　$ sudo docker run -d -P --name web -v /webapp training/webapp python app.py
注意：也可以在 Dockerfile 中使用 VOLUME 来添加一个或者多个新的卷到由该镜像创建的任意容器。

（2）挂载本地数据到容器数据卷

使用 -v 标记也可以指定挂载一个本地主机的目录到容器中去。
　　$ sudo docker run -d -P --name web -v /src/webapp:/opt/webapp training/webapp python app.py
上面的命令加载主机的 /src/webapp 目录到容器的 /opt/webapp 目录。这个功能在进行测试的时候十分方便，比如用户可以放置一些程序到本地目录中，来查看容器是否正常工作。本地目录的路径必须是绝对路径，如果目录不存在 Docker 会自动为你创建它。
注意：Dockerfile 中不支持这种用法，这是因为 Dockerfile 是为了移植和分享用的。然而，不同操作系统的路径格式不一样，所以目前还不能支持。
Docker 挂载数据卷的默认权限是读写，用户也可以通过 :ro 指定为只读。
　　$ sudo docker run -d -P --name web -v /src/webapp:/opt/webapp:ro training/webapp python app.py

（3）挂载一个本地主机文件作为数据卷

-v 标记也可以从主机挂载单个文件到容器中
　　$ sudo docker run --rm -it -v ~/.bash_history:/.bash_history ubuntu /bin/bash
这样就可以记录在容器输入过的命令了。
注意：如果直接挂载一个文件，很多文件编辑工具，包括 vi 或者 sed --in-place，可能会造成文件 inode 的改变，从 Docker 1.1 .0起，这会导致报错误信息。所以最简单的办法就直接挂载文件的父目录。

2、数据卷容器

如果你有一些持续更新的数据需要在容器之间共享，最好创建数据卷容器。
数据卷容器，其实就是一个正常的容器，专门用来提供数据卷供其它容器挂载的。
首先，创建一个命名的数据卷容器 dbdata：
　　$ sudo docker run -d -v /dbdata --name dbdata training/postgres echo Data-only container for postgres
然后，在其他容器中使用 --volumes-from 来挂载 dbdata 容器中的数据卷。
　　$ sudo docker run -d --volumes-from dbdata --name db1 training/postgres
　　$ sudo docker run -d --volumes-from dbdata --name db2 training/postgres
还可以使用多个 --volumes-from 参数来从多个容器挂载多个数据卷。 也可以从其他已经挂载了数据卷的容器来挂载数据卷。
　　$ sudo docker run -d --name db3 --volumes-from db1 training/postgres
注意：使用 --volumes-from 参数所挂载数据卷的容器自己并不需要保持在运行状态。
如果删除了挂载的容器（包括 dbdata、db1 和 db2），数据卷并不会被自动删除。如果要删除一个数据卷，必须在删除最后一个还挂载着它的容器时使用 docker rm -v 命令来指定同时删除关联的容器。 这可以让用户在容器之间升级和移动数据卷。

3、备份、恢复与迁移数据卷

可以利用数据卷对其中的数据进行进行备份、恢复和迁移。

（1）备份数据卷

首先使用 --volumes-from 标记来创建一个加载 dbdata 容器卷的容器，并从本地主机挂载当前到容器的 /backup 目录。命令如下：
　　$ sudo docker run --volumes-from dbdata -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /dbdata
容器启动后，使用了 tar 命令来将 dbdata 卷备份为本地的 /backup/backup.tar。

（2）恢复数据卷

如果要恢复数据到一个容器，首先创建一个带有数据卷的容器 dbdata2。
　　$ sudo docker run -v /dbdata --name dbdata2 ubuntu /bin/bash
然后创建另一个容器，挂载 dbdata2 的容器，并使用 untar 解压备份文件到挂载的容器卷中。
　　$ sudo docker run --volumes-from dbdata2 -v $(pwd):/backup busybox tar xvf /backup/backup.tar

五、容器网络

我们在使用docker run创建Docker容器时，可以用--net选项指定容器的网络模式，Docker有以下4种网络模式：

•  host模式，使用--net=host指定。

容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口。

• container模式，使用--net=container:NAME_or_ID指定。

创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围。

•  none模式，使用--net=none指定。

该模式关闭了容器的网络功能。

• bridge模式，使用--net=bridge指定，默认设置。

此模式会为每一个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥，通过docker0网桥以及Iptables nat表配置与宿主机通信。

注意：使用docker network ls命令列出这些docker内置的网络模式。

1、host模式

众所周知，Docker使用了Linux的Namespaces技术来进行资源隔离，如PID Namespace隔离进程，Mount Namespace隔离文件系统，Network Namespace隔离网络等。一个Network Namespace提供了一份独立的网络环境，包括网卡、路由、Iptable规则等都与其他的Network Namespace隔离。一个Docker容器一般会分配一个独立的Network Namespace。但如果启动容器的时候使用host模式，那么这个容器将不会获得一个独立的Network Namespace，而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口。

例如，我们在10.10.101.105/24的机器上用host模式启动一个含有web应用的Docker容器，监听tcp80端口。

当我们在容器中执行任何类似ifconfig命令查看网络环境时，看到的都是宿主机上的信息。而外界访问容器中的应用，则直接使用10.10.101.105:80即可，不用任何NAT转换，就如直接跑在宿主机中一样。但是，容器的其他方面，如文件系统、进程列表等还是和宿主机隔离的。

2、container模式

在理解了host模式后，这个模式也就好理解了。这个模式指定新创建的容器和已经存在的一个容器共享一个Network Namespace，而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等，容器彼此之间也可以通信，效果如同一个主机上的两个进程。。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。两个容器的进程可以通过lo网卡设备通信。

联盟式容器是指使用某个已存在容器的网络接口的容器，接口被联盟内的各容器共享使用；因此，联盟式容器彼此间完全隔离，例如：
　　联盟式容器彼此虽然共享同一个网络名称空间，但其它名称空间如User、Mount等还是隔离的。
　　联盟式容器彼此间存在端口冲突的可能性，因此，通常只会在多个容器上的程序需要程序loopback接口互相通信，或对已存的容器的网络属性进行监控时才使用此模式的网络模型。

3、none模式

此模式下容器不参与网络通信，运行于此类容器中的进程仅能访问本地环回接口，仅适用于进程无须网络通信的场景中，例如备份，进程诊断及各种离线任务等。

--network none:设置模式容器工作在none模式下。
在此模式下使用ifconfig -a 显示只有lo网卡。

4、Bridge模式（默认网络模式）

桥接式容器一般拥有两个接口：一个环回接口和一个连接至主机上某桥设备的以太网接口，在上面的图片就可以看到。

docker daemon启动时默认会创建一个名为docker0的网络桥，docker0网卡扮演二层交换机与网卡设备，不给IP就是交换机，给了IP即可以当交换机也可以当网卡。

并且我们以后在此模式下创建的容器为桥接式容器，我们每次启动一个容器，就会为这个容器分配一对网卡设备，其中一个网卡在容器上，另外一个网卡在宿主机上，在宿主机上的网卡接口桥接至docker0。

 

--network bridge：设置容器工作在bridge模式下，即为将容器接口添加至docker0桥。
docker0桥为NAT桥，因此，桥接式容器可通过此桥接口访问外部网络，但防火墙规则阻止一切从外部网络访问桥接式容器的请求，当然也有解决办法，后面会介绍外部访问容器。

这里容器使用独立network Namespace，并连接到docker0虚拟网卡（默认模式）。通过docker0网桥以及Iptables nat表配置与宿主机通信；bridge模式是Docker默认的网络设置，此模式会为每一个容器分配Network Namespace、设置IP等，并将一个主机上的Docker容器连接到一个虚拟网桥上。

5、bridge模式的拓扑

当Docker server启动时，会在主机上创建一个名为docker0的虚拟网桥，此主机上启动的Docker容器会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。接下来就要为容器分配IP了，Docker会从RFC1918所定义的私有IP网段中，选择一个和宿主机不同的IP地址和子网分配给docker0，连接到docker0的容器就从这个子网中选择一个未占用的IP使用。如一般Docker会使用172.17.0.0/16这个网段，并将172.17.42.1/16分配给docker0网桥（在主机上使用ifconfig命令是可以看到docker0的，可以认为它是网桥的管理接口，在宿主机上作为一块虚拟网卡使用）。单机环境下的网络拓扑如下，主机地址为10.10.101.105/24。

6、bridge模式下容器的通信

在bridge模式下，连在同一网桥上的容器可以相互通信（若出于安全考虑，也可以禁止它们之间通信，方法是在DOCKER_OPTS变量中设置–icc=false，这样只有使用–link才能使两个容器通信）。

Docker可以开启容器间通信（意味着默认配置--icc=true），也就是说，宿主机上的所有容器可以不受任何限制地相互通信，这可能导致拒绝服务攻击。进一步地，Docker可以通过--ip_forward和--iptables两个选项控制容器间、容器和外部世界的通信。

容器也可以与外部通信，我们看一下主机上的Iptable规则，可以看到这么一条（查看规则：iptables -t nat -vnL）：

-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE

这条规则会将源地址为172.17.0.0/16的包（也就是从Docker容器产生的包），并且不是从docker0网卡发出的，进行源地址转换，转换成主机网卡的地址。这么说可能不太好理解，举一个例子说明一下。假设主机有一块网卡为eth0，IP地址为10.10.101.105/24，网关为10.10.101.254。从主机上一个IP为172.17.0.1/16的容器中ping百度（180.76.3.151）。IP包首先从容器发往自己的默认网关docker0，包到达docker0后，也就到达了主机上。然后会查询主机的路由表，发现包应该从主机的eth0发往主机的网关10.10.105.254/24。接着包会转发给eth0，并从eth0发出去（主机的ip_forward转发应该已经打开）。这时候，上面的Iptable规则就会起作用，对包做SNAT转换，将源地址换为eth0的地址。这样，在外界看来，这个包就是从10.10.101.105上发出来的，Docker容器对外是不可见的。

上面添加规则来实现外部访问略为麻烦，我们还有一种更好的方法，端口映射：
为docker run命令使用-p选项即可实现端口映射，无须手动添加规则

-p选项的使用格式
-p <containerPort>
---将指定的容器端口映射至主机所有地址的一个动态端口（随机端口）
-p <hostPort>:<containerPort>
---将容器端口<containerPort>映射至指定的主机端口<hostPort>
-p <ip>::<containerPort>
---将指定的容器端口<containerPort>映射至主机指定<ip>的动态端口
-p <ip>:<hostPort>:<containerPort>
---将指定的容器端口<containerPort>映射至主机指定<ip>的端口<hostPort>
"动态端口"指随机端口，具体的映射结果可使用docker port命令查看

那么，外面的机器是如何访问Docker容器的服务呢？我们首先用下面命令创建一个含有web应用的容器，将容器的80端口映射到主机的80端口。

docker run --name=nginx_bridge --net=bridge -p 80:80 -d nginx

然后查看Iptable规则的变化，发现多了这样一条规则：

-A DOCKER ! -i docker0 -p tcp -m tcp --dport 80 -j DNAT --to-destination 172.17.0.2:80

此条规则就是对主机eth0收到的目的端口为80的tcp流量进行DNAT转换，将流量发往172.17.0.2:80，也就是我们上面创建的Docker容器。所以，外界只需访问10.10.101.105:80就可以访问到容器中的服务。

除此之外，我们还可以自定义Docker使用的IP地址、DNS等信息，甚至使用自己定义的网桥，但是其工作方式还是一样的。

六、容器安全

七、可视化工具

docker的容器可视化工具portainer、Shipyard

1、Shipyard

（1）镜像准备

docker pull rethinkdb
docker pull microbox/etcd
docker pull shipyard/docker-proxy
docker pull swarm 
docker pull shipyard/shipyard

（2）容器准备

#1. 数据存储
#Shipyard使用RethinkDB做为数据存储工具， 我们需要先运行RethinkDB容器。
#docker run -ti  -d --restart=always --name shipyard-rethinkdb rethinkdb

#2. 服务发现
#为了启用Swarm leader选择，我们必须使用来自Swarm容器的外部键值存储。此处，我们使用Etcd作为服务发现工具。可以选用的服务发现工具还有Consul、Zookeeper等。
# docker run -ti -d -p 4001:4001  -p 7001:7001  --restart=always --name shipyard-discovery microbox/etcd:latest -name discovery

#3. Docker代理服务
#默认情况下，Docker引擎只侦听套接字。 我们可以重新配置引擎以使用TLS，或者您可以使用代理容器。 这是一个非常轻量级的容器，它只是将请求从TCP转发到Docker监听的Unix套接字。
# docker run -ti -d -p 2375:2375 --hostname=$HOSTNAME  --restart=always --name shipyard-proxy -v /var/run/docker.sock:/var/run/docker.sock -e PORT=2375 shipyard/docker-proxy:latest
   
#4. Swarm管理节点
# docker run -tid --restart=always  --name shipyard-swarm-manager swarm:latest manage --host tcp://0.0.0.0:3375 etcd://<IP-OF-HOST>:4001
   
#5. Swarm Agent节点
# docker run -tid --restart=always --name shipyard-swarm-agent swarm:latest join --addr <ip-of-host>:2375 etcd://<ip-of-host>:4001
   
#6. Shipyard管理工具
# docker run -ti -d --restart=always --name shipyard-controller --link shipyard-rethinkdb:rethinkdb --link shipyard-swarm-manager:swarm -p 8080:8080 shipyard/shipyard:latest server -d tcp://swarm:3375

（3）登录界面

第一次登录账户密码分别为admin，shipyard

2、portainer

DockerUI(ui for Docker)
官方GitHub：https://github.com/kevana/ui-for-docker
项目已废弃，现在转投Portainer项目，不建议使用。

（1）环境准备

#docker search portainer
#docker pull portainer/portainer
#docker run -dit --restart=always -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock --name portainer portainer

（2）登录

第一次登录需要设置admin账户密码，不少于八位

 

3、docker-manager

学习地址:docker-manager可视化