背景

目前很多公司都在使用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，没有使用交换机提供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初始化设置

 
添加仓库节点

 
添加节点

 
前台登陆

 
编写dockerfile创建镜像


 
把现有容器打包成镜像

 
创建容器

关于怎么用django+uwsgi发布网站这里就不叙述了

由于各种原因项目中途GAMEOVE了,没有具体的需求，不知道如何往下写了，有兴趣的朋友可以参考一下[/quote]

   
    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是什么

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: Centos7

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参数可以看到所有创建的容器：

[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
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 是一个轻量级的应用容器。和常见的虚拟机类似，但是和虚拟机相比，资源消耗更低。并且，使用和 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/）。

翻译原文链接：https://henduan.com/xXoHn

kubekey简介

kubeykey是KubeSphere基于Go 语言开发的kubernetes集群部署工具，使用 KubeKey，您可以轻松、高效、灵活地单独或整体安装 Kubernetes 和 KubeSphere。

KubeKey可以用于以下三种安装场景：

• 仅安装 Kubernetes集群
• 使用一个命令安装 Kubernetes 和 KubeSphere
• 已有Kubernetes集群，使用ks-installer 在其上部署 KubeSphere

项目地址：https://github.com/kubesphere/kubekey 开源公司：青云

kubekey安装

下载kk二进制部署命令，您可以在任意节点下载该工具，比如准备一个部署节点，或者复用集群中已有节点：

wget https://github.com/kubesphere/kubekey/releases/download/v1.2.0-alpha.2/kubekey-v1.2.0-alpha.2-linux-amd64.tar.gz

tar -zxvf kubekey-v1.2.0-alpha.2-linux-amd64.tar.gz

mv kk /usr/local/bin/

脚本下载安装:

export KKZONE=cn

curl -sfL  | VERSION=v1.1.0 sh -

mv kk /usr/local/bin/

查看版本:

kk version

在所有节点上安装相关依赖

yum install -y socat conntrack ebtables ipset

所有节点关闭selinux和firewalld

setenforce 0 && sed -i 's/^SELINUX=enforcing$/SELINUX=disabled/' /etc/selinux/config

systemctl disable --now firewalld

所有节点时间同步

yum install -y chrony

systemctl enable --now chronyd

timedatectl set-timezone Asia/Shanghai

节点无需配置主机名，kubekey会自动纠正主机名。

部署单节点集群

部署单节点kubernetes

kk create cluster

同时部署kubernetes和kubesphere，可指定kubernetes版本或kubesphere版本

kk create cluster --with-kubernetes v1.20.4 --with-kubesphere v3.1.0

当指定安装KubeSphere时，要求集群中有可用的持久化存储。默认使用localVolume，如果需要使用其他持久化存储，请参阅addons配置。

部署多节点集群

准备6个节点，部署高可用kubernetes集群，kubekey的高可用实现目前是基于haproxy的本地负载均衡模式。

创建示例配置文件：

kk create config

根据您的环境修改配置文件config-sample.yaml，以下示例以部署3个master节点和3个node节点为例(不执行kubesphere部署，仅搭建kubernetes集群)：

cat > config-sample.yaml <

使用配置文件创建集群

export KKZONE=cn

kk create cluster -f config-sample.yaml | tee kk.log

创建完成后查看节点状态

[root@kube-master1 ~]# kubectl get nodes -o wide

NAME          STATUS   ROLES                  AGE     VERSION   INTERNAL-IP     EXTERNAL-IP   OS-IMAGE                KERNEL-VERSION           CONTAINER-RUNTIME

kube-master1   Ready    control-plane,master   4m58s   v1.20.6   192.168.93.60   CentOS Linux 7 (Core)   3.10.0-1127.el7.x86_64   

kube-master2   Ready    control-plane,master   3m58s   v1.20.6   192.168.93.61   CentOS Linux 7 (Core)   3.10.0-1127.el7.x86_64   

kube-master3   Ready    control-plane,master   3m58s   v1.20.6   192.168.93.62   CentOS Linux 7 (Core)   3.10.0-1127.el7.x86_64   

kube-node1     Ready    worker                 4m13s   v1.20.6   192.168.93.63   CentOS Linux 7 (Core)   3.10.0-1127.el7.x86_64   

kube-node2     Ready    worker                 3m59s   v1.20.6   192.168.93.64   CentOS Linux 7 (Core)   3.10.0-1127.el7.x86_64   

kube-node3     Ready    worker                 3m59s   v1.20.6   192.168.93.65   CentOS Linux 7 (Core)   3.10.0-1127.el7.x86_64   

查看所有pod状态

[root@kube-master1 ~]# kubectl get pods -A

NAMESPACE     NAME                                       READY   STATUS    RESTARTS   AGE

kube-system   calico-kube-controllers-8545b68dd4-rbshc   1/1     Running   2          3m48s

kube-system   calico-node-5k7b5                          1/1     Running   1          3m48s

kube-system   calico-node-6cv8z                          1/1     Running   1          3m48s

kube-system   calico-node-8rbjs                          1/1     Running   0          3m48s

kube-system   calico-node-d6wkc                          1/1     Running   0          3m48s

kube-system   calico-node-q8qp8                          1/1     Running   0          3m48s

kube-system   calico-node-rvqpj                          1/1     Running   0          3m48s

kube-system   coredns-7f87749d6c-66wqb                   1/1     Running   0          4m58s

kube-system   coredns-7f87749d6c-htqww                   1/1     Running   0          4m58s

kube-system   haproxy-kube-node1                          1/1     Running   0          4m3s

kube-system   haproxy-kube-node2                          1/1     Running   0          4m3s

kube-system   haproxy-kube-node3                          1/1     Running   0          2m47s

kube-system   kube-apiserver-kube-master1                 1/1     Running   0          5m13s

kube-system   kube-apiserver-kube-master2                 1/1     Running   0          4m10s

kube-system   kube-apiserver-kube-master3                 1/1     Running   0          4m16s

kube-system   kube-controller-manager-kube-master1        1/1     Running   0          5m13s

kube-system   kube-controller-manager-kube-master2        1/1     Running   0          4m10s

kube-system   kube-controller-manager-kube-master3        1/1     Running   0          4m16s

kube-system   kube-proxy-2t5l6                           1/1     Running   0          3m55s

kube-system   kube-proxy-b8q6g                           1/1     Running   0          3m56s

kube-system   kube-proxy-dsz5g                           1/1     Running   0          3m55s

kube-system   kube-proxy-g2gxz                           1/1     Running   0          3m55s

kube-system   kube-proxy-p6gb7                           1/1     Running   0          3m57s

kube-system   kube-proxy-q44jp                           1/1     Running   0          3m56s

kube-system   kube-scheduler-kube-master1                 1/1     Running   0          5m13s

kube-system   kube-scheduler-kube-master2                 1/1     Running   0          4m10s

kube-system   kube-scheduler-kube-master3                 1/1     Running   0          4m16s

kube-system   nodelocaldns-l958t                         1/1     Running   0          4m19s

kube-system   nodelocaldns-n7vkn                         1/1     Running   0          4m18s

kube-system   nodelocaldns-q6wjc                         1/1     Running   0          4m33s

kube-system   nodelocaldns-sfmcc                         1/1     Running   0          4m58s

kube-system   nodelocaldns-tvdbh                         1/1     Running   0          4m18s

kube-system   nodelocaldns-vg5t7                         1/1     Running   0          4m19s

kubekey集群维护

添加节点

kk add nodes -f config-sample.yaml

删除节点

kk delete node  -f config-sample.yaml

删除集群

kk delete cluster

kk delete cluster [-f config-sample.yaml]

集群升级

kk upgrade [--with-kubernetes version] [--with-kubesphere version]

kk upgrade [--with-kubernetes version] [--with-kubesphere version] [(-f | --file) path]

下面让我们看看一个Docker容器它启动过程中，背后到底做了什么？

docker run -i -t ubuntu /bin/bash

输入上面这行命令，启动一个ubuntu容器时，到底发生了什么？
 
大致过程可以用下图描述：

首先系统要有一个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网站）去联网下载，下载回来后，再进行装载到容器的动作，即下图所示：

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

原文地址：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的情况，导致服务启动失败，具体情况如下：


问题原因及解决办法：
原因是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: 

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网络
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

测试维度

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

测试指标

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

参测产品

厂商功能对比

1、DevOps

2、微服务

3、容器化

4、持续交付

5、混合云

总结

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

基于最近对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

今天是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的历史和现状分析

曾经我们都在做一个称之为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 ProjectDocker生态圈 

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相关的核心技术之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的版本容器镜像能力。每个新版本都是一个与之前版本的简单差异改动, 有效地保持镜像文件最小化。但,这也意味着你总是要有一个记录该容器从一个版本到另一个版本改动的审计跟踪。

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 

不可变基础设施（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，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，没有使用交换机提供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初始化设置

 
添加仓库节点

 
添加节点

 
前台登陆

 
编写dockerfile创建镜像


 
把现有容器打包成镜像

 
创建容器

关于怎么用django+uwsgi发布网站这里就不叙述了

由于各种原因项目中途GAMEOVE了,没有具体的需求，不知道如何往下写了，有兴趣的朋友可以参考一下[/quote]