FROM gcc:4.9

COPY . /usr/src/myapp

WORKDIR /usr/src/myapp

RUN gcc -o myapp main.c

CMD ["./myapp"]

#include

int main()

{

　　printf("Hello World\n");

　　return ;

}

FROM java:

COPY . /usr/src/javaapp

WORKDIR /usr/src/javaapp

RUN javac HelloWorld.java

CMD ["java", "HelloWorld"]

FROM python:-onbuild

CMD [ "python3.5", "./py3-sample.py" ]

def fib(n):

a, b = 0, 1

while a < n:

print(a, end=' ')

a, b = b, a+b

print()

fib(1000)

for animal in ["dog", "cat", "mouse"]:

print "%s is a mammal" % animal

FROM pypy:3-onbuild

CMD [ "pypy3", "./hi.py" ]

其中常用的是带有版本标签的，以及带有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平台。

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同级）。

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

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

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

FROM perl:5.20

COPY . /usr/src/myapp

WORKDIR /usr/src/myapp

CMD [ "perl", "./perl-sample.pl" ]

#!/usr/bin/perl

print "Hello, World!\n";

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指令构建：

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>

User switch command

--> j

1* {shell,start,[init]}

--> q

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

#!/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).