程式設計開發(C/C++&Java&Python&JavaScript&Go&PHP&Ruby&Perl&R&Erlang)

使用Docker快速部署主流程式語言的開發、編譯環境及其常用框架，包括C、C++、Java、Python、JavaScript、Go、PHP、Ruby、Perl、R、Erlang等。

在今後採用程式語言開發和測試時，將再也不用花費大量時間進行環境配置了，只需簡單獲取容器映象，即可快速擁有相關的環境。

C/C++

C是一門古老的語言，在1969年由貝爾實驗室設計開發，今天仍然是系統領域和高效能運算的主要選擇。C語言具有高效、靈活、功能豐富、表達力強和較高的可移植性等特點。C++在C的基礎上，支援了資料的抽象與封裝、物件導向和泛型程式設計。功能與效能的平衡使C++成為了目前應用最廣泛的系統程式語言之一。

三款流行的C/C++開發工具，GCC、LLVM和Clang。

GCC

GCC（GNU Compiler Collection）是一套由GNU開發的程式語言編譯器，是一套以GPL及LGPL許可證所發行的自由軟體，也是GNU計劃的關鍵部分。GCC（特別是其中的C語言編譯器）通常被認為是跨平臺編譯器的事實標準。

GCC可處理C/C++，以及Fortran、Pascal、Objective-C、Java、Ada等多種語言。

將C/C++程式碼執行在容器內的最簡方法，就是將編譯指令寫入Dockerfile中，然後使用此Dockerfile構建自定義映象，最後直接執行此映象，即可啟動程式。

FROM gcc:4.9
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
RUN gcc -o myapp main.c
CMD ["./myapp"]

編輯main.c，內容如下：

#include
int main()
{
　　printf("Hello World
");
　　return 0;
}

現在，就可以使用Dockerfile來構建映象my-gcc-app：

$ docker build -t gcc-image .

建立並執行此容器，會編譯並執行程式，輸出Hello World語句。

$ docker run -it –rm –name gcc-container gcc-image

Hello World

如果只需要容器編譯程式，而不需要執行它，可以使用如下命令：

$ docker run –rm -v “$(pwd)”:/usr/src/myapp -w /usr/src/myapp gcc gcc -o myapp main.c

以上命令會將當前目錄（”$(pwd)”）掛載到容器的/usr/src/myapp目錄，並執行gcc -o myapp myapp.c。GCC將會編譯myapp.c程式碼，並將生成的可執行檔案輸出至/usr/src/myapp資料夾。

LLVM

LLVM（Low Level Virtual Machine）是伊利諾伊大學的一個研究專案，試圖提供一個現代化的，基於SSA的編譯策略，同時支援靜態和動態程式語言。和之前為大家所熟知的JVM以及.net Runtime這樣的虛擬機器不同，這個虛擬系統提供了一套中立的中間程式碼和編譯基礎設施，並圍繞這些設施提供了一套全新的編譯策略（使得優化能夠在編譯、連線、執行環境執行過程中，以及安裝之後以有效的方式進行）和其他一些非常有意思的功能。

Docker Hub中已經有使用者提供了LLVM映象。

$ docker pull imiell/llvm

Clang

Clang是一個由Apple公司用C++實現、基於LLVM的C/C++/Objective C/Objective C++編譯器，其目標就是超越GCC成為標準的C/C++編譯器，它遵循LLVM BSD許可。Clang很好地相容了GCC。

Clang特性包括：

1. 快：在OSX上的測試中，Clang比GCC 4.0快2.5倍。
2. 記憶體佔用小：Clang記憶體佔用一般比GCC要小的多。
3. 診斷資訊可讀性強：Clang對於錯誤的語法不但有原始碼提示，還會在錯誤的呼叫和相關上下文上有更好的提示。
4. 基於庫的模組化設計：Clang將編譯過程分成彼此分離的幾個階段，將大大增強IDE對於程式碼的操控能力。

在Docker Hub中已經有使用者提供了Clang的映象：

$ docker pull bowery/clang

Java

Java是一種擁有跨平臺、物件導向、泛型程式設計特點的編譯型語言，廣泛應用於企業級應用開發和移動應用開發領域，由SUN公司在1995年推出。Java是基於類的物件導向的高階語言，其設計理念是儘可能的減少部署依賴，致力於“開發一次，到處執行”。這就意味著Java的二進位制編碼不需要再次編譯，即可執行在異構的JVM上。Java在大型網際網路專案，特別是網際網路金融和電子商務專案中非常受歡迎。

在容器中執行Java程式碼最簡單的方法就是將Java編譯指令直接寫入Dockerfile。然後使用此Dockerfile構建並執行此映象，即可啟動程式。

在本地新建一個空目錄，在其中建立Dockerfile檔案。在Dockerfile中，加入需要執行的Java編譯命令，例如：

FROM java:7
COPY . /usr/src/javaapp
WORKDIR /usr/src/javaapp
RUN javac HelloWorld.java
CMD ["java", "HelloWorld"]

使用此Dockerfile構建映象java-image：

$ docker build -t java-image .

然後，執行此映象即自動編譯程式並執行：

$ docker run -it –rm –name java-container java-image

Hello, World

如果只需要在容器中編譯Java程式，而不需要執行，則可以使用如下命令：

$ docker run –rm -v “$(pwd)”:/usr/src/javaapp -w /usr/src/javaapp java:7 javac HelloWorld.java

Python

Python是一種解釋型的動態語言，物件導向設計，功能十分強大。它整合了模組（modules）、異常處理（exceptions）、動態型別（dynamic typing）、高階資料結構（元組、列表、序列）、類（classes）等高階特性。Python設計精良，語法簡約，表達能力很強。目前，所有主流作業系統（Windows、所有Linux、類Unix系統）都支援Python。

使用官方的Python映象

推薦使用者使用Docker官方提供的Python映象作為基礎映象。

第一步，建立Dockerfile檔案：

新建專案目錄py-official，進入此目錄，新建一個Dockerfile檔案，內容如下：

FROM python:3-onbuild
CMD [ "python3.5", "./py3-sample.py" ]

新建py3-sample.py檔案，計算Fibonacci數列：

def fib(n):
a, b = 0, 1
while a < n:
print(a, end=` `)
a, b = b, a+b
print()
fib(1000)

新建requirements.txt依賴檔案，可以在此檔案中加入專案依賴程式，如Django等。此處僅新建空檔案。

$ touch requirements.txt

第二步，使用docker build命令構建名為py2.7-sample-app的映象：

$ docker build -t py3-image .

第三步，通過docker run命令建立並執行容器：

$ docker run -it –rm –name py3-container py3-image

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

如果只需要執行單個Python指令碼，那麼無需使用Dockerfile構建自定義映象，而是通過以下命令直接使用官方Python映象，帶引數執行容器：

$ docker run -it –rm –name my-running-script -v “$(pwd)”:/usr/src/myapp -w /usr/src/myapp python:3 python your-daemon-or-script.py

使用PyPy

PyPy是一個Python實現的Python直譯器和即時編譯（JIT）工具，它專注與速度、效率，以及和CPython完全的相容性。PyPy通過JIT技術可以使得Python執行速度提高近十倍，同時保證相容性。

首先，設定專案目錄，並新建hi.py例項程式：

for animal in ["dog", "cat", "mouse"]:
print "%s is a mammal" % animal

然後，在根目錄新建Dockerfile，基於pypy3的onbuild版本映象：

FROM pypy:3-onbuild
CMD [ "pypy3", "./hi.py" ]

如果使用者需要使用pypy2，則可以使用：FROM pypy:2-onbuild。

onbuild版本的映象內含若干onbuild觸發器，它們可以再映象構建期間完成一些必要的初始化操作，便於專案的直接執行。pypy的onbuild映象會拷貝一個requirements.txt依賴檔案，執行RUN pip install安裝依賴程式，然後將當前目錄拷貝至/usr/src/app。

下面，使用者開始構建和執行此映象：

$ docker build -t my-python-app .

$ docker run -it –rm –name my-running-app my-python-app

如果使用者只需要執行單個pypy指令碼，並希望避免新建Dockerfile，那麼使用者可以直接使用以下指令：

$ docker run -it –rm –name my-running-script -v “$PWD”:/usr/src/myapp -w /usr/src/myapp pypy:3 pypy3 your-daemon-or-script.py

如果需要使用pypy2執行，則可以使用如下指令：

$ docker run -it –rm –name my-running-script -v “$PWD”:/usr/src/myapp -w /usr/src/myapp pypy:2 pypy your-daemon-or-script.py

JavaScript

JavaScript是目前所有主流瀏覽器上唯一支援的指令碼語言，這也是早期JavaScript的唯一用途。Node.js的出現，讓服務端應用也可以基於JavaScript進行編寫。

Node.js自2009年釋出，使用Google Chrome瀏覽器的V8引擎，採用事件驅動，效能優異。同時還提供了很多系統級API，如檔案操作、網路程式設計等。

使用Node.js環境

Node.js擁有3種官方映象：node:、node:onbuild、node:slim。

FROM node:4-onbuild
EXPOSE 8888

`use strict`;
var connect = require(`connect`);
var serveStatic = require(`serve-static`);
var app = connect();
app.use(`/`, serveStatic(`.`, {`index`: [`index.html`]}));
app.listen(8080);
console.log(`MyApp is ready at http://localhost:8080`);

This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (node) node
version: (1.0.0)
description: node-sample
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/faxi/Docker/js/node/package.json:
{
"name": "node",
"version": "1.0.0",
"description": "node-sample",
"main": "index.js",
"scripts": {
"test": "echo "Error: no test specified" && exit 1"
},
"author": "",
"license": "ISC"
}
Is this ok? (yes) yes

npm info it worked if it ends with ok
npm info using npm@2.15.1
npm info using node@v4.4.3
npm info prestart node@1.0.0
npm info start node@1.0.0
> node@1.0.0 start /usr/src/app
> node server.js
MyApp is ready at http://localhost:8080

FROM golang:1.6-onbuild          
#顯示宣告基礎映象版本，利於後期維護。onbuild版本Dockerfile的具體內容如下：
FROM golang:1.6
RUN mkdir -p /go/src/app
WORKDIR /go/src/app
CMD ["go-wrapper", "run"]      
#通過`go-wrapper`程式執行當前目錄下的主函式
ONBUILD COPY . /go/src/app      
#拷貝當前專案程式碼至執行目錄
ONBUILD RUN go-wrapper download
#下載依賴，具體實現參考`go-wrapper`原始碼
ONBUILD RUN go-wrapper install  
#安裝依賴，具體實現參考`go-wrapper`原始碼
# `go-wrapper`原始碼地址：`https://github.com/docker-library/golang/blob/master/go-wrapper`
# Dockerfile原始碼地址: `https://github.com/docker-library/golang/blob/master/1.6/onbuild/Dockerfile`

package main
import "fmt"
func main() {
fmt.Println("Hello,世界")
}

#使用golang基礎映象。基於Debian系統，安裝最新版本的golang環境。工作空間（GOPATH）配置是"/go"
FROM golang
#將本地的包檔案拷貝至容器工作目錄。
ADD . /go/src/github.com/golang/example/my-go
#在容器中構建my-go。可以在這裡手動或者自動（godep）管理依賴關係。
RUN go install github.com/golang/example/my-go
#設定容器自動執行my-go。
ENTRYPOINT /go/bin/my-go-app
#監聽8080埠。
EXPOSE 8080

FROM golang:onbuild
EXPOSE 8080

package main
import "github.com/astaxie/beego"
func main() {
beego.Run()
}

可以使用docker run直接建立並執行映象：

$ docker run –rm –name gogs gogs/gogs

如果需要停止此映象，可以使用docker stop與docker rm指令：

$ docker stop gogs; docker rm gogs

如果需要將資料持久化，可以先新建資料資料夾，然後將其作為資料卷掛載至gogs容器中：

$ mkdir -p /srv/lxc/gogs/data

$ docker run -d –name gogs -p 8300:3000 -p 8322:22 -v /srv/lxc/gogs/data:/data gogs/gogs

PHP

PHP（Hypertext Preprocessor，超文字前處理器）是一種通用的開源指令碼語言。語法吸收了C、Java和Perl等語言的特點，利於學習，使用廣泛，主要適用於Web開發領域。PHP執行效率比完全生成HTML標記的CGI要高許多；PHP還可以執行編譯後程式碼，編譯可以達到加密和優化程式碼執行，使程式碼執行更快。

FROM php:5.6-cli
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
CMD [ "php", "./hello.php" ]

FROM php:5.6-apache
COPY src/ /var/www/html/

FROM php:5.6-apache
COPY config/php.ini /usr/local/lib/
COPY src/ /var/www/html/

FROM ruby:2.1.2-onbuild
CMD ["./rb-sample.rb .rb"]

say = "I love Ruby"
3.times { puts say }

FROM jruby:.1.7.24-onbuild
CMD ["./jruby-sample.rb"]

say = "I love JRuby"
3.times { puts say }

1.使用官方映象

第一步，使用者在Rails專案中建立一個Dockerfile，將此檔案放在專案根目錄（與Gemfile同級）。

Dockerfile內容如下：

FROM rails:onbuild

可見使用者使用了onbuild標籤，即此基礎映象會自行完成一些基本的構建工作幷包含了大部分啟動一個Rails專案所需的基本指令。

Dockerfie內容如下：

FROM ruby:2.3
# throw errors if Gemfile has been modified since Gemfile.lock
RUN bundle config --global frozen 1
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
ONBUILD COPY Gemfile /usr/src/app/
ONBUILD COPY Gemfile.lock /usr/src/app/
ONBUILD RUN bundle install
ONBUILD COPY . /usr/src/app

第二步，構建自定義映象：

$ docker build -t rails-image .

第三步，建立並執行此映象：

$ docker run –name rails-container -d rails-image

此時使用者可以使用瀏覽器訪問http://container-ip:3000檢視服務，當然，也可以對映到本地主機埠。

$ docker run –name some-rails-app -p 8080:3000 -d my-rails-app

現在可以使用瀏覽器訪問http://localhost:8080或者http://host-ip:8080。

2.使用Compose搭建Rails應用

下面使用Docker Compose來配置和執行一個簡單的Rails+PostgreSQL應用。

第一步，確定專案資料夾內容。新建一個名為rails-compose-example的專案資料夾，在其根目錄新建一個Dockerfile檔案，內容如下：

FROM ruby:2.2.0
RUN apt-get update -qq && apt-get install -y build-essential libpq-dev
RUN mkdir /code
WORKDIR /code
ADD Gemfile /code/Gemfile
ADD Gemfile.lock /code/Gemfile.lock
RUN bundle install
ADD . /code

Gemfile內容如下：

source `https://rubygems.org`

gem `rails`, `4.2.0`

下面使用者新建docker-compose.yml檔案，內容如下：

version: `2`
services:
db:
image: postgres
web:
build: .
command: bundle exec rails s -p 3000 -b `0.0.0.0`
volumes:
- .:/myapp
ports:
- "3000:3000"
depends_on:
- db

第二步，構建Rails專案。可以使用docker-compose run指令構建並啟動此Rails專案：

$ docker-compose run web rails new . –force –database=postgresql –skip-bundle

Perl

Perl是一個高階的、動態的解釋型指令碼語言，它的設計借鑑了C、Shell、awk和sed。Perl最重要的特性是它內部整合了正規表示式的功能，以及巨大的第三方程式碼庫CPAN。Perl像C一樣強大，同時像awk、sed等指令碼語言一樣富有表達性。Perl常見於系統管理和檔案處理等程式，Perl多數情況下屬於Web方案中的膠水語言。

可以使用Docker官方的Perl映象作為基礎，在此之上進行必要的定製。

第一步，下載官方的Perl映象：

$ docker pull perl

如果對Perl的版本有要求，可以在以上命令中加入Tag標籤，以便於在下一步的Dockerfile的FROM指令中明確Perl版本號。官方映象都有明確的標籤資訊。

第二步，在Perl專案中新建Dockerfile：

FROM perl:5.20
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
CMD [ "perl", "./perl-sample.pl" ]

新建perl-sample.pl檔案：

#!/usr/bin/perl
print "Hello, World!
";

第三步，通過此Dockerfile，構建自定義的映象：

$ docker build -t perl-image .

構建成功後，使用者可以通過docker images檢視：

$ docker images

REPOSITORY          TAG       IMAGE ID        CREATED              VIRTUAL SIZE

perl-image          latest    bc28eba086ad    About a minute ago   654.9 MB

最後，建立容器並執行：

$ docker run -it –rm –name perl-container perl-image

Hello, World!

如果只需要執行單個的Perl指令碼，那麼無需使用Dockerfile構建自定義映象，而是通過以下命令直接使用官方Perl映象，帶引數執行容器：

$ docker run -it –rm –name perl-container -v “$(pwd)”:/usr/src/myapp -w /usr/src/myapp perl:5.20 perl perl-sample.pl

Hello, World!

如果需要執行Perl的Web專案，則最好先自建內建SSH服務的映象，然後以此為基礎定製Perl容器，這樣可以方便地通過SSH服務訪問Perl容器。

R

R是一個面向統計分析和繪圖的語言，是由紐西蘭奧克蘭大學統計學系的Ross Ihaka和Robert Gentleman共同創立。R帶有大量的統計軟體包，如常見的貝葉斯推斷、聚類分析、機器學習、空間統計、穩健統計等，在生物資訊、統計學等領域應用廣泛。

hello <- function( name ) {
sprintf( "Hello, %s", name );
}

> source(`/bin/hi.R`)
> hello(`docker`)
[1] "Hello, docker"
>

FROM r-base:latest
COPY . /usr/local/src/r-scripts
WORKDIR /usr/local/src/r-scripts
CMD ["Rscript", "running-r-scripts.R"]

$ docker build -t my-r-container /directry/of/Dockerfile

然後使用docker run指令執行容器，並通過docker ps指令檢視執行狀態：

$ docker run -d my-r-container

e86739e8226a081372d9bb0fb9f62a32405814b5172a543487b0751839c2e57f

Erlang

Erlang是一種用來構建大規模彈性、實時、高併發、高可用系統的程式語言，被廣泛應用於電信、銀行、電子商務和即時訊息領域。Erlang的執行時系統內建支援併發、分散式和容錯機制。Erlang由愛立信所轄的CS-Lab於1987年開發，目的是創造一種可以應對大規模併發活動的程式語言和執行環境。

1.使用官方映象

可以使用erlang映象，直接進入Erlang互動命令列Eshell：

$ docker run -it –rm erlang:latest

Erlang/OTP 18 [erts-7.3.1] [source] [64-bit] [async-threads:10] [hipe] [kernel-poll:false]
Eshell V7.3.1  (abort with ^G)
1> uptime().
3 minutes and 3 seconds
ok
2>

可以使用ctl+G進入任務切換模式，其中j為列出所有任務：

User switch command
--> j
1* {shell,start,[init]}
--> q

$ docker run -it –rm -h erlang.local erlang erl -name allen

Erlang/OTP 18 [erts-7.3.1] [source] [64-bit] [async-threads:10] [hipe] [kernel-poll:false]
Eshell V7.3.1  (abort with ^G)
(allen)1> erlang:system_info(otp_release).
"18"
(allen)2>
User switch command
--> q

2.直接執行Erlang指令碼

可以直接使用docker run指令，通過escript執行Erlang指令碼。

下面以斐波那契數列作為例子進行講解。

首先，新建fab.erl檔案：

#!/usr/bin/env escript
%% -*- erlang -*-
main([String]) ->
try
N = list_to_integer(String),
F = fac(N),
io:format("factorial ~w = ~w
", [N,F])
catch
_:_ ->
usage()
end;
main(_) ->
usage().
usage() ->
io:format("usage: factorial integer
"),
halt(1).
fac(0) -> 1;
fac(N) -> N * fac(N-1).

儲存後，使用docker run指令執行：

$ docker run -it –rm –name erlang-inst1 -v “$PWD”:/usr/src/myapp -w /usr/src/myapp erlang escript fab.erl 5

factorial 5 = 120

可見已輸出factorial 5=120計算結果。