種是使用 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