种是使用 Docker 中的 Ubuntu 镜像，一种是直接在 Ubuntu 搭建环境。
我图省事先用的 Docker 方式，虽然看起来很简单，只需要执行两条命令，但我折腾了几十分钟也没搞定。
因为执行 docker build --rm=true -t termux . 后会安装和升级大量（1G 左右）的包，默认的官方源速度是很不给力的。这样或者修改 Dockerfile 修改源，或者直接手动进 Docker 里操作。这就不是两条命令的事情了，需要对 Docker 比较熟悉。我选择直接手动进 Docker 里操作。在安装过程中，我发现安装了大量看起来没有用的包，占用
❷ 如何运用docker配合python开发环境实例
1. 创建一个用于开发Django App的目录
mkdir django-example && cd django-example
2. 构建基本开发环境
touch Dockerfile
touch pip.conf requirements.txt
pip.conf文件填入以下内容，以便一会用pip安装Python 模块时使用阿里云镜像加速：
[global]
index-url =
[install]
trusted-host=mirrors.aliyun.com
requirements.txt文件中填入要安装的Python 模块：
django
编写构建开发环境的Dockerfile文件，填入以下内容：
# MAINTAINER Gevin
# DOCKER-VERSION 1.12.0
#
# Dockerizing Python: Dockerfile for building python applications
FROM python:2.7.12
MAINTAINER Gevin
WORKDIR /usr/src/app
# 使用阿里云的pip镜像
COPY pip.conf /root/.pip/pip.conf
COPY requirements.txt /usr/src/app/requirements.txt
RUN pip install -r /usr/src/app/requirements.txt
EXPOSE 8000
CMD ["bash"]
然后执行下面命令构建镜像：
docker build -t gevin/django-example:0.1 .
构建成功后，执行docker images命令，可以查看到当前构建好的image
docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
gevin/django-example 0.1 1855fc3c8062 12 hours ago 698.9 MB
3. 使用构建的image拉起开发环境
执行下面命令，可以以前台形式拉起django-example镜像的一个container：
docker run -it --rm -v $(pwd):/usr/src/app gevin/django-example:0.1
上面命令使用了data volume，把当前目录挂载到container中的工作目录下，这样当前目录下的所有文件都会映射到container的工作目录下，在工作目录下的所有改动，也都会保存到宿主机的当前目录下。
4. 创建django项目
上一步的命令创建了一个安装了django的交互式的container，直接在该container中执行创建django项目的命令即可：
root@7c91f460599f:/usr/src/app# django-admin startproject dj_example
上述命令，在container中基于django的命令创建了一个django项目，由于上一步操作时把宿主机的当前目录挂载到container的工作目录下，因此，刚刚在container中创建的django项目，在宿主机上也能看到。
container:
root@7c91f460599f:/usr/src/app# ls
Dockerfile dj_example pip.conf requirements.txt
宿主机：
django-example ls
Dockerfile dj_example pip.conf requirements.txt
5. 启动django项目
docker run -it --rm -p 8000:8000 -v $(pwd):/usr/src/app gevin/django-example:0.1 python dj_example/manage.py runserver 0.0.0.0:8000
❸ 如何使用Docker部署Go Web应用程序
需要在当前目录下建立如下三个文件。
1）.gitignore
node_moles/*
2)package.json
{
"name": "docker-centos-hello",
"private": true,
"version": "0.0.1",
"description": "Node.js Hello world app on CentOS using docker",
"author": "Daniel Gasienica ",
"dependencies": {
"express": "3.2.4"
}
}
3)server.js
var express = require('express'),
app = express(),
redis = require('redis'),
RedisStore = require('connect-redis')(express),
server = require('http').createServer(app);
app.configure(function() {
app.use(express.cookieParser('keyboard-cat'));
app.use(express.session({
store: new RedisStore({
host: process.env.REDIS_HOST || 'localhost',
port: process.env.REDIS_PORT || 6379,
db: process.env.REDIS_DB || 0
}),
cookie: {
expires: false,
maxAge: 30 * 24 * 60 * 60 * 1000
}
}));
});
app.get('/', function(req, res) {
res.json({
status: "ok"
});
});
var port = process.env.HTTP_PORT || 3000;
server.listen(port);
console.log('Listening on port ' + port);
配置Dockerfile
我们需要通过Dockerfile来配置我们的docker镜像。
FROM ubuntu:14.04
MAINTAINER zengjinlong
RUN apt-get update
#Install Redis
RUN apt-get -y -qq install python redis-server
RUN apt-get -y -qq install wget
#Install Node
RUN cd /opt && \
wget && \
tar -xzf node-v0.10.33-linux-x64.tar.gz && \
mv node-v0.10.33-linux-x64 node && \
cd /usr/local/bin && \
ln -s /opt/node/bin/* . && \
rm -f /opt/node-v0.10.33-linux-x64.tar.gz
#Set the working directory
WORKDIR /src
j
CMD ["/bin/bash"]
有了Dockerfile之后，就可以通过docker build来建立我们的镜像。
docker build -t minimicall/node_web:0.1 .
这里需要说明的是，你需要灵活的根据你的ubuntu真实的环境来变化中间的指令。例如,当我们第一次执行的时候，告诉我找不到python redis-server，我想应该是我的apt 源太out了，所以，我加了RUN apt-get update.就解决了这个问题。
当我wget的时候，说没有这个指令，那么我就得安装wget.而nodejs的地址，也是我去从nodejs的官网查找的。所以碰到问题，具体问题具体分析。
查看我们建立的镜像。
micall@micall-ThinkPad:~/docker/nodejs_web_app$ sudo docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
minimicall/node_web 0.1 730770dff17f 6 minutes ago 268.7 MB
centos centos6 70441cac1ed5 2 weeks ago 215.8 MB
ubuntu 14.04 5506de2b643b 4 weeks ago 199.3 MB
启动我们的镜像：
sudo docker run -i -t --rm \
> -p 3000:3000 \
> -v `pwd`:/src \
> minimicall/node_web:0.1
这时候我们已经进入到了这个镜像启动的容器里面了。
root@d80a2ed6b4c0:/src#
执行下列命令
root@d80a2ed6b4c0:/src# npm install --quiet > /dev/null
npm WARN engine [email protected]: wanted: {"node":"<0.9.0"} (current: {"node":"0.10.33","npm":"1.4.28"})
root@d80a2ed6b4c0:/src# npm install -g nodemon --quiet > /dev/null
root@d80a2ed6b4c0:/src# ls
Dockerfile Dockerfile~ index.js~ package.json server.js src
Dockerfile.centos index.js node_moles package.json~ server.js~
root@d80a2ed6b4c0:/src# nodemon server.js
22 Nov 14:37:31 - [nodemon] v1.2.1
22 Nov 14:37:31 - [nodemon] to restart at any time, enter `rs`
22 Nov 14:37:31 - [nodemon] watching: *.*
22 Nov 14:37:31 - [nodemon] starting `node server.js`
Listening on port 3000
这个时候用浏览器打开：，会的到如下结果。
{
"status": "ok"
}
❹ 如何到载百度网议
不久之前，机器之心联合网络推出 PaddlePaddle 专栏，为想要学习这一平台的技术人员推荐相关教程与资源。在解析过PaddlePaddle框架之后，从这篇文章开始上手，安装 PaddlePaddle。
目录
环境
Windows 系统的安装
在 Windows 上安装 Docker 容器在 Windows 上安装 Ubuntu
使用 pip 安装
使用 Docker 安装
从源码编译生成安装包
在本地编译生成安装包在 Docker 编译生成安装包
编译 Docker 镜像
测试安装环境
最后提示
项目代码
参考资料
环境
系统：Ubuntu 16.0.4（64 位）处理器：Intel(R) Celeron(R) CPU内存：8G
Windows 系统的安装
PaddlePaddle 目前还不支持 Windows，如果读者直接在 Windows 上安装 PaddlePaddlePaddle 的话，就会提示没有找到该安装包。如果读者一定要在 Windows 上工作的话，笔者提供两个建议：一、在 Windows 系统上使用 Docker 容器，在 Docker 容器上安装带有 PaddlePaddle 的镜像；二、在 Windows 系统上安装虚拟机，再在虚拟机上安装 Ubuntu。
在 Windows 上安装 Docker 容器
首先下载 Docker 容器的工具包 DockerToolbox，笔者使用这个安装包不仅仅只有 Docker，它还包含了 VirtualBox 虚拟机，使用者工具包我们就不用单独去安装 VirtualBox 虚拟机了，DockerToolbox 的官网下载地址：https://docs.docker.com/toolbox/toolbox_install_windows/
下载之后，就可以直接安装了，双击安装包，开始安装
选择安装路径，笔者使用默认的安装路径
然后安装所依赖的软件，因为笔者之前在电脑上已经安装了 git，所以在这里就不安装了，其他都要勾选
这一步不用修改什么，让程序为我们创建一个桌面快捷键
最后就可以安装了，等待一小段时间即可
到这里就安装完成了
安装完成之后，如果直接启动 Docker 的话，有可能可能会卡在这里，因为还有下载一个 boot2docker.iso 镜像，网速比较慢的话就可能一直卡在这里。所以我们还要镜像下一步操作
Running pre-create checks...
(default) No default Boot2Docker ISO found locally, downloading the latest release...
(default) Latest release for github.com/boot2docker/boot2docker is v17.12.1-ce
(default) Downloading C:\Users\15696\.docker\machine\cache\boot2docker.iso from https://github.com/boot2docker/boot2docker/releases/download/v17.12.1-ce/boot2docker.iso...
在下载 DockerToolbox 的时候，这个工具就已经带有 boot2docker.iso 镜像了。并且存在 DockerToolbox 安装的路径上，笔者的路径是：
C:\Program Files\Docker Toolbox\boot2docker.iso
我们把这个镜像复制到用户目录\.docker\machine\cache\，如笔者的目录如下：
C:\Users\15696\.docker\machine\cache\
复制完成之后，双击桌面快捷方式 Docker Quickstart Terminal，启动 Docker，命令窗口会输出以下信息：
Running pre-create checks...
Creating machine...
(default) Copying C:\Users\15696\.docker\machine\cache\boot2docker.iso to C:\Users\15696\.docker\machine\machines\default\boot2docker.iso...
(default) Creating VirtualBox VM...
(default) Creating SSH key...
(default) Starting the VM...
(default) Check network to re-create if needed...
(default) Windows might ask for the permission to create a network adapter. Sometimes, such confirmation window is minimized in the taskbar.
(default) Found a new host-only adapter: "VirtualBox Host-Only Ethernet Adapter #3"
(default) Windows might ask for the permission to configure a network adapter. Sometimes, such confirmation window is minimized in the taskbar.
(default) Windows might ask for the permission to configure a dhcp server. Sometimes, such confirmation window is minimized in the taskbar.
(default) Waiting for an IP...
最后看到 Docker 的 logo 就表示成功安装 Docker 容器了
## .
## ## ## ==
## ## ## ## ## ===
/"""""""""""""""""\___/ ===
~~~ {~~ ~~~~ ~~~ ~~~~ ~~~ ~ / ===- ~~~
\______ o __/
\ \ __/
\____\_______/
docker is configured to use the default machine with IP 192.168.99.100
For help getting started, check out the docs at https://docs.docker.com
Start interactive shell
15696@ MINGW64 ~
$
到这就可以使用 Docker 来安装 PaddlePaddle 了，具体请看本文章中关于 Docker 使用 PaddlePaddle 部分
在 Windows 上安装 Ubuntu
在 Windows 上在 Ubuntu 就要先安装虚拟机，虚拟机有很多，笔者使用的是开源的 VirtualBox 虚拟机，VirtualBox 的官网：https://www.virtualbox.org/
安装完成 VirtualBox 虚拟机之后，进入到 VirtualBox 虚拟机中点击新建，创建一个系统
选择分配的内存，我这里只是分配了 2G，如果正式使用 PaddlePaddle 训练模型，这远远不够，读者可以根据需求分配内存
创建一个虚拟硬盘
选择默认的 VDI 硬盘文件类型
这里最好是选择动态分配硬盘，这样虚拟机会根据实际占用的空间大小使用电脑本身的磁盘大小，这样会减少电脑空间的占用率的。如果是固定大小，那么创建的虚拟机的虚拟硬盘一开始就是用户设置的大小了。
这里就是选择虚拟硬盘大小的，最后分配 20G 以上，笔者分配 30G，应该够用。
然后选择刚才创建的 Ubuntu 系统，点击设置，这系统中取消勾选软驱，然后点击存储，选择 Ubuntu 镜像，笔者使用的是 64 位 Ubuntu 16.04 桌面版的镜像
最后就可以启动安装 Ubuntu 了。选择我们创建的 Ubuntu 系统，点击启动，进入到开始安装界面，为了方便使用，笔者选择中文版的
为了安装之后不用在安装和更新应用，笔者勾选了安装 Ubuntu 时下载更新，这样在安装的时候就已经更新应用了
然后是选安装的硬盘，因为我们使用的自己创建的整一个硬盘，所以我们可以直接选择青春整个硬盘并安装 Ubuntu，这里就不用考虑分区和挂载问题了
选择所在的位置，这没什么要求的，笔者随便选择一个城市
然后是选择键盘的布局，通常的键盘布局都是英语（美国）
创建 Ubuntu 的用户名称和密码
最后就是安装了，这个安装过程可能有点久，耐心等待
安装完成之后就可以在 Windows 系统上使用 Ubuntu 系统了，我们再使用 Ubuntu 来学习和使用 PaddlePaddle 做深度学习了。最好安装完成之后，把在存储中设置的 Ubuntu 镜像移除
在本篇文章之后部分都是在 Ubuntu 上操作，我们都可以使用 Ubuntu 这虚拟机来完成。
如果读者使用的是 Windows 10，可以使用 Windows 系统自带的 Linux 子系统，安装教程可以看我之前的文章 Windows10 安装 Linux 子系统。
使用 pip 安装
如果你还没有在 pip 命令的话，首先要安装 pip，要确保安装的 pip 版本是大于 9.0.0 的，否则可能无法安装 paddlepaddle。
安装 pip 命令如下：
sudo apt install python-pip
安装之后，还有看一下 pip 的的版本 pip --version，如果版本低于 9.0.0，那要先升级 pip，先要下载一个升级文件，命令如下：
wget https://bootstrap.pypa.io/get-pip.py
下载完成之后，可以使用这个文件安装最新的 pip 了
python get-pip.py
安装 pip 就可以动手安装 paddlepaddle 了。如果权限不够，请在 root 下执行命令
pip install paddlepaddle
现在就测试看看 paddlepaddle 有没有，在 python 的命令终端中试着导入 paddlepaddle 包：
import paddle.v2 as paddle
如果没有报错的话就证明 paddlepaddle 安装成功了。
使用 Docker 安装
为什么要使用 Docker 安装 paddlepaddle 呢，Docker 是完全使用沙箱机制的一个容器，在这个容器安装的环境是不会影响到本身系统的环境的。通俗来说，它就是一个虚拟机，但是它本身的性能开销很小。在使用 Docker 安装 paddlepaddle 前，首先要安装 Docker，通过下面的命令就可以安装了：
sudo apt-get install docker
安装完成之后，可以使用 docker --version 查看 Docker 的版本，如果有显示，就证明安装成功了。可以使用 docker images 查看已经安装的镜像。
一切都没有问题之后，就可以用 Docker 安装 paddlepaddle 了，命令如下：
docker pull docker.paddlepaddlehub.com/paddle
在这里不得不说的是，这个安装过程非常久，也许是笔者的带宽太小了。安装完成后，可以再使用 docker images 命令查看安装的镜像，应该可以 看到类似这样一个镜像，名字和 TAG 会相同，其他信息一般不同
docker.paddlepaddlehub.com/paddle latest 2b1ae16d846e 27 hours ago 1.338 GB
从源码编译生成安装包
我们的硬件环境都有很大的不同，官方给出的 pip 安装包不一定是符合我们的需求，比如笔者的电脑是不支持 AVX 指令集的，在官方中没找到这个的安装包（也行现在已经有了），所以我们要根据自己的需求来打包一个自己的安装包。
在本地编译生成安装包
1. 安装依赖环境
在一切开始之前，先要安装好依赖环境，下面表格是官方给出的依赖环境
1.1 安装 GCC
一般现在的 Ubuntu 都是高于个版本了，可以使用 gcc --version 查看安装的版本。比如笔者的是 4.8.4，如果你的是版本是低于 4.8.2 的就要更新一下了
sudo apt-get install gcc-4.9
1.2 安装 CMake
先要从官网下 CMake 源码
wget https://cmake.org/files/v3.8/cmake-3.8.0.tar.gz
解压源码
tar -zxvf cmake-3.8.0.tar.gz
依次执行下面的代码
# 进入解压后的目录
cd cmake-3.8.0
# 执行当前目录的 bootstrap 程序
./bootstrap
# make 一下
make
# 开始安装
sudo make install
查看是否安装成功，cmake --version，如果正常显示版本，那已经安装成功了。
1.3 安装 pip
关于安装 pip9.0.0 以上的版本，在上面的使用 pip 安装部分已经讲了，这里就不在熬述了
1.4 安装 numpy
安装 numpy 很简单，一条命令就够了
sudo apt-get install python-numpy
顺便多说一点，matplotlib 这个包也经常用到，顺便安装一下
sudo apt-get install python-matplotlib
1.5 安装 SWIG
执行下面代码安装 SWIG，安装成功之后，使用 swig -version 检查安装结果
sudo apt-get install -y git curl gfortran make build-essential automake swig libboost-all-dev
1.6 安装 Go
官方说可选择，那看情况吧，如果像安装安装吧，笔者顺便安装了，就一条代码的事情，老规则 go version
sudo apt-get install golang
到这里，依赖环境就已经安装好了，准备安装 paddlepaddle。
2. 首先要在 GitHub 上获取 paddlepaddle 源码
git clone https://github.com/PaddlePaddle/Paddle.git
3. 然后输以下命令
# 进入刚下载的 Paddle 里面
cd Paddle
# 创建一个 build 文件夹
mkdir build
# 进入 build 文件夹里
cd build
# 这就要选好你的需求了，比如笔者没有使用 GPU，不支持 AVX，为了节省空间，我把测试关闭了，这样会少很多空间。最后不要少了..
cmake .. -DWITH_GPU=OFF -DWITH_AVX=OFF -DWITH_TESTING=OFF
# 最后 make，生成你想要的安装包，这个可能很久, 一定要有耐心
make
经过长久的 make 之后，终于生成了我们想要的安装包，它的路径在 Paddle/build/python/dist 下，比如笔者在该目录下有这个安装包 paddlepaddle-0.11.0-cp27-cp27mu-linux_x86_64.whl，你的命名可能不是这个。之后就可以安装了，使用 pip 安装：
# 请切入到该目录
cd build/python/dist/
# 每个人的安装包名字可能不一样。如果权限不够，请在 root 下执行命令
pip install paddlepaddle-0.11.0-cp27-cp27mu-linux_x86_64.whl
这个我们就已经安装了 paddlepaddle，现在就测试看看 paddlepaddle 有没有安装成功了，在 python 的命令终端中试着导入 paddlepaddle 包：
import paddle.v2 as paddle
如果没有报错的话就证明 paddlepaddle 安装成功了。
在 Docker 编译生成安装包
使用 Docker 就轻松很多了，有多轻松，看一下便知 。
1. 首先要在 GitHub 上获取 paddlepaddle 源码
git clone https://github.com/PaddlePaddle/Paddle.git
2. 切入到项目的根目录下
cd Paddle
3. 生成安装包
下面一行代码，提醒一下，这个过程非常长，一定要有耐心，顺便把编译测试关了，减少空间
docker run -it -v $PWD:/paddle -e "WITH_GPU=OFF" -e "WITH_AVX=OFF" -e "-DWITH_TESTING=OFF" docker.paddlepaddlehub.com/paddle:latest-dev bash -x /paddle/paddle/scripts/docker/build.sh
同样会在 Paddle/build/python/dist 下生成一个安装包，这对比在本地生成的安装包，是不是要简单很多，没错这就是 Docker 强大之处，所有的依赖环境都帮我们安装好了，现在只要安装这个安装包就行了：
# 请切入到该目录
cd build/python/dist/
# 每个人的安装包名字可能不一样。如果权限不够，请在 root 下执行命令
pip install paddlepaddle-0.11.0-cp27-cp27mu-linux_x86_64.whl
同样我们要测试看看 paddlepaddle 有没有安装成功了，在 python 的命令终端中试着导入 paddlepaddle 包：
import paddle.v2 as paddle
如果没有报错的话就证明 paddlepaddle 安装成功了。
编译 Docker 镜像
如果你比较喜欢使用 Docker 来运行你的 paddlepaddle 代码，但是有没有你想要的镜像，这是就要自己来制作一个 Docker 镜像了，比如笔者的电脑是不支持 AVX 指令集的，还只有 CPU，那么我就要一个不用 AVX 指令集和使用 CPU 训练的镜像。好吧，我们开始吧
1. 我们要从 GitHub 下载源码：
git clone https://github.com/PaddlePaddle/Paddle.git
2. 安装开发工具到 Docker image 里
# 切入到 Paddle 目录下
cd Paddle
# 下载依赖环境并创建镜像，别少了最后的.
docker build -t paddle:dev .
有可能它不能够命名为 paddle:dev，我们可以对他从重新命名，ID 要是你镜像的 ID
# docker tag <镜像对应的 ID> <镜像名:TAG>
例如：docker tag 1e835127cf33 paddle:dev
3. 编译
# 这个编译要很久的，请耐心等待
docker run --rm -e WITH_GPU=OFF -e WITH_AVX=OFF -v $PWD:/paddle paddle:dev
安装完成之后，使用 docker images 查看刚才安装的镜像。
测试安装环境
我们就使用官方给出的一个例子，来测试我们安装 paddlepaddle 真的安装成功了
1. 创建一个记事本，命名为 housing.py，并输入以下代码：
import paddle.v2 as paddle
# Initialize PaddlePaddle.
paddle.init(use_gpu=False, trainer_count=1)
# Configure the neural network.
x = paddle.layer.data(name='x', type=paddle.data_type.dense_vector(13))
y_predict = paddle.layer.fc(input=x, size=1, act=paddle.activation.Linear())
# Infer using provided test data.
probs = paddle.infer(
output_layer=y_predict,
parameters=paddle.dataset.uci_housing.model(),
input=[item for item in paddle.dataset.uci_housing.test()()])
for i in xrange(len(probs)):
print 'Predicted price: ${:,.2f}'.format(probs[i][0] * 1000)
2. 执行一下该代码
在本地执行代码请输入下面的命令
python housing.py
在 Docker 上执行代码的请输入下面的代码
docker run -v $PWD:/work -w /work -p 8899:8899 docker.paddlepaddle.org/paddle python housing.py
-v 命令是把本地目录挂载到 docker 镜像的目录上，-w 设置该目录为工作目录，-p 设置端口号，使用到的镜像是在使用 Docker 安装部分安装的镜像 docker.paddlepaddle.org/paddle
3. 终端会输出下面类似的日志
I0116 08:40:12.004096 1 Util.cpp:166] commandline: --use_gpu=False --trainer_count=1
Cache file /root/.cache/paddle/dataset/fit_a_line.tar/fit_a_line.tar not found, downloading https://github.com/PaddlePaddle/book/raw/develop/01.fit_a_line/fit_a_line.tar
[==================================================]
Cache file /root/.cache/paddle/dataset/uci_housing/housing.data not found, downloading https://archive.ics.uci.e/ml/machine-learning-databases/housing/housing.data
[==================================================]
Predicted price: $12,316.63
Predicted price: $13,830.34
Predicted price: $11,499.34
Predicted price: $17,395.05
Predicted price: $13,317.67
Predicted price: $16,834.08
Predicted price: $16,632.04
如果没有成功运行该代码，报错信息如下，说明安装的 paddlepaddle 版本过低，请安装高版本的 paddlepaddle
I0116 13:53:48.957136 15297 Util.cpp:166] commandline: --use_gpu=False --trainer_count=1
Traceback (most recent call last):
File "housing.py", line 13, in <mole>
parameters=paddle.dataset.uci_housing.model(),
AttributeError: 'mole' object has no attribute 'model'
最后提示
有很多学习者会出现明明安装完成 PaddlePaddle 了，但是在 PaddlePaddle 的时候，在初始化 PaddlePaddle 这一行代码出错
paddle.init(use_gpu=False, trainer_count=1)
这个多数是读者的电脑不支持 AVX 指令集，而在 PaddlePaddle 的时候，安装的是支持 AVX 指令集的版本，所以导致在初始化 PaddlePaddle 的时候报错。所以在安装或者编译 PaddlePaddle 安装包时，要根据读者电脑本身的情况，选择是否支持 AVX 指令集。查看电脑是否支持 AVX 指令集，可以在终端输入以下命令，输出 Yes 表示支持，输出 No 表示不支持。
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
项目代码
GitHub 地址:https://github.com/yeyupiaoling/LearnPaddle
参考资料
http://paddlepaddle.org/
https://pip.pypa.io/en/stable/
http://www.runoob.com/
http://www.linuxidc.com/Linux/2016-12/138489.htm
https://www.jianshu.com/p/c6264cd5f5c7
❺ 如何在Python中使用ZeroMQ和Docker构建微服务架构
当想让一个容器做两件事情，或者使一个Docker镜像包含来自两个不同镜像的依赖库时，就需要知道每个镜像的Dockerfile。本文介绍了如何通过docker history命令来对Docker镜像进行反向工程，得到它们的Dockerfile，并组织到一个Dockerfile里然后build，从而实现想做的事情。
常言道，“不要重复发明轮子！”
在使用Docker时，构建自己的镜像之前，最好在Docker Hub寻找一些可以直接使用的镜像做练习。把软件架构分布到一系列容器中，每一个容器只做一件事情，这样的效果非常好。构建分布式应用的最好的基石是使用来自Docker Hub的官方镜像，因为可以信任它们的质量。
在某些情况下，可能想让一个容器做两件不同的事情。而在另外一些情况下，可能想让一个Docker镜像包含来自两个不同镜像的依赖库。如果有每个镜像的Dockerfile，这是非常简单的。将它们组织到一个Dockerfile里然后build就行。
然而，大多数时间都在使用Docker Hub上准备好的镜像，不会有它们的源Dockerfile。我花时间找一个可以合并（或flatten）两个不同Docker镜像的工具，当然没有它们的Dockerfile。也就是说在找一个能做下面这件事的东西：
image 1 --
\
---> merged_image_12
/
image 2 --
此前在GitHub上有两个相关的讨论（1、2），尽管它们都被关闭了。
这可能吗？
那么，是否存在工具能够像这样做吗：docker merge image2 image2 merged_image？
没有！
你甚至不可以用下面的方式来构建Dockerfile：
FROM image1
FROM image2
简而言之，在一个Dockerfile里不能有多个基础镜像。
但是我需要这个功能！
唯一的解决办法是取得这些镜像的Dockerfile，然后把它们组织到一个文件中，再进行构建。那么，我能在Docker Hub上获得一个镜像的Dockerfile吗？ 幸运的是可以。它不能离线获取（译注：原文是online，但显然online时对于来自GitHub的自动构建镜像是可以直接获取的），但是你可以使用docker history命令，通过反向工程获取。
怎么来使用？
在你的机器上使用docker pull从Docker Hub下载镜像。
docker pull image1
docker pull image2
然后使用docker history来取得构建这两个容器时运行的命令。
docker history --no-trunc=true image > image1-dockerfile
docker history --no-trunc=true image2 > image2-dockerfile
接下来打开这两个文件，你可以看到每个镜像的命令堆栈。这是因为Docker镜像通过层（阅读更多）的方式来构建。即你在Dockerfile中键入的每一个命令所构建的新镜像，都是在之前的命令产生的镜像之上。所以你可以对镜像进行逆向工程。
限制
不能对镜像进行反向工程的唯一场景，是镜像的维护者在他的Dockerfile中使用了ADD或COPY命令。你会看到这样一行：
ADD file:1ac56373f7983caf22
或 ADD dir:cf6fe659e9d21535844
这是因为不知道维护者在他自己的机器上，包括镜像里使用了什么本地文件。
❻ 如何用Dockerfile创建镜像
Dockerfile结构
dockerfile由4部分信息组成：基础镜像信息、维护者信息、镜像操作指令和容器启动时执行指令。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# This dockerfile uses the ubuntu image
# VERSION 2 - EDITION 1
# Author: docker_user
# Command format: Instruction [arguments / command] ..
# Base image to use, this must be set as the first line
FROM ubuntu
# Maintainer: docker_user <docker_user at email.com> (@docker_user)
MAINTAINER docker_user [email protected]
# Commands to update the image
RUN echo "deb http://archive.ubuntu.com/ubuntu/ raring main universe" >> /etc/apt/sources.list
RUN apt-get update && apt-get install -y nginx
RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf
# Commands when creating a new container
CMD /usr/sbin/nginx
其中#表注释，可以标注一些说明性的文字。
FROM关键字指定镜像的来源，默认为DockerHub，也可以写私有仓库的镜像，例如：localhost：5000/centos:6.7，如果本地已经存在指定的镜像名称，则会从本地缓存直接获取。MAINTAINER 指定镜像的作者，之后为镜像操作执行RUN、ADD等，最后是容器启动时发起的指令。
Dockerfile中的指令
FROM: 指定镜像名称，格式为FROM <image> 或FROM <image>:<tag>，例如FROM ubuntu 或 FROM ubuntu:12.04
MAINTAINER: 镜像作者 ，格式为 MAINTAINER <name>
RUN：格式为 RUN <command> 或 RUN ["executable", "param1", "param2"]。
前者将在 shell 终端中运行命令，即 /bin/sh -c；后者则使用 exec 执行。指定使用其它终端可以通过第二种方式实现，例如 RUN ["/bin/bash", "-c", "echo hello"]。
每条 RUN 指令将在当前镜像基础上执行指定命令，并提交为新的镜像。当命令较长时可以使用 \ 来换行。
CMD:支持三种格式
1.CMD ["executable","param1","param2"] 使用 exec 执行，推荐方式；
2.CMD command param1 param2 在 /bin/sh 中执行，提供给需要交互的应用；
3.CMD ["param1","param2"] 提供给 ENTRYPOINT 的默认参数；
指定启动容器时执行的命令，每个 Dockerfile 只能有一条 CMD 命令。如果指定了多条命令，只有最后一条会被执行。如果用户启动容器时候指定了运行的命令，则会覆盖掉 CMD 指定的命令。
EXPOSE:格式为 EXPOSE <port> [<port>...]。
告诉 Docker 服务端容器暴露的端口号，供互联系统使用。在启动容器时需要通过 -P，Docker 主机会自动分配一个端口转发到指定的端口。
ENV:格式为 ENV <key> <value>。 指定一个环境变量，会被后续 RUN 指令使用，并在容器运行时保持。这就对应程序语言中的变量定义，可在需要的时候引用。例如：
1
2
3
4
ENV PG_MAJOR 9.3
ENV PG_VERSION 9.3.4
RUN curl -SL http://example.com/postgres-$PG_VERSION.tar.xz | tar -xJC /usr/src/postgress && …
ENV PATH /usr/local/postgres-$PG_MAJOR/bin:$PATH
ADD:格式为 ADD <src> <dest>。
该命令将复制指定的 <src> 到容器中的 <dest>。 其中 <src> 可以是Dockerfile所在目录的一个相对路径；也可以是一个 URL；还可以是一个 tar 文件（自动解压为目录）。
COPY:格式为 COPY <src> <dest>。
复制本地主机的 <src>（为 Dockerfile 所在目录的相对路径）到容器中的 <dest>。当使用本地目录为源目录时，推荐使用 COPY。
COPY和ADD的不同就是：ADD多了自动解压和支持URL路径的功能。
ENTRYPOINT：
两种格式：
ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2（shell中执行）。
配置容器启动后执行的命令，并且不可被 docker run 提供的参数覆盖。
每个 Dockerfile 中只能有一个 ENTRYPOINT，当指定多个时，只有最后一个起效。
CMD和ENTRYPOINT比较：两个命令都是只能使用一次，并且都是在执行docker run指令时运行，如果有多个，只执行最后一条。
两者的不同在于参数的传递方式，如果在Dockerfile中定义如下指令
1
CMD echo hello
或
1
ENTRYPOINT ["echo","hello"]
那么在运行命令docker run containerId echo hello时，指定了CMD的输入结果为world，可以看出Dockerfile中指定的命令被覆盖了，而指定了ENTRYPOINT时，输出结果为hello echo world，可以看出指定的命令被作为ENTRYPOINT指定指令的参数了。
VOLUME:格式为 VOLUME ["/data"]。创建一个可以从本地主机或其他容器挂载的挂载点，一般用来存放数据库和需要保持的数据等。不过此属性在Dockerfile中指定并没有什么意义，因为没有办法指定本地主机的目录。如果需要指定挂载点可以在执行docker run命令时指定：
1
docker run -it -v /home/fengzheng/ftp/:/data 859666d51c6d /bin/bash
USER:格式为 USER daemon。指定运行容器时的用户名或 UID，后续的 RUN 也会使用指定用户。
当服务不需要管理员权限时，可以通过该命令指定运行用户。并且可以在之前创建所需要的用户，例如：RUN groupadd -r postgres && useradd -r -g postgres postgres。要临时获取管理员权限可以使用 gosu，而不推荐 sudo。
WORKDIR:格式为 WORKDIR /path/to/workdir。为后续的 RUN、CMD、ENTRYPOINT 指令配置工作目录。可以使用多个 WORKDIR 指令，后续命令如果参数是相对路径，则会基于之前命令指定的路径。例如
1
2
3
4
WORKDIR /a
WORKDIR b
WORKDIR c
RUN pwd
则最终路径为 /a/b/c。
ONBUILD:格式为 ONBUILD [INSTRUCTION]。
配置当所创建的镜像作为其它新创建镜像的基础镜像时，所执行的操作指令。
例如，Dockerfile 使用如下的内容创建了镜像 image-A。
1
2
3
4
[...]
ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src
[...]
如果基于 image-A 创建新的镜像时，新的Dockerfile中使用 FROM image-A指定基础镜像时，会自动执行ONBUILD 指令内容，等价于在后面添加了两条指令。
1
2
3
4
5
FROM image-A
#Automatically run the following
ADD . /app/src
RUN /usr/local/bin/python-build --dir /app/src
使用 ONBUILD 指令的镜像，推荐在标签中注明，例如 ruby:1.9-onbuild。
基于CentOS6.7并源码安装nginx
首先准备了nginx-1.9.9.tar.gz安装包和CentOS6-Base-163.repo（163源），将这两个文件放到同一目录下，并在此目录下创建名称为Dockerfile的文件。之后在此文件中实现源替换、nginx编译安装、及一些依赖包的安装，Dockerfile内容如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# this is a test ubuntu 12.04 image dockerfile
# Author:fengzheng
# Base image,this must be set as the first line
#localhost:5000/centos:6.7是我的私有仓库的镜像，可替换为centos:6.7（DockerHub中的镜像）
FROM localhost:5000/centos:6.7
MAINTAINER fengzheng
# Commands to update the image
RUN mkdir /usr/nginx1.9.9
ADD nginx-1.9.9.tar.gz /usr/nginx1.9.9/
#RUN yum -y install tar
#RUN tar -zxvf /usr/nginx1.9.9/nginx-1.9.9.tar.gz
RUN cd /etc/yum.repos.d/ && mv CentOS-Base.repo CentOS-Base.repo.bak
ADD CentOS6-Base-163.repo /etc/yum.repos.d/
RUN cd /etc/yum.repos.d/ && mv CentOS6-Base-163.repo CentOS-Base.repo \
&& yum clean all && yum makecache \
&& yum -y install gcc \
&& yum -y install yum install -y pcre-devel \
&& yum -y install zlib zlib-devel \
&& yum -y install openssl openssl--devel \
&& cd /usr/nginx1.9.9/nginx-1.9.9/ && ./configure && make && make install
#如果设置daemon off; nginx无法启动
#RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf
# Commands when creating a new container
# 启动nginx 需进入/usr/local/nginx/sbin 执行./configure
CMD /bin/bash
最后执行命令"docker build -t nginx-centos:6.7 ."
其中.表示在当前目录下搜索Dockerfile文件，-t参数指定镜像名称和tag。
❼ 如何在Python中使用ZeroMQ和Docker构建微服务架构
微服务是什么？
微服务是一种架构风格，它包括多个彼此间进行通信的独立进程。在设计上，这些进程具有高度的可扩展性、相互解耦而且一次只完成一个较小的任务。这些服务都拥有自己的资源以及通过网络实现彼此间通信的进程。
相比于靠后端的 单体结构
来封装所有服务器逻辑的传统客户端－服务器架构（C/S架构）而言，微服务架构的差异性体现在关注点分离（Separation of
concern）。这种设计模式更易于维护，使得灵活性、可扩展性及容错能力更强。但是这种分布式架构所的不足之处体现在如果设计不合理就会使得排错及维
护变得复杂。
一个简单微服务的例子
让我们来分析这样的一个场景：你正在使用微服务模式构建一个电子商务网店。
对于一个电商网店上的常见商品，好比说iPhone，其详情页会显示：
。产品的及基本信息
。你的购买历史
。哪些人买了iPhone也买了手机套
。与苹果手机相关的优惠和折扣
。店家的数据
。送货方式
。推荐商品等等
此外，这个简单的产品详情页的接口将有多个版本的来匹配web、移动端以及用于第三方应用程序的REST API。
在微服务模式中数据分布在多个服务之间。在这个例子中，服务包括：
。产品详情服务
。商家服务
。支付服务
。优惠及折扣服务
。库存服务
。定价服务
。回顾服务
。推荐服务
这些独立的服务是如何被访问的呢？
解决办法是使用一个API网管，它作为所有客户端的单一入口并且根据需求调用分布在整个基础架构中的特定微服务。以上模式的行业应用案例是NetFlix API网关，它具有支持不同设备的多个API客户端。你可以点击此处 了解更多 。
构建一个简单的微服务
目前有很多方法可以用于构建你的微服务。
在本文中我们将使用ZeroMQ来创建两个进程之间的通信。ZeroMQ提供了用于在套接字之上开发可扩展、分布式systed的构建块。它使用椭圆曲线密码体制（第四版）来实现安全性，并提供了即刻开启的 通讯模式 。
关于ZMQ，还有很多 优点 。MQ即是针对异步工作而设计的线程化消息队列。谈论太多zeroMQ的内容已经超出了本文的范畴，你可以阅读 使用zeromq 以及 zeromq用于分布式系统 。
我们要使用的另一个工具是 Docker 。本文假设读者对Docker已经有了基础的了解。
ZeroMQ有很多种通讯模式，为了开始我们的工作，让我们用ZeroMQ和Flask来配置一个简单的PUB－SUB。下图展示了组件之间的关系和数据流。
1&3 － 一个flask服务器运行在5000端口上而且其URL是 /downcase/ 。该URL用来接受（GET）请求，而所有格式为的请求将收到回应：答谢字符将会转换为小写字符并返回。
2 － 回应的消息也被发送给同一个容器中的ZMQ发布者（Publisher）
4，5 － ZMQ订阅者（subscriber）持续监听并将来自ZMQ服务器的消息保存到名为 subscriber.log 的文件中
创建服务器
首先看一下我们的Dockerfile
<pre><code>
FROM ubuntu:14.04
RUN apt-get update
RUN apt-get install -y --force-yes python python-dev python-setuptools software-properties-common gcc python-pip
RUN apt-get clean all
RUN pip install pyzmq
RUN pip install Flask
ADD zmqserver.py /tmp/zmqserver.py
Flask Port
EXPOSE 5000
Zmq Sub Server
EXPOSE 4444
CMD ["python","/tmp/zmqserver.py"]
</code></pre>
我们选择Ubuntu
14.04作为容器操作系统。我们安装了基本的软件包。通过pip，我们安装pyzmq（zeromq的Python绑定）同时也安装了Flask。接着
我们导出端口5000（flask服务器）和4444（发布者运行的端口）。此外，我们复制了包含所有flask及zeromq
pythond代码的脚本文件 zmqserver.py 并运行它。
现在我们来看一下zmqserver.py的内容：
server.py
import time
import zmq
HOST = '127.0.0.1'
PORT = '4444'
_context = zmq.Context()
_publisher = _context.socket(zmq.PUB)
url = 'tcp://{}:{}'.format(HOST, PORT)
def publish_message(message):
try:
_publisher.bind(url)
time.sleep(1)
_publisher.send(message)
except Exception as e:
print "error {}".format(e)
finally: _publisher.unbind(url)
from flask import Flask
from flask import request
app = Flask(__name__)
@app.route("/downcase/", methods=['GET'])
def lowerString():
_strn = request.args.get('param')
response = 'lower case of {} is {}'.format(_strn, _strn.lower()) publish_message(response)
return response
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=False)
ZMQ发布者运行在4444端口上。我们创建了一个context并且声明了URL。我们运行了flask app，它通过URL ／downcase/ 把GET获得的参数 Param 转换成小写字符，这就是服务的应答。应答的字符串是 published ，它作为一个消息把相同的字符串返回给浏览器。
为了构建以上的Docker映像（image），我们执行以下的命令：
sudo docker build -t docker-zmq-pub
并且在该映像之上执行：
docker run --name docker-pub-server -p 5000:5000 -p 4444:4444 -t docker-zmq-pub
我们把容器中的端口5000和4444映射到这台主机上，于是无论客户端在哪里，它们都可以订阅这个发布者。
订阅者客户端
client.py
import zmq
import sys
import time
import logging
import os
HOST = '127.0.0.1'
PORT = '4444'
logging.basicConfig(filename='subscriber.log', level=logging.INFO)
class ZClient(object):
def __init__(self, host=HOST, port=PORT):
"""Initialize Worker"""
self.host = host
self.port = port
self._context = zmq.Context()
self._subscriber = self._context.socket(zmq.SUB)
print "Client Initiated"
def receive_message(self):
"""Start receiving messages"""
self._subscriber.connect('tcp://{}:{}'.format(self.host, self.port))
self._subscriber.setsockopt(zmq.SUBSCRIBE, b"")
while True:
print 'listening on tcp://{}:{}'.format(self.host, self.port)
message = self._subscriber.recv()
print message
logging.info(
'{} - {}'.format(message, time.strftime("%Y-%m-%d %H:%M")))
if __name__ == '__main__':
zs = ZClient()
zs.receive_message()
我们声明了发布者的IP地址及端口，当前它运行在同一个的主机上因此地址是127开头。我们在URL tcp://IP:PORT 上进行监听。一旦我们收到一个消息，就将其附上时间戳后记录到名为 subscriber.log 的文件中。运行客户端要做的所有工作就是执行 python <name_of_client_file>.py 。如果你在以上的架构上进行构建，它可以很好地充当近实时的日志聚合引擎。
我在Unbuntu主机上对以上的代码进行了测试。这里所用的代码保管在 github 上。这是一个如何配置zmq、docker和python服务器的基础讲解，在我的下一片文章中我们会使用我们已经学习的东西构建简单的微服务。
❽ 如何使用数据卷在宿主机和docker容器之间共享文件
共享宿主机的目录给容器
docker run -i -t -v ~/download:/home/hello python3-env /bin/bash
-v 表示创建一个数据卷并挂载到容器里
~/download:/home/hello 冒号前面是宿主机目录，后面是容器里的目录。表示把宿主机的download目录挂载到容器的/home/hello目录下。注意run之后是一个新的容器，ID都不一样的。
注意：python3-env是镜像的名称
从Dockerfile新建一个镜像
Dockerfile内容如下：
FROM debian
RUN apt-get update
RUN apt-get install -y python3-pip
新建镜像
docker build -t python3-env .
进入该镜像查看python版本
docker run -t -i python3-env /bin/bash
root@044fbdf3730e:/# python3
Python 3.2.3 (default, Feb 20 2013, 14:44:27)
--End--
❾ 如何制作一个定制的 Python 基础 Docker 镜像
目标：准备一个定制的 Python 基础镜像。基础镜像，通常为含最小功能的系统镜像，之后的应用镜像都以此为基础。
本项目代码维护在 DaoCloud/python-sample-base-image 项目中。
您可以在 GitHub 找到本项目并获取本文中所提到的所有脚本文件。
制作基础镜像
选择 Ubuntu 官方的 14.04 版本为我们依赖的系统镜像。
FROM ubuntu:trusty
因所有官方镜像均位于境外服务器，为了确保所有示例能正常运行，可以使用与官方镜像保持同步的 DaoCloud 境内镜像：
dockerfile
FROM cloud.io/ubuntu:trusty
设置镜像的维护者，相当于镜像的作者或发行方。
MAINTAINER Captain Dao <[email protected]>
用 RUN 命令调用 apt-get 包管理器安装 Python 环境所依赖的程序包。
安装依赖包相对比较固定，因此该动作应该尽量提前，这样做有助于提高镜像层的复用率。
安装完依赖后打扫卫生可以显着的减少镜像大小。
RUN apt-get update && \
apt-get install -y python \
python-dev \
python-pip && \
rm -rf /var/lib/apt/lists/*
以下是一个不建议的做法，原因是比上述命令多添加了一层镜像，然而并没有降低总镜像的体积。
dockerfile
RUN apt-get update && \
apt-get install -y python \
python-dev \
python-pip
RUN rm -rf /var/lib/apt/lists/*
用 RUN 命令调用 mkdir 来准备一个干净的放置代码的目录。
RUN mkdir -p /app
指定其为当前的工作目录。
WORKDIR /app
指定暴露的容器内端口地址，最后设置默认启动命令。
EXPOSE 80
CMD ["bash"]
至此一个 Python 的基础镜像制作完毕，您可以在本地运行 docker build -t my-python-base . 来构建出这个镜像并命名为 my-python-base。
Python 家族成员众多，因此需要一个通用的基础镜像，并在此基础上根据需求进行定制。
由于国内网络环境的特殊，在本地运行 docker build 的时间会很长，并且有可能失败。推荐使用 DaoCloud Toolbox 和 DaoCloud 的云端 代码构建 功能。
完整 Dockerfile
# Ubuntu 14.04，Trusty Tahr（可靠的塔尔羊）发行版
FROM cloud.io/ubuntu:trusty
# 道客船长荣誉出品
MAINTAINER Captain Dao <[email protected]>
# APT 自动安装 PHP 相关的依赖包，如需其他依赖包在此添加
RUN apt-get update && \
apt-get install -y python \
python-dev \
python-pip \
# 用完包管理器后安排打扫卫生可以显着的减少镜像大小
&& apt-get clean \
&& apt-get autoclean \
&& rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
# 配置默认放置 App 的目录
RUN mkdir -p /app
WORKDIR /app
EXPOSE 80
CMD ["bash"]
wph95