‘壹’ docker容器与虚拟机有什么区别
Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）。几乎没有性能开销,可以很容易地在机器和数据中心中运行。最重要的是,他们不依赖于任何语言、框架包括系统。
在docker的网站上提到了docker的典型场景：
Automating the packaging and deployment of applications
Creation of lightweight, private PAAS environments
Automated testing and continuous integration/deployment
Deploying and scaling web apps, databases and backend services
由于其基于LXC的轻量级虚拟化的特点，docker相比KVM之类最明显的特点就是启动快，资源占用小。因此对于构建隔离的标准化的运行环境，轻量级的PaaS(如dokku), 构建自动化测试和持续集成环境，以及一切可以横向扩展的应用(尤其是需要快速启停来应对峰谷的web应用)。
‘贰’ 如何在Ubuntu上创建及管理LXC容器
将LXC安装到Ubuntu上
想在Ubuntu上使用LXC，就要安装LXC用户空间工具，如下所示。
$ sudo apt-get install lxc
安装完毕之后，运行lxc-checkconifg工具，检查当前Linux内核支持LXC的情况。要是一切都已被启用，内核对LXC的支持已准备就绪。
$ lxc-checkconfig
安装LXC工具后，你会发现，LXC的默认网桥接口（lxcbr0）已自动创建（已在/etc/lxc/default.conf中加以配置）。
创建LXC容器后，窗口的接口就会自动连接到该网桥，那样容器就能与外界进行联系了。
创建LXC容器
为了能够创建某个特定目标环境（比如Debian Wheezy 64位）的LXC容器，你就需要一个相应的LXC模板。幸运的是，Ubuntu上的LXC用户空间工具随带一系列预先准备好的LXC模板。你可以在/usr/share/lxc/templates目录下找到可用的LXC模板。
$ ls /usr/share/lxc/templates
LXC模板其实就是一段脚本而已，用来为某个特定的Linux环境创建容器。你在创建LXC容器时，需要用到这其中一个模板。
比如说，为了创建Ubuntu容器，使用下面这个命令行：
$ sudo lxc-create -n -t ubuntu
默认情况下，它会创建与本地主机同一版本号和同一架构的最小Ubuntu安装系统，这种情况下是Saucy Salamander（13.10）64位。
如果你希望，可以创建任何一种版本的Ubuntu容器，只要传递release参数。比如说，想创建Ubuntu 14.10容器：
$ sudo lxc-create -n -t ubuntu -- --release utopic
它会下载并验证目标容器环境需要的所有程序包。整个过程可能需要几分钟或更长时间，具体取决于容器类型。所以请耐心点。
经过一系列的程序包下载和验证后，LXC容器映像最终创建完毕，你会看到默认的登录资料可供使用。容器存储在/var/lib/lxc/<container-name>，根文件系统则位于/var/lib/lxc/<container-name>/rootfs。
LXC创建过程中下载的所有程序包则缓存在/var/cache/lxc里面，那样使用同样的LXC模板创建额外的容器就不用花时间了。
现在不妨看一下主机上的LXC容器列表：
$ sudo lxc-ls –fancy
NAME STATE IPV4 IPV6 AUTOSTART
------------------------------------
test-lxc STOPPED - - NO
想启动一个容器，请使用下面这个命令。“-d”选项将容器作为守护程序来启动。要是没有这个选项，你在启动容器后，会直接被连接到控制台。
$ sudo lxc-start -n -d
启动容器后，不妨再次检查容器状态：
$ sudo lxc-ls –fancy
NAME STATE IPV4 IPV6 AUTOSTART
-----------------------------------------
lxc RUNNING 10.0.3.55 - NO
你会看到，容器处于“RUNNING”（运行）状态，已被赋予了一个IP地址。
你还可以证实，容器的接口（比如vethJ06SFL）自动连接到LXC的内部网桥（lxcbr0），如下所示。
$ brctl show lxcbr0
管理LXC容器
既然我们已知道了如何创建及启动LXC容器，现在不妨看看我们可以如何处理运行中的容器。
首先，我们想要访问容器的控制台。为此，键入这个命令：
$ sudo lxc-console -n
键入<Ctrl+a q>组合键，退出控制台。
想停止和销毁容器：
$ sudo lxc-stop -n
$ sudo lxc-destroy -n
想把现有容器克隆成另一个容器，使用这些命令：
$ sudo lxc-stop -n
$ sudo lxc-clone -o -n
故障排查
如果你遇到了LXC方面的错误，下面是故障排查方面的几个要点。
1. 你无法创建LXC容器，出现下列错误。
$ sudo lxc-create -n test-lxc -t ubuntu
lxc-create: symbol lookup error: /usr/lib/x86_64-linux-gnu/liblxc.so.1: undefined symbol: cgmanager_get_pid_cgroup_abs_sync
这意味着你运行最新的LXC，却使用较旧的libcgmanager（libcg管理器）。想解决这个问题，你就需要更新libcg管理器。
$ sudo apt-get install libcgmanager0
‘叁’ 如何在Ubuntu系统下安装docker
Docker 是 dotCloud 最近几个月刚宣布的开源引擎，旨在提供一种应用程序的自动化部署解决方案，简单的说就是，在 Linux 系统上迅速创建一个容器（类似虚拟机）并在容器上部署和运行应用程序，并通过配置文件可以轻松实现应用程序的自动化安装、部署和升级，非常方便。因为使用了容器，所以可以很方便的把生产环境和开发环境分开，互不影响，这是 docker 最普遍的一个玩法。更多的玩法还有大规模 web 应用、数据库部署、持续部署、集群、测试环境、面向服务的云计算、虚拟桌面 VDI 等等。
注意：由于Docker需要在Linux Kernel 3.8及以上才可以很好的工作【本人在ubuntu12.04 lts 内核3.2也正常安装】，官方更是推荐Ubuntu系统，这里有两种选择：Ubuntu 12.04 LTS或最新的Ubuntu 13.10 而本文比较喜欢倾向LTS，幸好有办法解决Kernel版本问题。
1、更新Ubuntu内核
使用如下命令行更新内核至3.8.0-25
sudo apt-get install linux-image-3.8.0-25-generic
sudo apt-get install linux-headers-3.8.0-25-generic
完成后重启电脑，通过命令 “uname -r” 来查看内核是否成功更新。
2、安装lxc-docker
root@ubuntu: sudo apt-get install software-properties-common #增加 add-apt-repository 命令
root@ubuntu: sudo apt-get install python-software-properties
root@ubuntu: sudo add-apt-repository ppa:dotcloud/lxc-docker #增加一个ppa源，如：ppa:user/ppa-name
root@ubuntu: sudo apt-get update #更新系统
root@ubuntu: sudo apt-get install lxc-docker
3、测试doctor是否安装成功
root@ubuntu:~# docker #出现如下信息表示docker安装成功
Usage: docker [OPTIONS] COMMAND [arg...]
-H=[tcp://127.0.0.1:4243]: tcp://host:port to bind/connect to or unix://path/to/socket touse
A self-sufficient runtime for linux containers.
...
4、Hello World
4.1、下载官方ubuntu image
linjiqin@ubuntu:~$ sudo docker pull ubuntu #pull命令需要到国外的镜像仓库，拉取镜像，因为GFW的关系，拉取失败的可能性很大
4.2、运行hello world
linjiqin@ubuntu:~$ sudo docker run ubuntu /bin/echo hello world
5、docker常用命令
5.1、docker三种命令运行模式
docker有三种命令运行的方式：短暂方式、交互方式、daemon方式。
a、短暂方式：就是刚刚的那个”hello world”，命令执行完后，container就终止了，不过并没有消失，可以用 sudo docker ps -a 看一下所有的container，第一个就是刚刚执行过的container，可以再次执行一遍：
linjiqin@ubuntu:~$ sudo docker start container_id
不过这次看不到”hello world”了，只能看到ID，用logs命令才能看得到：
linjiqin@ubuntu:~$ sudo docker logs container_id
可以看到两个”hello world”，因为这个container运行了两次。
b、交互方式
linjiqin@ubuntu:~$ sudo docker run -i -t image_name /bin/bash #image_name为docker镜像名称
c、daemon方式
即让软件作为长时间服务运行，这就是SAAS啊！
例如，一个无限循环打印的脚本(替换为memcached、apache等，操作方法仍然不变！)：
linjiqin@ubuntu:~$ CONTAINER_ID=$(sudo docker run -d ubuntu /bin/sh -c "while true; do echo hello world; sleep 1; done")
在container外面查看它的输出
linjiqin@ubuntu:~$ sudo docker logs $CONTAINER_ID
或者连接上容器实时查看
linjiqin@ubuntu:~$ sudo docker attach $CONTAINER_ID
终止容器
linjiqin@ubuntu:~$ sudo docker stop $CONTAINER_ID
linjiqin@ubuntu:~$ sudo docker ps #看一下，已经没了
5.2、docker ps命令
linjiqin@ubuntu:~$ sudo docker ps #列出当前所有正在运行的container
linjiqin@ubuntu:~$ sudo docker ps -l #列出最近一次启动的，且正在运行的container
linjiqin@ubuntu:~$ sudo docker ps -a #列出所有的container
注意：
a、其他用法请参考 sudo docker ps -h
b、还有一种方式可以让程序在daemon模式下运行，就是在Dockerfile里设置USER为daemon
5.3、docker export命令
linjiqin@ubuntu:~$ container_id=`docker run -d <image_name> ls`
linjiqin@ubuntu:~$ docker export $container_id > image.tgz
5.4、docker import命令
linjiqin@ubuntu:~$ cat image.tgz | sudo docker import - simple_dev #simple_dev为自定义的镜像名称
5.5、docker port命令
linjiqin@ubuntu:~$ docker run -p 80:8080 <image> <cmd> #映射容器的8080端口到宿主机的80端口
5.6、删除容器
5.6.1、删除所有容器
linjiqin@ubuntu:~$ sudo docker rm `sudo docker ps -a -q`
5.6.1、删除具体某个容器
linjiqin@ubuntu:~$ sudo docker rm $CONTAINER_ID
5.7、docker命令快速参考
linjiqin@ubuntu:~$ sudo docker images #查看本地镜像
linjiqin@ubuntu:~$ sudo docker attach $CONTAINER_ID #启动一个已存在的docker实例
linjiqin@ubuntu:~$ sudo docker stop $CONTAINER_ID #停止docker实例
linjiqin@ubuntu:~$ sudo docker logs $CONTAINER_ID #查看docker实例运行日志，确保正常运行
linjiqin@ubuntu:~$ sudo docker inspect $CONTAINER_ID #查看container的实例属性，比如ip等等
sudo docker run -t -i -v /home/linjiqin/dev/docker:/home/mycontainer:rw -p 8000:8000 mydocker /bin/bash
写在前面，运行我们的镜像的命令使用上面的为参考，这样会挂载本地文件夹，并且会映射container的8000端口到宿主机的8000端口
/home/linjiqin/dev/docker为要挂载的本地文件夹，需提前创建
/home/mycontainer为docker映射路径，执行上面命令会帮我们创建。
‘肆’ docker 安装 ubuntu 怎么用
Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google公司推出的
Go 语言实现。 项目后来加入了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在 GitHub上进行维护。
Docker 自开源后受到广泛的关注和讨论，以至于 dotCloud 公司后来都改名为 Docker Inc。RedHat 已经在其 RHEL6.5 中集中支持 Docker；Google 也在其 PaaS 产品中广泛应用。
Docker 项目的目标是实现轻量级的操作系统虚拟化解决方案。 Docker 的基础是 Linux 容器（LXC）等技术。
在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的容器就像操作一个快速轻量级的虚拟机一样简单。
安装docker
docker安装方法一
ubuntu14.04以上的版本都是自带docker安装包的；所以可以直接安装；但是这个一般不是最先版本
sudo apt-get update
sudo apt-get install docker.io
docker安装方法二；安装最新版本
sudo apt-get update
curl -s https://get.docker.io/ubuntu/ | sudo sh
这个方法启动docker若出现下面错误；(这个我没遇到)
FATA[0000] Error loading docker apparmor profile: fork/exec /sbin/apparmor_parser: no such file or directory ()
别担心，请安装apparmor软件即可
sudo apt-get install apparmor
用户组和配置文件修改
把当前用户加入到docker用户组中
sudo usermod -a -G docker $USER
添加配置文件
sudo vim /etc/default/docker
在配置文件中添加或修改
DOCKER="/usr/bin/docker"
重启docker
sudo service docker restart #重启
安装完成之后可以测试下面几个命令
查看版本
docker -v
显示如下：
这就表明你安装成功了
查看状态：
sudo service docker status
显示如下：
其他状态命令：
sudo service docker start #启动
sudo service docker stop #关闭
sudo service docker restart #重启
查看镜像：此时应该没有镜像
docker images
显示如下：
安装第一个镜像ubuntu
下载docker 镜像，需要几分钟。
sudo docker pull ubuntu
启动容器，并且进入到Ubuntu容器的bash命令
sudo docker run -i -t ubuntu /bin/bash
输出hello world
下载时的现象：
启动时的现象：其实相当于启动了一个虚拟机；
输出hello world：
ps命令：
Docker常用命令速查
# 下载一个ubuntu镜像
sudo docker pull ubuntu
# 使用ubuntu运行一个交互性的shell,
# 分配一个伪终端，附带stdin和stdout(输入/输出流)
# 如果你想退出分离出来的伪终端,
# 可以使用CTRL -p+CTRL -q --就像先按CTRL -p 然后CTRL -q
sudo docker run -i -t ubuntu /bin/bash
#docker ps命令
sudo docker ps #列出当前所有正在运行的container
sudo docker ps -l #列出最近一次启动的，且正在运行的container
sudo docker ps -a #列出所有的container
#port命令
docker run -p 80:8080 <image> <cmd> #映射容器的8080端口到宿主机的80端口
#删除容器命令
sudo docker rm `sudo docker ps -a -q`#删除所有容器
sudo docker rm $CONTAINER_ID#删除容器id为CONTAINER_ID的容器
#其他命令快速参考：
sudo docker images #查看本地镜像
sudo docker attach $CONTAINER_ID #启动一个已存在的docker实例
sudo docker stop $CONTAINER_ID #停止docker实例
sudo docker logs $CONTAINER_ID #查看docker实例运行日志，确保正常运行
sudo docker inspect $CONTAINER_ID #查看container的实例属性，比如ip等等
sudo docker run -t -i -v /home/linjiqin/dev/docker:/home/mycontainer:rw -p 8000:8000 mydocker /bin/bash
写在前面，运行我们的镜像的命令使用上面的为参考，这样会挂载本地文件夹，并且会映射container的8000端口到宿主机的8000端口
/home/linjiqin/dev/docker为要挂载的本地文件夹，需提前创建
/home/mycontainer为docker映射路径，执行上面命令会帮我们创建
‘伍’ 如何理解 LXC 与 Docker 之间的主要区别
两者的概述
容器技术独立运行并且从主机系统上封装应用程序工作量。把容器想象成可以安装和运行应用程序的主机操作系统里面的操作系统，从实用目的来讲，它就像一个虚拟机。
LXC项目给不同配置和用户空间应用提供最小的容器操作样本来管理容器生命周期， LXC项目的这个特性和Linux内核使模仿机制能够正常启用。
便携性
容器技术将应用从主机操作系统上解耦下来，摘录该程序并且使之在任意支持LXC的系统上都实现轻便化。低调的说法就是：非常好用。用户在这样一个原始和最小库的Linux操作系统上可以在容器里运行任何程序（就像是在容器里运行LAMP堆栈）。
因为应用程序和工作量是相对独立的，所以用户可以运行多版本的语言，比如PHP，Python，Ruby，Apache，这些语言都可以共存，隐藏在容器里。实现云计算，就好比是这些例子和工作量都可以灵活的被移动到别的系统，复制，以及快速配置。
难道虚拟技术就做不到吗？
不不不，虚拟技术也可以做到，但是会有一定程度的性能损失，灵活度也会下降。容器技术不是模仿硬件层次，而是在Linux内核里使用cgroup和namespaces来打造轻便的、将近裸机速度的虚拟技术操作系统环境。因为不是虚拟化存储，所以容器技术不会管底层存储或者文件系统，而是你放哪里，它操作哪里。
这从根本上改变了我们如何虚拟化工作负载和应用程序，因为容器速度比硬件虚拟化技术更快，更加便捷，弹性扩容的更加高效，只是它的工作负载要求操作系统，而不是Linux或特定的Linux内核版本。
那VMWare就这样玩完了？
没那么快！虚拟技术相对成熟，又有广泛的工具，还有生态系统来支持它在不同环境下的配置。至于工作负载，它要求非Linux操作系统，或者只能使用特定的核心虚拟化技术。
LXC
LXC起源于cgroup和namespaces在Linux内核方面的发展，它支持轻便的虚拟技术操作系统环境（容器技术），Daniel Lezcano和Serge Hallyn做了一些它的早期工作，这个可以追溯到2009年在IBM的时候。
LXC系统提供工具来管理容器，先进的网络和存储支持，还有最小容器操作系统模板的广泛选择。它目前由一个两人的团队领导：来自Ubuntu的Stephane Graber和Serge Hallyn。LXC是由Ubuntu支持的。
如何区分他们
生产Docker的目的是为了尽可能减少容器中运营的程序，减少到只运营单个程序，并且通过Docker来管理这个程序。
有了Docker，可以从底层应用程序通过Docker来配置，网络，存储和编排。
LXC用正常操作系统环境回避那个问题，并且因此可以快速兼容所有应用程序和工具，以及任意管理和编制层次，来替代虚拟机。
除此之外，Docker使用层次，禁用存储持久性。LXC支持AUFS层次和覆盖，对COW克隆和用brtfs、ZFS、LVM Thin快照广泛支持，并且将选择留给用户。LXC容器技术里的分散存储是绑定安装的，来为用户达到主机或者另一个容器。
Docker和LXC都设置了一个默认的NAT网络。另外，Docker设置一个端口转发到主机上，就会有一个－p标记，比如“－p80:80”就是80从主机转发到容器。有NAT，本地主机就可以直接通过IP访问容器，外部服务需要的时候可以通过IPtable规则来简单完成，当外部服务被消耗的时候，只需要端口转发就可以。至于为什么需要这么做，原因目前还不是很明确。
要把事项复合起来，Docker只给了很少的IP和主机文件控制权，所以不能给容器设置静态IP，这对于IP的分配任务来说有点让人疑惑。我们需要使用“－－Links”标记来连接容器，这个容器中要在被连接的容器中加一个入口在／etc／主机上。
有了LXC，分配静态IP，动态IP，使用多网络设备就简单多了，可以使用／etc／hosts文件，基本上使用Linux网络全栈是没有限制的。您希望在主机上连接容器吗？用户使用GRE，L2TPV3或者VXLAN来快速设置层次，或者是任意的在使用的网络技术。
LXC容器技术可以无缝运行虚拟机运行的一切。
Docker
Docker是dotCloud也就是现在的Docker公司在2013年3月发布的，一开始是基于LXC项目来创建单个应用程序容器。Docker现在已经开发了他们自己的直接使用核心namespaces和cgroup的工具：libcontainer。
分层容器
Docker最开始是基于LXC对Aufs的支持来建立分层容器，因为Aufs可能无法被合并到核心中，所以现在对Brtfs、设备映射和覆盖也添加支持，
Docker容器技术是由基底镜像构成，当提交变成Docker镜像的时候会再加上一个分层面板。当运行一个镜像的时候，它的复本就作为容器被启动了，在提交之前，它的任何数据都只是暂时的。每一个提交都是一个独立的镜像，所以可以从镜像开始。
我们在《如何用LXC覆盖》里有一个指导说明，它给用户描述了分层结构是如何工作的。有了像Aufs或者覆盖（他们在实施上、性能上有区别，而且支持一定数量的低一点的层次）这样的文件系统的联合，较低一点的层次是只读的，而较高一点的层次是在运行的时候是可读可写的。在容器内容中通常是基底操作系统，但是也不是很必要，而上层的图层面板则是由你来修改。
虽然图层面板的想法听起来很不错，但是分层文件系统在技术上仍然是不成熟的，在使用图层面板的时候，还有有一个固有的复杂性和性能的损失。《陷入图层面板》是一个真实的冒险实例，大家不妨看看。
单个应用程序容器
Docker将容器技术限制到只能运行单个进程。Docker的底层镜像操作系统模版不是为运行多个应用程序，进程设计，也不是为像init，cron，syslog，ssh等服务而设计。
我们来看早期的东西，它介绍了日复一日的用户场景有一定的复杂性。因为目前的架构，应用程序和服务是为正常的多程序操作系统环境设计的，所以需要去寻找一种以Docker的方式来工作或使用工具来支持Docker。
拿一个简单的应用程序举个例子，比如WordPress。你可能需要建立3个容器来互相消耗服务。PHP容器，Nginx容器和MySQL容器加上2个分别用来放MysqlDB和WordPress文件持久性数据的容器。然后通过适当的权限将WordPress文件安装成PHP－FPM和Nginx两种语言都可用，然后为了把东西弄得更加让人兴奋，找出一种能够让容器在本地网络上可以互相交流的方法，不需要对网络不定时的控制，也不需要Docker后台程序设置IP！但是我们还没有计算WordPress账户管理的cron和Email。哎！
为了在Docker里运行多个程序，你需要shell 脚本，或者是一个分开的程序管理，比如runit或者管理器。但是Docker生态系统会将之视为“反模式“，而且Docker的整个架构是建立在运行单个程序的容器上的。
代码库
Docker为用户提供公共或者个人push和pull镜像的数据库。这个跟Flockport app Store为用户使用容器做好准备有点相似。这样做，对用户来说，分享和分布应用程序就很简单了。
Dockerfile
Dockerfile是一个告诉Docker如何从镜像用特定的应用程序来创建容器的脚本。跟使用特定的安装好的应用程序通过bash脚本来创建一个LXC容器相似。
跟LXC拉开距离
LXC的特点需要通过Docker团队来重载实现，使之在Docker中可用，比如LXC现在支持让非根用户创建和配置容器的未经授权容器，LXC现在还致力于实时迁移和多主机管理。这些对容器来说都是很大的进步，也为更好的安全性，多租户工作量以及虚拟平价铺平了道路。
Docker还不支持这些。随着最近的libcontainer声明，推测两者间的差距还将增大。
运行容器的方法没有对错之分，容器怎么用主要取决于用户，docker方法是独特的，而且还将在每个阶段自定义途径成为必须途径，并以此来找到Docker的方法从安装和运行应用程序来完成任务，完成弹性扩容。
‘陆’ 如何理解LXC与Docker之间的主要区别
Docker不是lxc的一个替代方案。“lxc”是指linux内核（尤指命名空间以及Cgroup）的一个特性，它允许其他一些沙盒进程运行在一块相对独立的空间，并且能够方便的控制他们的资源调度。而基于底层的内核特性的基础上，Docker在上层构建了一个更高层次的具备多个强大功能的工具集：可移植的跨机器部署。Docker定义了一个将应用打包的规范，而它的所有依赖都被封装到了一个简单对象里，它可以被传输到任意一台能运行Docker的机器，并且在这里启动Docker的实例之后，它能够确保承载应用的执行环境将会与之前所定义的完全一致。Lxc实现了进程级的沙盒封装，它是可移植部署的一个重要前提，但是要想实现可移植部署，仅仅是这样可还不够。如果你发送给我一份安装到一个自定义LXC配置下的应用副本，那么几乎可以肯定的是，它在我的机器上运行的结果不会跟你的完全一样，因为它绑定了你机器的一些特殊配置：网络，存储，日志，Linux发行版本等等。Docker为这些机器的特定配置定义了一个抽象层，所以它使得这些相同的Docker容器能够一成不变的运行在多个不同的主机上，甚至带上各种不同的配置。以应用为中心。相对于机器而言，Docker被用于优化应用的部署过程。这可以从它的API，UI，设计理念还有文档里得到体现。反之，lxc的辅助脚本专注在把容器作为一个轻量级的机器使用——基本上就是一堆启动更快并且内存需求更小的服务器。我们认为容器技术的内容远远不止这些。自动构建。Docker为开发人员引入了一个可以用来把他们的源代码自动打包到容器里的工具，并且他们能够对于应用的依赖，构建工具，打包服务等有着完全的自主掌控能力。他们能够自由的使用make，maven，chef，puppet，salt，debian包，rpm包，源码包，或者任意以上的结合，而无需关心机器本身的配置。版本化。Docker引入了一个类似git的特性来完成一个容器的连续版本追踪，版本之间的差异diff，新的版本的提交，回滚等。历史记录信息里也包含了容器的用户信息以及他是如何构建它的，因此生产环境的服务器你都有充足的手段去一步步的定位到最上游的开发人员。Docker也实现了一个增量上传和下载功能，类似于gitpull，所以更换到新版本的容器只需要传输增量部分就行。组件的重用。任意容器都能用作“基础镜像”来创建更特定的组件。这可以手工完成也可以做成自动构建的一部分。例如，你可以准备一个理想的python环境，并且把它用作10个不同的应用的基础镜像。你所定义的标准postgresql设置可以被将来你手上的所有项目重用。诸如此类。共享。Docker有权访问一个公共的注册中心（/）而这里有数以千计的业界人士上传各种各样有价值的容器：任一从redis，couchdb，postgres到ircbouncers再到rails应用服务器，Hadoop甚至是多个发行版本的基础镜像。该注册中心也包含了一个官方的“标准库”，这里提供了一些由Docker官方团队维护的实用容器。注册中心本身也是开源的，所以任何人都能部署他们自己的私有注册中心来存储和下发私有容器，例如用于内网服务器的部署。工具生态圈。Docker定义了一个API来自动化和个性化的创建和部署容器。也因此催生了众多的工具集成到Docker，为之提供一些扩展特性。类PaaS的部署（Dokku，Deis，Flynn），多节点编排（maestro,salt,mesos,openstacknova），管理看板（docker-ui,openstackhorizon,shipyard），配置管理（chef,puppet)，持续集成（jenkins,strider,travis）等等。Docker正在迅速的建立以它本身为标准的基于容器的工具生态圈。
‘柒’ docker run 和网络有关吗
在Docker中，run应该是用户使用最多的命令了，很多读者反馈不是很明白run命令的用法，而且相关的书籍、中文资料中对run命令的描述也不是非常完整，所以DockerOne组织翻译了Docker官方的文档，以飨读者。注意，本文基于最新的Docker 1.4文档翻译。
Docker会在隔离的容器中运行进程。当运行 docker run命令时，Docker会启动一个进程，并为这个进程分配其独占的文件系统、网络资源和以此进程为根进程的进程组。在容器启动时，镜像可能已经定义了要运行的二进制文件、暴露的网络端口等，但是用户可以通过docker run命令重新定义（译者注：docker run可以控制一个容器运行时的行为，它可以覆盖docker build在构建镜像时的一些默认配置），这也是为什么run命令相比于其它命令有如此多的参数的原因。
命令格式
最基本的docker run命令的格式如下：
$ sudo docker run [OPTIONS] IMAGE[:TAG] [COMMAND] [ARG...]
如果需要查看[OPTIONS]的详细使用说明，请参考Docker关于OPTIONS的章节。这里仅简要介绍Run所使用到的参数。OPTIONS总起来说可以分为两类：
设置运行方式：
决定容器的运行方式，前台执行还是后台执行；
设置containerID；
设置网络参数；
设置容器的CPU和内存参数；
- 设置权限和LXC参数；
设置镜像的默认资源，也就是说用户可以使用该命令来覆盖在镜像构建时的一些默认配置。
docker run [OPTIONS]可以让用户完全控制容器的生命周期，并允许用户覆盖执行docker build时所设定的参数，甚至也可以修改本身由Docker所控制的内核级参数。
Operator exclusive options
当执行docker run时可以设置以下参数：
Detached vs Foreground
Detached (-d)
- Foreground
Container Identification
Name (--name)
- PID Equivalent
IPC Setting
Network Settings
Clean Up (--rm)
Runtime Constraints on CPU and Memory
Runtime Privilege, Linux Capabilities, and LXC Configuration
接下来我们依次进行介绍。
Detached vs foreground
当我们启动一个容器时，首先需要确定这个容器是运行在前台还是运行在后台。
-d=false: Detached mode: Run container in the background, print new container id
Detached (-d)
如果在docker run后面追加-d=true或者-d，那么容器将会运行在后台模式。此时所有I/O数据只能通过网络资源或者共享卷组来进行交互。因为容器不再监听你执行docker run的这个终端命令行窗口。但你可以通过执行docker attach来重新附着到该容器的回话中。需要注意的是，容器运行在后台模式下，是不能使用--rm选项的。
Foregroud
在前台模式下（不指定-d参数即可），Docker会在容器中启动进程，同时将当前的命令行窗口附着到容器的标准输入、标准输出和标准错误中。也就是说容器中所有的输出都可以在当前窗口中看到。甚至它都可以虚拟出一个TTY窗口，来执行信号中断。这一切都是可以配置的：
-a=[] : Attach to `STDIN`, `STDOUT` and/or `STDERR`
-t=false : Allocate a pseudo-tty
--sig-proxy=true: Proxify all received signal to the process (non-TTY mode only)
-i=false : Keep STDIN open even if not attached
如果在执行run命令时没有指定-a参数，那么Docker默认会挂载所有标准数据流，包括输入输出和错误，你可以单独指定挂载哪个标准流。
$ sudo docker run -a stdin -a stdout -i -t ubuntu /bin/bash
如果要进行交互式操作（例如Shell脚本），那我们必须使用-i -t参数同容器进行数据交互。但是当通过管道同容器进行交互时，就不需要使用-t参数，例如下面的命令：
echo test | docker run -i busybox cat
容器识别
Name（--name）
可以通过三种方式为容器命名：
1. 使用UUID长命名（""）
2. 使用UUID短命令（"f78375b1c487"）
3. 使用Name("evil_ptolemy")
这个UUID标示是由Docker deamon生成的。如果你在执行docker run时没有指定--name，那么deamon会自动生成一个随机字符串UUID。但是对于一个容器来说有个name会非常方便，当你需要连接其它容器时或者类似需要区分其它容器时，使用容器名称可以简化操作。无论容器运行在前台或者后台，这个名字都是有效的。
PID equivalent
如果在使用Docker时有自动化的需求，你可以将containerID输出到指定的文件中（PIDfile），类似于某些应用程序将自身ID输出到文件中，方便后续脚本操作。
--cidfile="": Write the container ID to the file
Image[:tag]
当一个镜像的名称不足以分辨这个镜像所代表的含义时，你可以通过tag将版本信息添加到run命令中，以执行特定版本的镜像。例如: docker run ubuntu:14.04
IPC Settings
默认情况下，所有容器都开启了IPC命名空间。
--ipc="" : Set the IPC mode for the container,
'container:<name|id>': reuses another container's IPC namespace
'host': use the host's IPC namespace inside the container
IPC（POSIX/SysV IPC）命名空间提供了相互隔离的命名共享内存、信号灯变量和消息队列。
共享内存可以提高进程数据的交互速度。共享内存一般用在数据库和高性能应用（C/OpenMPI、C++/using boost libraries）上或者金融服务上。如果需要容器中部署上述类型的应用，那么就应该在多个容器直接使用共享内存了。
Network settings
默认情况下，所有的容器都开启了网络接口，同时可以接受任何外部的数据请求。
--dns=[] : Set custom dns servers for the container
--net="bridge" : Set the Network mode for the container
'bridge': creates a new network stack for the container on the docker bridge
'none': no networking for this container
'container:<name|id>': reuses another container network stack
'host': use the host network stack inside the container
--add-host="" : Add a line to /etc/hosts (host:IP)
--mac-address="" : Sets the container's Ethernet device's MAC address
你可以通过docker run --net none来关闭网络接口，此时将关闭所有网络数据的输入输出，你只能通过STDIN、STDOUT或者files来完成I/O操作。默认情况下，容器使用主机的DNS设置，你也可以通过--dns来覆盖容器内的DNS设置。同时Docker为容器默认生成一个MAC地址，你可以通过--mac-address 12:34:56:78:9a:bc来设置你自己的MAC地址。
Docker支持的网络模式有：
none。关闭容器内的网络连接
bridge。通过veth接口来连接容器，默认配置。
host。允许容器使用host的网络堆栈信息。 注意：这种方式将允许容器访问host中类似D-BUS之类的系统服务，所以认为是不安全的。
container。使用另外一个容器的网络堆栈信息。
None模式
将网络模式设置为none时，这个容器将不允许访问任何外部router。这个容器内部只会有一个loopback接口，而且不存在任何可以访问外部网络的router。
Bridge模式
Docker默认会将容器设置为bridge模式。此时在主机上面将会存在一个docker0的网络接口，同时会针对容器创建一对veth接口。其中一个veth接口是在主机充当网卡桥接作用，另外一个veth接口存在于容器的命名空间中，并且指向容器的loopback。Docker会自动给这个容器分配一个IP，并且将容器内的数据通过桥接转发到外部。
Host模式
当网络模式设置为host时，这个容器将完全共享host的网络堆栈。host所有的网络接口将完全对容器开放。容器的主机名也会存在于主机的hostname中。这时，容器所有对外暴露的端口和对其它容器的连接，将完全失效。
Container模式
当网络模式设置为Container时，这个容器将完全复用另外一个容器的网络堆栈。同时使用时这个容器的名称必须要符合下面的格式：--net container:<name|id>.
比如当前有一个绑定了本地地址localhost的Redis容器。如果另外一个容器需要复用这个网络堆栈，则需要如下操作：
$ sudo docker run -d --name redis example/redis --bind 127.0.0.1
$ # use the redis container's network stack to access localhost
$ sudo docker run --rm -ti --net container:redis example/redis-cli -h 127.0.0.1
管理/etc/hosts
/etc/hosts文件中会包含容器的hostname信息，我们也可以使用--add-host这个参数来动态添加/etc/hosts中的数据。
$ /docker run -ti --add-host db-static:86.75.30.9 ubuntu cat /etc/hosts
172.17.0.22 09d03f76bf2c
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
86.75.30.9 db-static
Clean up (--rm)
默认情况下，每个容器在退出时，它的文件系统也会保存下来，这样一方面调试会方便些，因为你可以通过查看日志等方式来确定最终状态。另外一方面，你也可以保存容器所产生的数据。但是当你仅仅需要短暂的运行一个容器，并且这些数据不需要保存，你可能就希望Docker能在容器结束时自动清理其所产生的数据。
这个时候你就需要--rm这个参数了。 注意：--rm 和 -d不能共用！
--rm=false: Automatically remove the container when it exits (incompatible with -d)
Security configuration
--security-opt="label:user:USER" : Set the label user for the container
--security-opt="label:role:ROLE" : Set the label role for the container
--security-opt="label:type:TYPE" : Set the label type for the container
--security-opt="label:level:LEVEL" : Set the label level for the container
--security-opt="label:disable" : Turn off label confinement for the container
--secutity-opt="apparmor:PROFILE" : Set the apparmor profile to be applied to the container
你可以通过--security-opt修改容器默认的schema标签。比如说，对于一个MLS系统来说（译者注：MLS应该是指Multiple Listing System），你可以指定MCS/MLS级别。使用下面的命令可以在不同的容器间分享内容：
#docker run --security-opt label:level:s0:c100,c200 -i -t fedora bash
如果是MLS系统，则使用下面的命令：
# docker run --security-opt label:level:TopSecret -i -t rhel7 bash
使用下面的命令可以在容器内禁用安全策略：
# docker run --security-opt label:disable -i -t fedora bash
如果你需要在容器内执行更为严格的安全策略，那么你可以为这个容器指定一个策略替代，比如你可以使用下面的命令来指定容器只监听Apache端口：
# docker run --security-opt label:type:svirt_apache_t -i -t centos bash
注意：此时，你的主机环境中必须存在一个名为svirt_apache_t的安全策略。
Runtime constraints on CPU and memory
下面的参数可以用来调整容器内的性能。
-m="": Memory limit (format: <number><optional unit>, where unit = b, k, m or g)
-c=0 : CPU shares (relative weight)
通过docker run -m可以调整容器所使用的内存资源。如果主机支持swap内存，那么可以使用-m可以设定比主机物理内存还大的值。
同样，通过-c可以调整容器的CPU优先级。默认情况下，所有的容器拥有相同的CPU优先级和CPU调度周期，但你可以通过Docker来通知内核给予某个或某几个容器更多的CPU计算周期。
比如，我们使用-c或者--cpu-shares =0启动了C0、C1、C2三个容器，使用-c/--cpu-shares=512启动了C3容器。这时，C0、C1、C2可以100%的使用CPU资源（1024），但C3只能使用50%的CPU资源（512）。如果这个主机的操作系统是时序调度类型的，每个CPU时间片是100微秒，那么C0、C1、C2将完全使用掉这100微秒，而C3只能使用50微秒。
Runtime privilege, Linux capabilities, and LXC configuration
--cap-add: Add Linux capabilities
--cap-drop: Drop Linux capabilities
--privileged=false: Give extended privileges to this container
--device=[]: Allows you to run devices inside the container without the --privileged flag.
--lxc-conf=[]: (lxc exec-driver only) Add custom lxc options --lxc-conf="lxc.cgroup.cpuset.cpus = 0,1"
默认情况下，Docker的容器是没有特权的，例如不能在容器中再启动一个容器。这是因为默认情况下容器是不能访问任何其它设备的。但是通过"privileged"，容器就拥有了访问任何其它设备的权限。
当操作者执行docker run --privileged时，Docker将拥有访问主机所有设备的权限，同时Docker也会在apparmor或者selinux做一些设置，使容器可以容易的访问那些运行在容器外部的设备。你可以访问Docker博客来获取更多关于--privileged的用法。
同时，你也可以限制容器只能访问一些指定的设备。下面的命令将允许容器只访问一些特定设备：
$ sudo docker run --device=/dev/snd:/dev/snd ...
默认情况下，容器拥有对设备的读、写、创建设备文件的权限。使用:rwm来配合--device，你可以控制这些权限。
$ sudo docker run --device=/dev/sda:/dev/xvdc --rm -it ubuntu fdisk /dev/xvdc
Command (m for help): q
$ sudo docker run --device=/dev/sda:/dev/xvdc:r --rm -it ubuntu fdisk /dev/xvdc
You will not be able to write the partition table.
Command (m for help): q
$ sudo docker run --device=/dev/sda:/dev/xvdc:w --rm -it ubuntu fdisk /dev/xvdc
crash....
$ sudo docker run --device=/dev/sda:/dev/xvdc:m --rm -it ubuntu fdisk /dev/xvdc
fdisk: unable to open /dev/xvdc: Operation not permitted
使用--cap-add和--cap-drop，配合--privileged，你可以更细致的控制人哦怒气。默认使用这两个参数的情况下，容器拥有一系列的内核修改权限，这两个参数都支持all值，如果你想让某个容器拥有除了MKNOD之外的所有内核权限，那么可以执行下面的命令：
$ sudo docker run --cap-add=ALL --cap-drop=MKNOD ...
如果需要修改网络接口数据，那么就建议使用--cap-add=NET_ADMIN，而不是使用--privileged。
$ docker run -t -i --rm ubuntu:14.04 ip link add mmy0 type mmy
RTNETLINK answers: Operation not permitted
$ docker run -t -i --rm --cap-add=NET_ADMIN ubuntu:14.04 ip link add mmy0 type mmy
如果要挂载一个FUSE文件系统，那么就需要--cap-add和--device了。
$ docker run --rm -it --cap-add SYS_ADMIN sshfs sshfs [email protected]:/home/sven /mnt
fuse: failed to open /dev/fuse: Operation not permitted
$ docker run --rm -it --device /dev/fuse sshfs sshfs [email protected]:/home/sven /mnt
fusermount: mount failed: Operation not permitted
$ docker run --rm -it --cap-add SYS_ADMIN --device /dev/fuse sshfs
# sshfs [email protected]:/home/sven /mnt
The authenticity of host '10.10.10.20 (10.10.10.20)' can't be established.
ECDSA key fingerprint is 25:34:85:75:25:b0:17:46:05:19:04:93:b5:dd:5f:c6.
Are you sure you want to continue connecting (yes/no)? yes
[email protected]'s password:
root@30aa0cfaf1b5:/# ls -la /mnt/src/docker
total 1516
drwxrwxr-x 1 1000 1000 4096 Dec 4 06:08 .
drwxrwxr-x 1 1000 1000 4096 Dec 4 11:46 ..
-rw-rw-r-- 1 1000 1000 16 Oct 8 00:09 .dockerignore
-rwxrwxr-x 1 1000 1000 464 Oct 8 00:09 .drone.yml
drwxrwxr-x 1 1000 1000 4096 Dec 4 06:11 .git
-rw-rw-r-- 1 1000 1000 461 Dec 4 06:08 .gitignore
如果Docker守护进程在启动时选择了lxc lxc-driver（docker -d --exec-driver=lxc），那么就可以使用--lxc-conf来设定LXC参数。但需要注意的是，未来主机上的Docker deamon有可能不会使用LXC，所以这些参数有可能会包含一些没有实现的配置功能。这意味着，用户在操作这些参数时必须要十分熟悉LXC。
特别注意：当你使用--lxc-conf修改容器参数后，Docker deamon将不再管理这些参数，那么用户必须自行进行管理。比如说，你使用--lxc-conf修改了容器的IP地址，那么在/etc/hosts里面是不会自动体现的，需要你自行维护。
Overriding Dockerfile image defaults
当开发者使用Dockerfile进行build或者使用commit提交容器时，开发人员可以设定一些镜像默认参数。
‘捌’ 如何在Ubuntu上借助Docker管理Linux容器
虽说标准的硬件虚拟化技术（比如KVM、Xen或Hyper-V）擅长于在一个物理主机上运行多个操作系统的完全隔离的实例，但这种虚拟化技术在性能、资源和资源配置时间等方面存在各种各样的开销。标准的机器虚拟化实际上可能没有必要，这取决于你的实际使用场合。
另外一种轻型虚拟化方法就是所谓的Linux容器（LXC），它提供了操作系统级别的虚拟化。由于不存在运行虚拟机带来的开销，LXC让用户可以在轻型容器沙盒里面运行标准Linux操作系统的多个实例。如果你搭建一个可复制的开发/测试环境，或者在安全沙盒里面部署应用程序，容器就派得上大用场。
Docker就是为了便于部署Linux容器而开发的这样一款开源工具。Docker正迅速成为容器技术方面的一项事实上的标准，已经被诸如Ubuntu和红帽之类的各大Linux发行版所采用。
我在本教程中将演示如何在Ubuntu 14.04上，借助Docker管理Linux容器。请注意：对Ubuntu的早期版本而言，操作步骤可能略有不同。
眼下，Ubuntu上可用的Docker程序包只支持64位系统。想在32位机器上运行它，你就要利用源代码构建32位版本的Docker（详见这里）。
安装Docker
借助apt-get命令，安装Docker是件轻而易举的事。
$ sudo apt-get install docker.io
为了允许非根用户也可以运行Docker，将你自己添加到docker群组。下面这个命令会允许当前用户运行Docker，无需根用户权限。
$ sudo usermod -a -G docker $USER
退出，然后重新登录，以激活群组成员的变化。
下一步，编辑Docker配置文件，以便更新Docker二进制代码的位置。
$ sudo vi /etc/default/docker.io
DOCKER="/usr/bin/docker.io"
重启Docker服务。
$ sudo service docker.io restart
管理Docker容器
如果你想启动Ubuntu操作系统的一个新的Docker容器，首先需要获取Ubuntu Docker映像文件。下面这个命令会通过网络下载Docker映像文件。
$ docker pull ubuntu
你可以以一种交互模式来开启Ubuntu Docker，如下所示。最后一个参数“/bin/bash”是一旦启动就将在容器里面执行的命令，这里是一个简单的bash外壳命令。
$ docker run -i -t ubuntu /bin/bash
上述命令会立即启动一个Ubuntu容器（这正是容器的魅力所在！），并为你提供容器里面的外壳提示符。这时候，你应该能够访问沙盒环境里面的标准的Ubuntu操作系统了。
想退出Docker容器，在容器里面的提示符处键入“exit”。
你可以启动不同形式的容器。比如，想启动Fedora容器，请执行下面这个命令：
$ docker.io run -i -t fedora /bin/bash
如果本地没有Fedora Docker映像文件，该命令就会首先自动下载映像文件，然后启动Docker。
如果你想启动采用某个发行版版本的容器，也可以这么做。比如说，想启动Ubuntu 13.04 Docker，请执行下面这个命令：
$ docker.io run -i -t ubuntu:13.04 /bin/bash
容器网络
Docker使用Linux网桥将容器彼此互联起来，并将它们连接到外部网络。安装了Docker后，你应该会看到默认情况下自动组建的docker0 Linux网桥。你创建的每个容器都将连接到docker0网桥接口。
自定义Linux网桥
如果你想，也可以使用自定义Linux网桥将诸容器互联起来。为此，你可以建立一个自定义网桥，并对它进行配置，如下所示。你可以为该网桥分配一个单独的子网，并且从子网为Docker分配IP地址。我会使用10.0.0.0/24作为Docker子网。
$ sudo apt-get install bridge-utils
$ sudo brctl addbr br0
$ sudo ifconfig br0 10.0.0.1 netmask 255.255.255.0
想让Docker使用自定义网桥，将“-b=br0”添加到/etc/default/docker.io中的DOCKER_OPTS变量，然后重启Docker服务。
$ sudo service docker.io restart
至此，任何新的容器都会连接到br0，其IP地址会自动从10.0.0.0/24来分配。
其他定制
还有另外几种方法可以定制Docker的默认网络设置，主要是通过改动/etc/default/docker.io中的DOCKER_OPTS变量来实现。
“-dns 8.8.8.8 -dns 8.8.4.4”：指定容器使用的DNS服务器。
“-icc=false”：让诸容器彼此隔离开来。
故障排查
1. 运行docker.io命令时，你会遇到下面这个错误。
dial unix /var/run/docker.sock: no such file or directory（没有此类文件或目录）
出现这个错误，可能是由于Docker守护程序没在运行。检查Docker守护程序的状态，确保先启动它。
$ sudo service docker.io status
$ sudo service docker.io start
‘玖’ docker相当于一个Linux上虚拟机吗可以在docker上放置网站，提供外部访问吗
当前，Docker内部使用的是Linux容器技术（LXC），这是运行在与它的宿主机器同样的操作系统上。这准许它可以和宿主机器共享许多系统资源。它也会使用AuFS作为文件系统，也为你管理网络。
AuFS是一个层状的文件系统，因此你可以有一个只读部分和一个只写部分，然后将二者组合起来。你可以使系统的共同的部分用作只读，那块是被所有容器共享，并且给每个容器自己的可写区域
Mitisky
翻译于 3年前
3人顶
顶 翻译得不错哦！
好吧，让我们假设你有一个容器镜像（image）容量是1GB，如果你想用一个完整的虚拟机来装载，你得需要容量的大小是1GB乘上你需要虚拟机的数量。但使用Linux容器虚拟化技术（LXC）和AuFS，你可以共享1GB容量，如果你需要1000个容器，假设他们都运行在同样的系统影像上，你仍然可以用稍微比1GB多一点的空间来给容器系统，
一个完整的虚拟化系统得到了分给它的自有全部资源，只有最小的共享。你获得了更多的隔离，但是这是很庞大的（需要更多的资源）
使用Linux容器虚拟化技术（LXC），隔离性方面有所缺失，但是他们更加轻量，而且需要更少资源。所以你可以轻松运行1000个容器在一个宿主机器上，甚至眼都不眨。试着用Xen来实现那个，我想除非你有一个超级强大的主机，不然我看是不可能的了
Mitisky
翻译于 3年前
2人顶
顶 翻译得不错哦！
一个完整的虚拟系统通常得用几分钟去启动，linux容器虚拟技术（LXC）只要数秒，甚至有时时间更短。
对于每种虚拟系统都有反对者和支持者。如果你希望一个完全隔离的和资源有保障的环境，那么完全的虚拟机是你的选择。如果你只希望进程之间相互隔离，并且希望大量运行他们在一个合理大小的宿主机器上。那么linux容器虚拟技术（LXC）是你的选择。