使用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\n"); 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特性包括：
- 快：在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).
保存后，使用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計算結果。