使用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特性包括：

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!\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带有大量的统计软件包，如常见的贝叶斯推断、聚类分析、机器学习、空间统计、稳健统计等，在生物信息、统计学等领域应用广泛。

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", [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计算结果。