suse编译安装docker

‘壹’ 请教，如何在ubuntu环境下编译Docker的安装文件

Docker 的基本用法
在本节中，我将向您介绍 Docker 命令的常用选项。例如如何下载一个 docker image，打造一个容器，以及如何访问容器。
要创建一个新的容器，你应该选择一个基本 image 的操作系统，例如启动 Ubuntu 或者 CentOS 或其他系统。您可以搜索一个基本 image 使用 Docker 搜索命令：
docker search ubuntu
该命令将显示所有 ubuntu images，你可以自己尝试一下搜索 centos Images。

现在我们现在 base image到我们的服务中，使用命令：
docker pull ubuntu

现在，您可以通过使用命令来查看所有已下载的images：
docker images

Ubuntu 镜像从DockerHub/Docker Registry下载。下一步骤是创建从该镜像的容器。
要创建容器，可以使用docker create 或 docker run
docker create ubuntu:14.04
docker create 命令会创建一个新的容器，但不会启动它。所以现在你需要使用运行命令：
docker run -i -t ubuntu:14.04 /bin/bash
此命令将创建并运行一个基于 Ubuntu14.04 镜像的容器，容器内并运行一个命令/bin/bash，您将在容器内自动运行命令。

当你输入 Exit 命令退出容器时，容器也是停止运行，如果你想容器在后台运行需要在命令后面添加 -d 参数。
docker run -i -t -d ubuntu:14.04 /bin/sh -c “while true; do echo hello world; sleep 1; done”
/bin/sh -c “while true; do echo hello world; sleep 1; done” this is bash script to echo “hello word” forever.
现在你可以看到容器在后台运行通过命令：
docker ps
如果你想从 bash 命令看日志结果，使用命令：
docker logs NAMES/ContainerID

怎样在后台访问容器 shell？这个命令将会连接你的容器 shell：
docker exec -i -t NAMES/ContainerID

你可以看到主机名和容器ID是相等的，这意味着你在容器shell内。当你在shell 上键入’exit`，会离开的shell，但容器仍在运行。
你会经常使用的另一个命令是：
docker stop NAME/ContainerID
这将停止容器而不将其删除，这样你就可以用命令重新启动它：
docker start NAME/ContainerID
如果你想删除的容器，先停止它，然后用命令将其删除：
docker rm NAME/ContainerID

‘贰’ 如何在"特殊"的网络环境下编译 Docker

由于 Docker 编译需要依赖于 Docker Daemon ，所以只能在 64 位的 linux 环境下先安装 Docker 程序，再从 Github 上克隆 Docker 的代码进行编译。
在 Docker 的目录下执行 make 命令将默认执行 Makefile 中 make binary 指令进行编译。
?

default: binary

all: build
$(DOCKER_RUN_DOCKER) hack/make.sh

binary: build
$(DOCKER_RUN_DOCKER) hack/make.sh binary

cross: build
$(DOCKER_RUN_DOCKER) hack/make.sh binary cross

从以上的 Makefile 可以看出，执行 make、make binary、make all 或 make cross 都可以得到可运行的 Docker 程序。
在 Mac OS 环境下使用 brew 的命令安装 Docker ，只能得到一个 docker client 的二进制程序，如果以 daemon 的方式运行，会得到 ‘This is a client-only binary - running the Docker daemon is not supported.’ 的错误提示信息。
方法 1.
使用 VirtualBox 或者 VMWare Workstation 安装一个 Linux 的虚拟机。宿主机使用 VPN 等方案使网络“正常”访问各种“服务”，虚拟机网卡使用 NAT 模式。在 Linux 虚拟机内使用 make 进行编译 Docker 不会有任何网络问题。只是编译速度受限于 VPN 等网络解决方案，有可能等待时间很长。
方法 2.
Docker 每次发布新版本，都会在 docker-dev 的镜像仓库发布一个新的标签，这个镜像仓库包含了编译 Docker 镜像所依赖的所有环境，只需替换 Docker 代码目录下的 Dockerfile 即可实现编译 Docker 。
?

FROM docker.cn/docker/docker-dev:v1.2.0
VOLUME /var/lib/docker
WORKDIR /go/src/github.com/docker/docker
ENV DOCKER_BUILDTAGS apparmor selinux
ENTRYPOINT [“hack/dind”]
COPY . /go/src/github.com/docker/docker

Dockerfile 中只保留必要的步骤就可以实现编译了。

‘叁’ 超值一篇分享，Docker：从入门到实战过程全记录

作者 | 天元浪子

来源 | CSDN博客

想要真正理解Docker，就不得不从虚拟化技术的发展历程说起。普遍认为虚拟化技术经历了物理机时代、虚拟机时代，目前已经进入到了容器化时代。可以说，Docker是虚拟化技术不断发展的必然结果。

那么，什么是容器呢？容器和虚拟机有什么不同？Docker和容器又是什么关系呢？搞明白这几个问题，Docker的概念就清晰了。

1.1 虚拟机和容器

借助于VMWare等软件，可以在一台计算机上创建多个虚拟机，每个虚拟机都拥有独立的操作系统，可以各自独立的运行程序。这种分身术虽然隔离度高（操作系统级），使用方便（类似物理机），但占用存储资源多（GB级）、启动速度慢（分钟级）的缺点也是显而易见的。

相较于虚拟机，容器（Container）是一种轻量型的虚拟化技术，它虚拟的是最简运行环境（类似于沙盒）而非操作系统，启动速度快（秒级）、占用存储资源少（KB级或MB级），容器间隔离度为进程级。在一台计算机上可以运行上千个容器，这是容器技术对虚拟机的碾压式优势。

1.2 容器、镜像和Docker

Docker是一个开源的应用容器引擎，可以创建容器以及基于容器运行的程序。Docker可以让开发者打包他们的应用和依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。

听起来很简单，但是在Docker和容器之间，还隐藏着一个镜像的概念，令初学者颇感困惑。本质上，Docker镜像是一个特殊的文件系统，它提供容器运行时所需的程序、库、资源、配置等文件。Docker镜像类似于一个py文件，它需要Docker的运行时（类似于python解释器）运行。镜像被运行时，即创建了一个镜像的实例，一个实例就是一个容器。

1.3 Docker 和 k8s

作为容器引擎，Docker为容器化的应用程序提供了开放的标准，使得开发者可以用管理应用程序的方式来管理基础架构，实现快速交付、测试和部署代码。随着容器的大量使用，又产生了如何协调、调度和管理容器的问题，Docker的容器编排应运而生。

k8s是Google开源的一个容器编排引擎，它支持自动化部署、大规模可伸缩、应用容器化管理，是一个开源的，用于管理云平台中多个主机上的容器化的应用，k8s的目标是让部署容器化的应用简单并且高效，k8s提供了应用部署、规划、更新、维护的一种机制。

Docker和k8sr都是以containerd（容器化标准）作为运行时，因此使用Docker创建的镜像完全可以在k8s中无障碍的使用。

2.1 在ubuntu中安装

在linux系统中安装Docker非常简单，官方为我们提供了一键安装脚本。这个方法也适用于Debian或CentOS等发行版。

安装过程如果出现超时，不要灰心，多试几次，总会成功的。安装完成后，Docker只能被root用户使用，可以使用下面的命令取消权限限制：

然后，重启docker服务：

最后，关闭当前的命令行，重新打开新的命令行就可以了。

顺便提一下，如果在CentOS下安装，可能会出现一堆类似于下面的错误：

这是由于docker和Podman冲突造成的，需要先卸载Podman：

2.2 在Win10中安装

Docker的运行，依赖linux的环境，官方提供了Docker Desktop for Windows，但是它需要安装Hyper-V，Hyper-V是微软开发的虚拟机，类似于 VMWare 或 VirtualBox，仅适用于 Windows 10。这个虚拟机一旦启用，QEMU、VirtualBox 或 VMWare Workstation 15 及以下版本将无法使用！如果你必须在电脑上使用其他虚拟机（例如开发 Android 应用必须使用的模拟器），请不要使用 Hyper-V！

我的电脑是win10家庭版，不能直接安装hyper-v，需要将下面的命令保存到cmd文件中：

然后在cmd文件上点击右键，选择使用管理员运行。执行完毕后会重启，在重启的过程中进行安装。

2.3 Hello world

docker服务启动的情况下，运行下面的命令：

此命令的含义是：

第一次运行时，因为本地没有ubuntu:20.04镜像，docker会自动从镜像服务器下载。下载过程可能需要多试几次，只要成功一次，以后执行就不再需要下载了。

docker官方还提供了一个hello-world镜像，可以直接运行：

此命令省略了镜像版本和运行参数，docker使用latest作为版本，即最新版本。

从hello world的例子中，也可以体验到，docker实例的运行是非常快的。

docker官方的镜像库比较慢，在进行镜像操作之前，需要将镜像源设置为国内的站点。

新建文件/etc/docker/daemon.json，输入如下内容：

然后重启docker的服务：

3.1 列出本地所有镜像

执行命令 docker images 可以查看

当前我本地只有刚才安装的两个镜像。

3.2 从镜像库中查找镜像

执行命令 docker search 镜像名称可以从docker镜像库中查找镜像。

最好选择官方（OFFICIAL）的镜像，这样的镜像最稳定一些。

3.3 下载新的镜像

执行命令docker pull 镜像名称:版本号即可下载新的镜像。

镜像下载后，就可以使用镜像来创建容器了。

4.1 启动容器

执行命令docker run即可启动容器，也就是创建某个镜像的实例。docker run命令非常复杂，可以先执行一个docker run --help来查看帮助：

比如我们要执行python的shell，需要添加-it参数，即：docker run -it python:3.8

4.2 将宿主机的文件挂载到容器

docker容器与宿主机是隔离的，要想让容器内的程序能访问宿主机上的文件，需要通过-v参数将宿主机的文件挂载到容器中。

比如我们在宿主机上有一个hello.py，可以打印hello，想要在python容器中执行，就需要进行挂载。-v后还需要接两个参数，分别是宿主机的目录和容器内的目录，两者使用:分隔，路径必须都是绝对路径。

我的hello.py保存在主目录的/docker_test目录中，将这个目录挂载到容器的/docker_test目录，然后在容器内执行python /docker_test/hello.py：

4.3 容器的端口映射

我们修改一下hello.py，创建一个socket服务端，并监听5000端口，当有客户端连接时，打印客户端的地址，先客户端发送hello，然后关闭连接：

在容器内执行：

接下来，尝试用telnet命令连接，结果却是失败的。原因是，127.0.0.1是宿主机的ip地址，5000是容器的端口，这与我们的习惯稍微有些不同。事实上，docker的容器是非常轻量的，它并没有自己的网络，要想访问容器的端口，需要进行端口映射，将容器的某端口映射到宿主机的端口，客户端连接时，只要与宿主机的端口进行连接就可以了。

需要注意的是，上面的代码创建的服务器，无论如何也不可能被客户端连接，因为代码中绑定了127.0.0.1的ip，在容器中运行时，需要绑定所有ip，即0.0.0.0。

然后，再使用-p参数，-p还需要三个参数，即宿主机的ip地址、宿主机的端口、容器的端口，三者之间使用:分隔。一般的，可以将宿主机的ip地址省略，只写宿主机的端口：容器的端口即可。

这样，就将容器的5000端口映射到了宿主机的5001端口，使用：

即可与容器中的服务器进行连接。

4.4 容器管理

上面的服务运行之后，可以使用docker ps命令，查看运行中的容器：

显示的内容有下面几列：

要想结束容器，可以使用docker kill 容器ID命令。

一般而言，当我们的程序开发完成后，会连同程序文件与运行环境一起制作成一个新的镜像。

要制作镜像，需要编写Dockerfile。DockeFile由多个命令组成，常用的命令有：

注意，Docker镜像中有一个层的概念，每执行一个RUN命令，就会创建一个层，层过多会导致镜像文件体积增大。尽量在RUN命令中使用&&连接多条shell命令，减少RUN命令的个数，可以有效减小镜像文件的体积。

5.1 自制显示文本文件内容镜像

编写cat.py，接收一个文件名，由python读取文件并显示文件的内容：

这个例子比较简单，缩写Dockerfile如下：

这个Dockerfile的含义是：

需要说明的是，ENTRYPOINT有两种写法：

这里采用第二种写法，是因为我们要在外部给容器传递参数。执行命令编译Docker镜像：

这个命令中，-t的含义是目标，即生成的镜像名为hello，版本号为1.0，别忘了最后那个.，这叫到上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。

这样，我们的第一个镜像就制作完成了，使用下面的命令执行它：

即可看到~/docker_test/cat/files/test.txt的内容。

5.2 自制web服务器镜像

我们使用tornado开发一个网站，而python的官方镜像是没有tornado库的，这就需要在制作镜像时进行安装。

测试的ws.py如下：

编写Dockerfile文件如下：

在此我们验证一下CMD与ENTRYPOINT的区别。在Dockerfile所在有目录下执行如下命令：

执行完成后，再使用docker images使用就可以看到生成的镜像了，然后使用下面的命令运行：

在浏览器中输入宿主机的ip和8000端口，就可以看到页面了。

在这个例子中，我使用的运行命令是CMD，如果在docker run中指定的其他的命令，此命令就不会被执行，如：

此时，容器中被执行的是python命令，而不是我们的服务。在更多情况下，我们希望在docker run命令中为我们的服务传参，而不是覆盖执行命令，那么，我们应该使用ENTRYPOINT而不是CMD：

上面这种写法，是不支持传递参数的，ENTRYPOINT和CMD还支持另一种写法：

使用这种写法，docker run命令中的参数才可以传递给hello.py：

这个命令中，--port=9000被作为参数传递到hello.py中，因此容器内的端口就成了9000。

在生产环境中运行时，不会使用-it选项，而是使用-d选项，让容器在后台运行：

这种方式下，即使当前的控制台被关闭，该容器也不会停止。

5.3 自制apscheler服务镜像

接下来，制作一个使用apscheler编写的服务镜像，代码如下：

Dockerfile也是信手拈来：

生成镜像：

应该可以运行了，文件复制需要两个目录，在运行时，可以使用两次-v来挂载不同的目录：

前面用到的官方python镜像大小足足882MB，在这个基础上，再安装用到的第三方库，添加项目需要的图片等资源，大小很容易就超过1个G，这么大的镜像，网络传给客户非常的不方便，因此，减小镜像的体积是非常必要的工作。

docker hub上有个一python:3.8-alpine镜像，大小只有44.5MB。之所以小，是因为alpine是一个采用了busybox架构的操作系统，一般用于嵌入式应用。我尝试使用这个镜像，发现安装一般的库还好，但如果想安装numpy等就会困难重重，甚至网上都找不到解决方案。

还是很回到基本的路线上来，主流的操作系统镜像，ubuntu的大小为72.9MB，centos的大小为209MB——这也算是我更喜欢使用ubuntu的一个重要原因吧！使用ubuntu作为基础镜像，安装python后的大小为139MB，再安装pip后的大小一下子上升到了407MB，要是再安装点其他东西，很容易就赶上或超过python官方镜像的大小了。

看来，寻常路线是很难压缩镜像文件体积了。幸好，还有一条曲线救国的路可走，这就是多阶段构建法。

多阶段构建的思想其实很简单，先构建一个大而全的镜像，然后只把镜像中有用的部分拿出来，放在一个新的镜像里。在我们的场景下，pip只在构建镜像的过程中需要，而对运行我们的程序却一点用处也没有。我们只需要安装pip，再用pip安装第三方库，然后将第三方库从这个镜像中复制到一个只有python，没有pip的镜像中，这样，pip占用的268MB空间就可以被节省出来了。

1、在ubuntu镜像的基础上安装python：

然后运行：

这样，就生成了python:3.8-ubuntu镜像。

2、在python:3.8-ubuntu的基础上安装pip：

然后运行：

这样，就生成了python:3.8-ubuntu-pip镜像。

3、多阶段构建目标镜像：

这个dockerfile需要解释一下了，因为它有两个FROM命令。

第一个是以python:3.8-ubuntu-pip镜像为基础，安装numpy，当然，在实际应用中，把所有用到的第三方库出写在这里。

第二个FROM是以FROM python:3.8-ubuntu镜像为基础，将第三方库统统复制过来，COPY命令后的–from=0的意思是从第0阶段进行复制。实际应用中再从上下文中复制程序代码，添加需要的ENTRYPOINT等。

最后，再运行：

这然，用于我们项目的镜像就做好了。比使用官方python镜像构建的版本，小了大约750MB。

到此，我们的镜像已经制作好了，可是，镜像文件在哪，如何在生产环境下运行呢？

刚才使用docker images命令时，已经看到了生成的镜像：

我们可以使用docker save命令将镜像保存到指定的文件中，保存的文件是一个.tar格式的压缩文件：

将hello.tar复制到生产环境的机器上，然后执行导入命令：

就可以使用了。

‘肆’ 怎样制作docker基础镜像 suse

初次安装部署好docker后,大多数镜像可以从DockerHub 提取,但是大多数人都希望自己可以完全自定义一个镜像,那么这里需要一个第三方工具 febootstrap epel6的源提供febootstrap的RPM包 yum install docker-io febootstrap -y service docker start。

‘伍’ 如何编译docker 1.2.0版本的源码

经过研究docker的官方编译脚步，发现本地编译也很简单，只需要在docker源码的目录下执行如下命令即可：
./hack/make.sh binary
上面这条命令就只会生成docker的二进制文件，不过肯定不会这么顺利的，执行这个命令你就会发现错误。如果第一次执行报的错误应该是找不到相应的go依赖包。那么现在就开始解决第一个问题，go依赖包。
解决go依赖包最直接的方法就一个一个去github或者其他地方去下载到本地，但是这样做很麻烦，docker依赖的go语言包很多，然后依赖包可能又依赖其他包。这里有一个简单实用的办法，也是go语言管理项目的方便之处。通过go get命令来自动下载，例如发现报错的是docker某一个目录下的依赖包，那么可以如下执行：
go get -v ./src/github.com/docker/docker/...
这条命令执行以后整个docker目录下源文件依赖的包都会被自动下载。如果发现其他目录下源文件也报同样的错误，可以按照次方法解决。不过这里需要强调一点， 这些下载都是会下载最新的包，如果编译老的docker肯定会出问题 ，如果编译最新的docker代码肯定不会有问题，因为官方的编译是这种方式。
上面执行的命令都是建立在go语言环境建立成功的基础上，我安装的go遇到是1.3.3版本的，采用源码方式安装。安装在/export/servers/go下面，然后所有的go语言工程源码目录放在 /export/servers/gopath。然后配置环境变量在用户的根目录下的.bashrc文件里面如下：
export GOPATH=/export/servers/gopath
export GOROOT=/export/servers/go
export GOARCH=amd64
export GOOS=linux
然后docker的代码目录如下：/export/servers/gopath/src/github.com/docker/docker。这样才能在gopath下面进行依赖包的下载。通过上面的方法把所有依赖包下载完以后就可以进行编译了。
在继续编译的过程中还会遇到缺少c语言依赖包缺少的问题，主要有三个，（1）sqlite3;（2）device-mapper;（3）btrfs.
第一个sqlite3可以使用如下命令安装依赖：yum install sqlite-devel.x86_64

‘陆’ 怎么安装suse系统

准备工具：

默认安装vmware12pro虚拟机软件，可以在本站下载。

下载opensuse42.3系统镜像，5分享--》镜像--》linux下载系统。

开始新建虚拟机

分配处理器，然后下一步。

分配内存。带桌面的最少1G，不带桌面可以分配512M。

创建给虚拟机的硬盘。

参考：网页链接

‘柒’ 如何在 CentOS 7 上安装 Docker

在编译docker代码之前肯定需要研究一下docker的代码结构以及官方推荐的方式，因为docker是开源的，所以很多第三方开发者参与。那么官方肯定会给出开发环境搭建的文档，所以拿到代码肯定先研究官方的编译方法。通过文档和代码了解到docker官方推荐的是在docker本身的容器里面搭建环境和编译，官方给出的是一个基于ubuntu的dockerfile。不过正是这个dockerfile可以清楚的知道需要为了编译准备哪些依赖环境，为我们后面自己编译提供了环境搭建的基础。然后就尝试了官方的编译方案，结果各种网络问题导致编译通不过，当然网上也有相应的解决方案，基本上就是替换一些依赖源（国外的被墙了）。但是就算编译通过了也只是一个基于ubuntu的二进制文件，只能在ubuntu的相应的系统上运行。我们需要的是一个可以在centos7上运行的二进制文件，关键要搭建一个可以持续开发和编译测试的环境。当然也可以制作一个centos7的dockerfile文件，对照着官方的ubuntu的dockerfile也很简单。但是这些都是还需要有一个前提，就是需要先安装一个以前版本的docker来启动这个环境涩，好处也是杠杠的，可以在任何一台能够运行docker的系统上进行开发和测试，而且可以进行持续集成。不过对于我们来说能够编译出一个稳定运行在centos7上的二进制文件即可，所以就尝试直接在本地进行编译，而不是通过docker的容器进行。
经过研究docker的官方编译脚步，发现本地编译也很简单，只需要在docker源码的目录下执行如下命令即可：

./hack/make.sh binary

上面这条命令就只会生成docker的二进制文件，不过肯定不会这么顺利的，执行这个命令你就会发现错误。如果第一次执行报的错误应该是找不到相应的go依赖包。那么现在就开始解决第一个问题，go依赖包。
解决go依赖包最直接的方法就一个一个去github或者其他地方去下载到本地，但是这样做很麻烦，docker依赖的go语言包很多，然后依赖包可能又依赖其他包。这里有一个简单实用的办法，也是go语言管理项目的方便之处。通过go get命令来自动下载，例如发现报错的是docker某一个目录下的依赖包，那么可以如下执行：

go get -v ./src/github.com/docker/docker/...

这条命令执行以后整个docker目录下源文件依赖的包都会被自动下载。如果发现其他目录下源文件也报同样的错误，可以按照次方法解决。不过这里需要强调一点，这些下载都是会下载最新的包，如果编译老的docker肯定会出问题，如果编译最新的docker代码肯定不会有问题，因为官方的编译是这种方式。
上面执行的命令都是建立在go语言环境建立成功的基础上，我安装的go遇到是1.3.3版本的，采用源码方式安装。安装在/export/servers/go下面，然后所有的go语言工程源码目录放在/export/servers/gopath。然后配置环境变量在用户的根目录下的.bashrc文件里面如下：

export GOPATH=/export/servers/gopath
export GOROOT=/export/servers/go
export GOARCH=amd64
export GOOS=linux

然后docker的代码目录如下：/export/servers/gopath/src/github.com/docker/docker。这样才能在gopath下面进行依赖包的下载。通过上面的方法把所有依赖包下载完以后就可以进行编译了。
在继续编译的过程中还会遇到缺少c语言依赖包缺少的问题，主要有三个，（1）sqlite3;（2）device-mapper;（3）btrfs.
第一个sqlite3可以使用如下命令安装依赖：yum install sqlite-devel.x86_64
第二个在官方的dockerfile文件里面有解决方案，执行如下命令：

git clone --no-checkout https://git.fedorahosted.org/git/lvm2.git /usr/local/lvm2 && cd /usr/local/lvm2 && git checkout -q v2_02_103

cd /usr/local/lvm2 && ./configure --enable-static_link && make device-mapper && make install_device-mapper

第三个btrfs使用如下安装依赖： yum install btrfs-progs。
这些依赖都解决了就继续编译，这个时候可能会出现ld连接错误，提示找不到库。因为docker编译的方式完全是static，所以所有依赖的库必须还要有相应的静态库（.a），而不是动态库(.so)。刚才通过yum install sqlite-devel.x86_64安装了sqlite3的依赖，但是最后发现里面没有静态库，所以编译ld的时候出错了。我的解决办法就是重新到sqlite3的官方网站下载了源码包，然后编译安装即可。
编译完成以后，就会在docker源码目录下的bundles/1.3.1/binary/目录有如下文件：
docker docker-1.3.1 docker-1.3.1.md5 docker-1.3.1.sha256
docker-1.3.1这个文件就是我们需要的二进制文件了，docker是一个软连接到docker-1.3.1的文件。
到此就成功完成编译了，以后修改了代码重新支持编译脚步即可：

./hack/make.sh binary

‘捌’ 如何编译Docker源码

本文根据docker官方给出的docker代码编译环境搭建指南做更深入的分析。官方给出的指导比较简单，但是由于国内的网络问题经常会编译失败，了解了编译步骤后，也可以结合自身遇到的网络问题进行“规避”。
docker的编译环境实际上是创建一个docker容器，在容器中对代码进行编译。 如果想快速的查看编译环境搭建指导，而不关注环境搭建的机制和细节，可以直接跳到最后一章“总结”。

前提
机器上已经安装了docker，因为编译环境是个docker容器，所以要事先有docker（daemon），后面会创建个编译环境容器，在容器里面编译代码。本文中使用物理机，物理机上运行着docker （daemon）。
机器（物理机）上安装了git 。 后续使用git下载docker源码
机器（物理机）上安装了make。
下载ubuntu 14.04的docker镜像

下载docker源码
git clone
会把代码下载到当前目录下，后面会把代码拷贝到容器中。

编译前分析
官方给的编译方法是make build 和 make binary等。下面先分析Makefile，看懂Makefile后，编译环境的准备流程就比较清楚了。

Makefile
在下载的docker源码中可以看到它的Makefile，Makefile中比较关键的几个参数：
DOCKER_MOUNT := $(if $(BIND_DIR),-v "$(CURDIR)/$(BIND_DIR):/go/src/github.com/docker/docker/$(BIND_DIR)") DOCKER_MOUNT 表示创建容器时的mount参数。因为编译环境是一个容器，在后续的步骤中启动容器时使用DOCKER_MOUNT参数，会将物理机上的目录mount给容器容器，容器中该目录是编译生成docker二进制文件的目录。
DOCKER_FLAGS := docker run --rm -i --privileged $(DOCKER_ENVS) $(DOCKER_MOUNT) 这是后面创建docker容器时的命令行的一部分，其中包含了前面的DOCKER_MOUNT参数。
DOCKER_IMAGE := docker-dev$(if $(GIT_BRANCH),:$(GIT_BRANCH)) 这是docker image参数，镜像的名字是docker-dev，以当前git中docker版本作为tag名。这个镜像是在make build一步做出来的。
DOCKER_RUN_DOCKER := $(DOCKER_FLAGS) "$(DOCKER_IMAGE)" 创建docker容器的命令行，组合了前面的DOCKER_FLAGS 和 DOCKER_IMAGE 。 从命令行中可以看出，启动容器使用的参数有 --rm -i --privileged，使用了一些环境变量，还有使用了-v参数把物理机上目录mount给容器，在容器中编译好二进制文件后放到该目录中，在物理机上就能获得docker二进制文件。启动的的docker 容器镜像名字是docker-dev。下文会介绍docker-dev镜像是怎么来的。
由于官方给出的“构建编译环境”的方法是执行 make build，下面在Makefile中看到build分支是这样的：

make build时会调用 docker build -t "$(DOCKER_IMAGE)" . 去制作一个叫做DOCKER_IMAGE的镜像。
进行源码编译的方式是执行 make binary来编译代码，在Makefile中make binary的分支如下：

make binary除了进行 make build以外，会执行$(DOCKER_RUN_DOCKER)，即上文提到的docker run命令行。由于执行过了build，会build出来docker-dev镜像，所以在docker run时直接使用前面build出来的镜像。docker run时的命令行参数是hack/make.sh binary。make binary的过程实际上是创建一个容器，在容器中执行hack/make.sh binary脚本。接下来会详细介绍make build和make binary所做的内容。
make build
根据官方的指导，先执行make build来搭建编译环境。上面分析了，make build实际上是制作了一个镜像，这个镜像里会包含编译代码所需的环境。下面来介绍下这个镜像。

Dockerfile
在和Makefile相同的目录下（源码的根目录），有Dockerfile。执行make build 相当于调用docker build，使用的就是该Dockerfile。Dockerfile中的几个主要步骤（有些步骤这里略过）：
FROM ubuntu:14.04 使用ubuntu 14.04作为基础镜像；在宿主机上，要事先下载好ubuntu 14.04镜像。
安装一些编译需要的软件；
用git下载lvm2源码，并编译安装；
下载并安装GO 1.5.1；
安装GO相关的tools 可以做code coverage test 、 go lint等代码检查
安装registry和notary server；
安装docker-py 后面跑集成测试用的
将物理机的contrib/download-frozen-image.sh 脚本拷贝到镜像中/go/src/github.com/docker/docker/contrib/
运行contrib/download-frozen-image.sh 制作镜像 实际上这一步只是下载了3个镜像的tar文件。注意：docker build相当于创建一个临时的容器（在临时的容器中执行Dockerfile中的每一步，最后在保存成镜像），“运行contrib/download-frozen-image.sh 制作镜像”这个动作出现在Dockerfile中，相当于在docker build所创建的临时的容器中下载docker镜像，有docker-in-docker容器嵌套的概念。下一小节会对download-frozen-image.sh脚本做详细分析。
ENTRYPOINT ["hack/dind"] 做出来的镜像，使用它启动的容器可以自动运行源码目录中的hack/dind脚本。 dind这个脚本是a wrapper script which allows docker to be run inside a docker container 。后面的小节会对hack/dind脚本做详细的分析。
COPY . /go/src/github.com/docker/docker 把物理机上的docker源码文件打入到镜像中
download-frozen-image.sh脚本
上一小节里提到，在Dockerfile中，有一步会调用contrib/download-frozen-image.sh ，它主要作用是下载3个镜像的tar包，供后续docker load。在Dockerfile中的调用方式如下：

download-frozen-image.sh脚本中会依次解析参数，其中/docker-frozen-images作为base dir，后面下载的东西全放到这里。之后的3个参数是镜像，里面包含了镜像名（例如busybox）、镜像tag（例如latest）、镜像id（例如），后面会在循环中依次下载这3个镜像的tar文件。
download-frozen-image.sh脚本中会通过curl从registry上获取如下信息：
token：获取token，后面curl获取的其他信息时都需要使用token。例如本例中 token='signature=,repository="library/busybox",access=read'
ancestryJson：把镜像相关联的历史层次的id也都获取到，因为每一层的tar都需要下载。本例中 ancestryJson='["", ""]'
这里可以看到这个镜像只有2层，两层的id这里都列了出来。 每个镜像包含的层数不同，例如。第三个镜像jess/unshare共有10层。
VERSION、json、tar: 每一层镜像id的目录下，都下载这3个文件，其中VERSION文件内容目前都是“1.0”，json文件是该层镜像的json文件，tar文件是该层镜像的真正内容，以.tar保存。
下载好的各层镜像目录结构如下：
$ls

$tree

hack/dind脚本
在Dockerfile中，ENTRYPOINT ["hack/dind"] ，表示在镜像启动后，运行该脚本，下面分析一下这个脚本的功能。
脚本在代码根目录下的hack目录中，作者对脚本的描述是 DinD: a wrapper script which allows docker to be run inside a docker container.
就是可以在docker容器中创建docker容器。它就做了一个事，那就是在容器中创建好cgroup目录，并把各个cgroup子系统mount上来。
为了方便理解，我们可以先看看物理机。在宿主机上如果创建docker容器，需要宿主机上必须事先mount cgroup子系统，因为cgroup是docker容器的一个依赖。同理docker-in-docker也要求外层的docker容器中有cgroup子系统，dind脚本在容器启动后，先去/proc/1/cgroup中获取cgroup子系统，然后依次使用mount命令，将cgroup mount上来，例如mount -n -t cgroup -o "cpuset" cgroup "/cgroup/cpuset"
最终在运行make build后，会制作出一个叫docker-dev的镜像。
make binary
执行make binary 就可以编译出docker二进制文件。编译出来的二进制文件在源码目录下的bundles/1.10.0-dev/binary/docker-1.10.0-dev ，其中还包含md5和sha256文件。

Makefile中的binary
Makefile中关于make binary流程是

先执行build，即上一节介绍的，制作docker-dev编译环境镜像。
再执行DOCKER_RUN_DOCKER，创建容器，DOCKER_RUN_DOCKER就是执行docker run，使用docker-dev镜像启动容器，并且会mount -v 将容器生成二进制文件的路径与宿主机共享。DOCKER_RUN_DOCKER在“编译前分析”一章中有介绍。启动的容器运行的命令行是 hack/make.sh binary 。docker run完整的形式如下：
docker run --rm -i --privileged -e BUILDFLAGS -e DOCKER_CLIENTONLY -e DOCKER_DEBUG -e DOCKER_EXECDRIVER -e DOCKER_EXPERIMENTAL -e DOCKER_REMAP_ROOT -e DOCKER_GRAPHDRIVER -e DOCKER_STORAGE_OPTS -e DOCKER_USERLANDPROXY -e TESTDIRS -e TESTFLAGS -e TIMEOUT -v "/home/mu/src/docker/docker/bundles:/go/src/github.com/docker/docker/bundles" -t "docker-dev:master" hack/make.sh binary
hack/make.sh脚本
上一节提到的make binary中创建的容器启动命令是hack/make.sh binary，运行容器中的（docker源码目录下的）hack/make.sh脚本，参数为binary。
make.sh中根据传入的参数组装后续编译用的flags（BUILDFLAGS），最后根据传入的参数依次调用 hack/make/目录下对应的脚本。例如我们的操作中传入的参数只有一个binary。那么在make.sh的最后，会调用hack/make/binary脚本。
hack/make/binary脚本中，就是直接调用go build进行编译了，其中会使用BUILDFLAGS LDFLAGS LDFLAGS_STATIC_DOCKER等编译选项。
如果最终生成的docker二进制文件不在bundles/1.10.0-dev/binary/目录下，那么可能是编译参数BINDDIR设置的不正确，可以在执行make binary时增加BINDDIR参数，例如
make BINDDIR=. binary , 将BINDDIR设置为当前目录。
总结
编译步骤总结：
1、编译前在物理机上安装好make、git，并下载好docker代码。下载好ubuntu:14.04镜像
2、执行make build 。这步执行完会在物理机上创建出一个docker-dev的镜像。
3、执行make binary 。 这步会使用docker-dev镜像启动一个容器，在容器中编译docker代码。编译完成后在物理机上直接可以看到二进制文件。默认二进制文件在 bundles/1.10.0-dev/binary/目录下
4、docker代码里有很多test，可以使用此套编译环境执行test，例如 make test 。 更多参数可以看Makefile
搭建环境心得：
1、在make build时，使用Dockerfile创建制作镜像，这个镜像有40多层，其中一层失败就会导致整个build过程失败。由于Dockerfile中很多步骤是要连到国外的网站去下载东西，很容易失败。好在docker build有cache机制，如果前面的层成功了，下次重新build时会使用cache跳过，节省了很多时间。所以如果make build中途失败（一般是由于国内连国外的网络原因），只要重新执行make build就会在上次失败的地方继续，多试几次可以成功。
2、如果其他人已经build出了docker-dev镜像，可以把它下载到自己的环境上。这样在自己make build时，会跳过那些已经在本地存在的层，可以节省时间。
3、每一次编译会自动删除掉前面已经生成的二进制文件，所以不用担心二进制文件不是最新的问题。

‘玖’ linux怎么安装docker

1 在 CentOS 6.4 上安装 docker
docker当前官方只支持Ubuntu，所以在 CentOS 安装Docker比较麻烦(Issue #172)。
docker官方文档说要求Linux kernel至少3.8以上，CentOS 6.4是2.6的内核，于是我哼哧哼哧的编译安装了最新的kernel 3.11.6，重启后运行docker还是失败，最后找到原因，是因为编译时忘记集成aufs模块了。aufs 需要和 kernel 一起编译，很麻烦。
不过不需要这么麻烦，有强人已经编译好了带aufs模块的内核，见这里Installing docker.io on centos 6.4 (64-bit)
1.1 取消selinux，因为它会干扰lxc的正常功能
sudo vim /etc/selinux/config
SELINUX=disabled
SELINUXTYPE=targeted

1.2 安装 Fedora EPEL
sudo yum install http://ftp.riken.jp/Linux/fedora/epel/6/x86_64/epel-release-6-8.noarch.rpm

1.3 添加 hop5 repo地址
cd /etc/yum.repos.d
sudo wget http://www.hop5.in/yum/el6/hop5.repo

1.4 安装 docker-io
sudo yum install docker-io

会自动安装带aufs模块的3.10内核，以及docker-io包。
1.5 将 cgroup 文件系统添加到 /etc/fstab , 只有这样docker才能正常工作
sudo echo "none /sys/fs/cgroup cgroup defaults 0 0" >> /etc/fstab

1.6 修改grub引导顺序
sudo vim /etc/grub.conf
default=0

设置default为新安装的内核的位置，一般是0
1.7 重启
sudo reboot

1.8 检查新内核是否引导成功
重启后，检查一下新内核是否引导起来了
uname -r
3.10.5-3.el6.x86_64

说明成功了
看一下 aufs是否存在
grep aufs /proc/filesystems
nodev aufs

说明存在
1.9 启动 docker daemon 进程
sudo docker -d &

如果你在公司，且公司内部都是通过代理上网，则可以把代理服务器告诉docker，用如下命令(参考这里)：
sudo HTTP_PROXY=http://xxx:port docker -d &

1.10 下载 ubuntu 镜像
sudo docker pull ubuntu

1.11 运行 hello world
sudo docker run ubuntu /bin/echo hello world
hello world

安装成功了！！

‘拾’ 如何在Linux上安装配置DockerUI

1、检查系统需求
Apache/Nginx
MySQL
php 5.5.9+
Composer
PHP扩展：OpenSSL、 PDO、Mbstring、Tokenizer、Fileinfo、GD（2.0+）/Imagick（6.5.7+）
系统满足上述需求后才能继续进行安装。
2、使用Composer安装项目和依赖
在web根目录下运行以下命令：
composer create-project pyrocms/pyrocms=3.0-beta1 --prefer-source

注意在Windows系统中这里我们不能使用--prefer-dist选项进行安装，否则会报错：
[ErrorException]
ZipArchive::extractTo(): No such file or directory

注：使用--prefer-source选项会强制克隆源代码，而不是像--prefer-dist那样强制下载git引用的压缩包。
Composer使用PHP的ZipArchive扩展压缩文件，使用--prefer-dist安装在Windows系统上存在一个问题：如果路径大于256个字符或者包含.会抛出上述错误异常，进而导致Composer不能继续往下运行。Linux上则不存在这个问题。
安装完成后，如果是在Linux环境需要配置storage、public/assets、bootstrap/cache目录的可写权限。
如果你觉得Composer安装麻烦还可以使用学院提供的一键安装包：PyroCMS 3.0测试版一键安装包。
3、在浏览器中完成安装和配置
在浏览器中导航到http://localhost/pyrocms/public，页面会自动跳转到安装界面http://localhost/pyrocms/public/installer，此时页面可能会出现错误页面，错误提示信息如下：
FatalErrorException in Container.php line 790:
Maximum function nesting level of '100' reached, aborting!

在Laravel中这并不是什么bug，只是因为安装了XDebug而PHP配置文件中xdebug.max_nesting_level对应值设置过低的缘故（默认为100），我们只需将其值设置为250（Homestead虚拟机中就是这么设置的）并重启web服务器即可。
注意第一次访问需要较长时间，这是因为要编译并加载前端资源的缘故。加载完成后，安装页面显示如下（部分截图）：

在该页面我们要填写数据库配置信息，管理员账户信息以及站点的一些通用配置。填写完成后点击“Save”按钮提交表单，然后进入安装进度页面，完成站点相关配置和初始化操作，以及基本模块和扩展的安装：

安装完成后显示如下：

点击“Login”按钮进入登录页面：

填写我们之前提交的管理员账户信息进行登录。登录成功后跳转到后台管理页面http://localhost/pyrocms/public/admin/dashboard：

PyroCMS采用类似Drupal（一个流行的开源CMS）的节点（Node）方式来组织内容，一切元素诸如表单元素、分类、类型、设置等都可以看作节点，然后以节点方式组成内容，比如发布Posts需要先创建分类，类型（如文章、视频等），以及文章字段对应的表单元素节点等。感兴趣的同学可以去玩玩，这里我就不深入探讨了。