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

時間 2019-11-24

標籤編程開發 c++&java&python&javascript&go&php&ruby&perl&r&erlang java python javascript php ruby perl erlang 欄目 C&C++ 简体版

原文原文鏈接

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

在從此採用編程語言開發和測試時，將不再用花費大量時間進行環境配置了，只需簡單獲取容器鏡像，便可快速擁有相關的環境。html

C/C++

C是一門古老的語言，在1969年由貝爾實驗室設計開發，今天仍然是系統領域和高性能計算的主要選擇。C語言具備高效、靈活、功能豐富、表達力強和較高的可移植性等特色。C++在C的基礎上，支持了數據的抽象與封裝、面向對象和泛型編程。功能與性能的平衡使C++成爲了目前應用最普遍的系統編程語言之一。java

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

GCC

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

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

將C/C++代碼運行在容器內的最簡方法，就是將編譯指令寫入Dockerfile中，而後使用此Dockerfile構建自定義鏡像，最後直接運行此鏡像，便可啓動程序。git

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\n");
　　return 0;
}

如今，就可使用Dockerfile來構建鏡像my-gcc-app：github

$ docker build -t gcc-image .golang

建立並運行此容器，會編譯並運行程序，輸出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特性包括：

快：在OSX上的測試中，Clang比GCC 4.0快2.5倍。
內存佔用小：Clang內存佔用通常比GCC要小的多。
診斷信息可讀性強：Clang對於錯誤的語法不但有源碼提示，還會在錯誤的調用和相關上下文上有更好的提示。
基於庫的模塊化設計：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。

其中經常使用的是帶有版本標籤的，以及帶有onbuild標籤的node鏡像。

首先，在Node.js項目中新建一個Dockerfile：

FROM node:4-onbuild
EXPOSE 8888

而後，新建server.js文件，內容以下：

'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');

以後，經過npm init命令來新建node項目所必須的package.json文件：

$ npm init

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

下面使用docker build指令構建node鏡像：

$ docker build -t node-image .

最後，建立並運行node容器：

$ docker run -it -P node-image

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

此時可使用瀏覽器查看到MyApp應用的服務頁面。

首先，使用docker ps指令查看端口綁定狀況：

$ docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

7b6f666d4808 node-image "npm start" xxxago Up xx 0.0.0.0:32771->8888/tcp node-container

若是隻須要運行單個node腳本的容器，則無需經過Dockerfile構建鏡像，可使用如下指令：

$ docker run -it --rm --name my-running-script -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp node:0.10 node your-daemon-or-script.js

Go

Go語言（也稱Golang）是一個由Google主導研發的編程語言，於2009年推出。它的語法清晰明瞭，設計精良，擁有一些先進的特性，還有一個龐大的標準庫。Go的基本設計理念是：編譯效率、運行效率和開發效率要三者兼顧。使用Go開發，既能夠獲得不少靈活的語法支持，又能夠擁有C/C++的運行和編譯效率。此外，Go提供了輕量級的協程，支持大規模併發的場景。

搭建並運行Go容器

1.使用官方鏡像

運行Go語言環境的最簡方法是使用官方golang鏡像。可使用docker run指令直接啓動Go語言的交互環境：

$ docker run -it golang /bin/bash

root@79afc2b64b06:/go# go versiongo version go1.7 linux/amd64

還能夠將Go編譯指令寫入Dockerfile中，基於此Dockerfile構建自定義鏡像。具體步驟以下。

第一步，新建項目文件夾，並在根目錄新建Dockerfile：

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`

第二步，新建自定義go程序go-sample.go：

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

第三步，使用docker build指令構建鏡像：

$ docker build -t golang-image .

最後，使用docker run指令運行Go容器：

$ docker run -it --rm --name golang-container golang-image + exec app

Hello,世界

至此成功運行了Go語言的實例容器。

若是須要在容器中編譯Go代碼，可是不須要在容器中運行它，那麼能夠執行以下命令：

$ docker run --rm -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp golang go build -v_/usr/src/myapp

這會將Go項目文件夾做爲Docker數據卷掛載起來並做爲運行目錄。而後，Docker會在工做目錄中編譯代碼，執行go build命令並輸出可執行文件至myapp。

2.Go項目容器化

首先，下載Golang官方提供的outyet示例項目：

$ mkdir outyet

$ cd outyet

#使用go get下載：

$ go get github.com/golang/example/outyet

#或者直接使用wget下載：

$ wget https://github.com/golang/example/archive/master.zip

$ unzip master.zip

$ cd example-master/outyet

$ ls

Dockerfile containers.yaml main.go main_test.go

示例項目搭建成功後，能夠按照如下模板去自定義項目的Dockerfile：

#使用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

若是使用onbuild版本的基礎鏡像，那麼源文件拷貝、構建與配置等過程就會自動完成，無需在Dockerfile中逐一配置，以下所示：

FROM golang:onbuild
EXPOSE 8080

下面開始構建與運行此Golang項目。在outyet項目根目錄執行docker build指令，使用本地目錄下的Dockerfile：

$ docker build -t outyet .

構建過程當中，Docker會從Docker Hub中獲取golang基礎鏡像，拷貝本地包文件，構建項目並給鏡像打上outyet標籤。

下面，使用docker run指令運行此鏡像：

$ docker run -p 6060:8080 --name test --rm outyet

此時，實例項目的容器已經在運行狀態。打開瀏覽器訪問http://localhost:6060/便可看到運行界面。

Beego

Beego是一個使用Go的思惟來幫助開發者構建並開發Go應用程序的開源框架。Beego使用Go開發，思路來自於Tornado，路由設計來源於Sinatra。

使用方法以下。

第一步，下載安裝：

go get github.com/astaxie/beego

第二步，建立文件hello.go：

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

第三步，編譯運行：

go build -o hello hello.go

./hello

第四步，打開瀏覽器並訪問http://localhost:8080。

至此，一個Beego項目成功構建了。

Gogs：基於Go的Git服務

Gogs的目標是打造一個最簡單、輕鬆的方式搭建自助Git服務。使用Go語言開發使得Gogs可以經過獨立的二進制分發，而且支持Go語言支持的全部平臺，包括Linux、Mac OS X、Windows以及ARM平臺。

可使用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還能夠執行編譯後代碼，編譯能夠達到加密和優化代碼運行，使代碼運行更快。

1.使用官方鏡像

第一步，在PHP項目的根目錄中新建一個Dockerfile：

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

新建hello.php文件：

echo "hello php\n"

第二步，運行docker build命令構建鏡像：

$ docker build -t php-image .

最後，執行如下命令去運行Docker鏡像：

$ docker run -it --rm --name php-container php-image

hello php

2.掛載PHP項目

須要運行簡單的，甚至單文件的PHP項目，那麼每次都寫Dockerfile會很麻煩。

這種狀況下，能夠用如下命令掛載PHP項目：

$ docker run -it --rm --name my-running-script -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp php:5.6-cli php your-script.php

3.配合Apache使用

一般狀況下，PHP項目須要和Apache httpd/Nginx一塊兒運行，這樣就須要PHP容器中內含Apache Web Server。

可使用帶有apache標籤的鏡像，如php:5.6-apache。

第一步，在PHP項目的根目錄中新建一個Dockerfile，並使用Docker Hub官方的基礎鏡像：

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

其中，src/是當前包含全部PHP代碼的目錄。

第二步，使用此Dockerfile構建自定義鏡像：

$ docker build -t my-php-app .

第三步，建立並運行此鏡像：

$ docker run -it --rm --name my-running-app my-php-app

建議添一個自定義的php.ini配置文件，將其拷貝到/usr/local/lib。這樣能夠對PHP項目作更多的定製化，如開啓某些PHP插件，或者對PHP解釋器進行一些安全/性能相關的配置。

添加方法很簡單：

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

src/是當前存放PHP代碼的文件夾，config/文件夾包含php.ini文件。

若是讀者但願直接使用官方鏡像運行PHP項目，能夠執行以下命令：

$ docker run -it --rm --name my-apache-php-app -v "$(pwd)":/var/www/html php:5.6-apache

Ruby

Ruby是一種動態的面向對象的腳本語言，具備支持反射、跨平臺、設計精簡等特色，在Web應用領域應用頗多。Ruby的設計受到Perl、Smalltalk、Eiffel、Ada和Lisp的影響。Ruby支持多種編程範式，如函數編程、面向對象編程、CLI交互式編程。Ruby還有動態的數據類型系統和自動的內存管理。

使用Ruby官方鏡像

首先，在Ruby項目中建立一個Dockerfile：

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

而後，新建rb-sample.rb例子程序：

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

將以上文件放在app的根目錄（與Gemfile同級）。

使用的官方鏡像帶有onbuild標籤，意味着包含了啓動大部分Ruby項目所需的基本指令。

在構建鏡像的時候，Docker會執行COPY./usr/src/app以及RUN bundle install。

而後，構建名爲ruby-image的鏡像：

$ docker build -t ruby-image .

最後，建立並運行此鏡像：

$ docker run -it --name ruby-container ruby-image

因爲在構建時使用了帶有onbuild標籤的鏡像，因此在app目錄下須要有Gemfile.lock文件。

能夠在App的根目錄運行如下命令：

$ docker run --rm -v "$(pwd)":/usr/src/app -w /usr/src/app ruby:2.1.2 bundle install --system

若是隻須要運行單個的Ruby腳本，那麼無需使用Dockerfile構建自定義鏡像，而是經過如下命令直接使用官方Ruby鏡像，帶參數運行容器：

$ docker run -it --rm --name my-running-script -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp ruby:2.1.2 ruby your-daemon-or-script.rb

JRuby

JRuby相似於Python的Jython，它可運行於JVM上並支持Java的接口和類。

第一步，用戶在JRuby項目中建立一個Dockerfile：

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

第二步，新建Ruby示例代碼jruby-sample.rb：

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

將此文件放在app的根目錄（與Gemfile同級）。

使用的官方鏡像帶有onbuild標籤，意味着包含了啓動大部分JRuby項目所需的基本指令。在構建鏡像的時候，會執行COPY./usr/src/app以及RUN bundle install。

第三步，構建自定義鏡像：

$ docker build -t jruby-image .

第四步，建立並運行此鏡像：

$docker run -it --name jruby-container jruby-image

因爲在構建時使用了帶有onbuild標籤的鏡像，因此在app目錄下須要有Gemfile.lock文件。這時能夠在app的根目錄運行如下命令：

$ docker run --rm -v "$(pwd)":/usr/src/app -w /usr/src/app jruby:1.7.15 bundleinstall --system

若是隻須要運行單個的JRuby腳本，那麼無需使用Dockerfile構建自定義鏡像，而是經過如下命令直接使用官方JRuby鏡像，帶參數運行容器：

$ docker run -it --rm --name my-running-script -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp jruby:1.7.15 jruby your-daemon-or-script.rb

Ruby on Rails

Rails是使用Ruby語言編寫的網頁程序開發框架，目的是爲開發者提供經常使用組件，簡化網頁程序的開發。只需編寫較少的代碼，就能實現其餘編程語言或框架難以企及的功能。經驗豐富的Rails程序員會發現，Rails讓程序開發變得更有樂趣。

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!\n";

第三步，經過此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帶有大量的統計軟件包，如常見的貝葉斯推斷、聚類分析、機器學習、空間統計、穩健統計等，在生物信息、統計學等領域應用普遍。

Rocker項目是一個Docker官方支持的項目，它提供了R語言的容器環境支持。官方提供的r-base鏡像就是基於Rocker項目的。

1.運行交互式R語言環境

能夠直接運行官方提供的r-base鏡像，進入交互模式的R環境：

$ docker run -ti --rm r-base

退出交互命令行時，可使用quit()指令，此時能夠選擇是否保存工做空間：

> quit()

Save workspace image? [y/n/c]:

2.運行R語言批量模式

能夠經過鏈接工做目錄，來運行R語言的批量指令。把一個卷（volume）鏈接至容器時，最好使用一個非根用戶，這樣能夠避免權限問題：

$ docker run -ti --rm -v "$PWD":/home/docker -w /home/docker -u docker r-base R

3.運行R語言命令行模式

能夠直接進入R容器的bash命令行：

$ docker run -ti --rm r-base bash

root@4a0bba3f4cb4:/#

在bash中若是但願進入R語言交互命令行，能夠直接輸入R：

root@4a0bba3f4cb4:/bin# R

可使用vim.tiny編輯器，新建r-demo.R腳本：

print("Hello,World!")

保存後，就可使用Rscript指令運行此腳本：

root@4a0bba3f4cb4:/bin# Rscript demo.R

Rscript demo.R

[1] "Hello,World!"

還能夠在R語言交互命令行中運行R腳本。

首先，在容器中新建hi.R腳本：

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

而後直接輸入R指令進入交互命令行，使用source()函數加載腳本，再使用hello()函數調用用戶的打印邏輯：

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

4.使用自定義容器

在用戶將手頭的R項目容器化的過程當中，每每須要加入本身的環境構建邏輯，也須要運行自定義容器。

這種狀況下，用戶就須要基於官方提供的r-base基礎鏡像，完成自定義的Dockerfile，例如：

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

其中running-r-scripts.R內容能夠簡寫爲：print("My R Container！")

而後，使用docker build指令構建：

$ 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", [N,F])
catch
_:_ ->
usage()
end;
main(_) ->
usage().
usage() ->
io:format("usage: factorial integer\n"),
halt(1).
fac(0) -> 1;
fac(N) -> N * fac(N-1).