> 注意:——如果你不喜欢sudo,可以查看[非root用户使用](https://github.com/widuu/chinese_docker/blob/master/examples/installation/binaries.md)，--如何你使用OS X或者通过TCP使用Docker，你需要使用sudo 当你有许多docker服务器，或者不能使用Docker缓存来构建不相干的Docker容器，他可以为你的包缓存代理，这是非常有用的。该容器使第二个下载的任何包几乎瞬间下载。 使用下边的Dockerfile ~~~ # # Build: docker build -t apt-cacher . # Run: docker run -d -p 3142:3142 --name apt-cacher-run apt-cacher # # and then you can run containers with: # docker run -t -i --rm -e http_proxy http://dockerhost:3142/ debian bash # FROM ubuntu MAINTAINER SvenDowideit@docker.com VOLUME ["/var/cache/apt-cacher-ng"] RUN apt-get update ; apt-get install -yq apt-cacher-ng EXPOSE 3142 CMD chmod 777 /var/cache/apt-cacher-ng ; /etc/init.d/apt-cacher-ng start ; tail -f /var/log/apt-cacher-ng/* ~~~ 使用下边的命令构建镜像： ~~~ $ sudo docker build -t eg_apt_cacher_ng . ~~~ 现在运行它，映射内部端口到主机 ~~~ $ sudo docker run -d -p 3142:3142 --name test_apt_cacher_ng eg_apt_cacher_ng ~~~ 查看日志文件，默认使用`tailed`命令，你可以使用 ~~~ $ sudo docker logs -f test_apt_cacher_ng ~~~ 让你Debian-based容器使用代理,你可以做三件事之一： 1.添加一个apt代理设置`echo 'Acquire::http { Proxy "http://dockerhost:3142"; };' >> /etc/apt/conf.d/01proxy` 2.设置环境变量：`http_proxy=http://dockerhost:3142/` 3.修改你的`sources.list`来开始`http://dockerhost:3142/` 选项1注入是安全设置到你的apt配置在本地的公共基础版本。 ~~~ FROM ubuntu RUN echo 'Acquire::http { Proxy "http://dockerhost:3142"; };' >> /etc/apt/apt.conf.d/01proxy RUN apt-get update ; apt-get install vim git # docker build -t my_ubuntu . ~~~ 选项2针对测试时非常好的，但是会破坏其它从http代理的HTTP客户端，如curl 、wget或者其他： ~~~ $ sudo docker run --rm -t -i -e http_proxy=http://dockerhost:3142/ debian bash ~~~ 选项3是最轻便的，但是有时候你可能需要做很多次，你也可以在你的`Dockerfile`这样做： ~~~ $ sudo docker run --rm -t -i --volumes-from test_apt_cacher_ng eg_apt_cacher_ng bash $ /usr/lib/apt-cacher-ng/distkill.pl Scanning /var/cache/apt-cacher-ng, please wait... Found distributions: bla, taggedcount: 0 1\. precise-security (36 index files) 2\. wheezy (25 index files) 3\. precise-updates (36 index files) 4\. precise (36 index files) 5\. wheezy-updates (18 index files) Found architectures: 6\. amd64 (36 index files) 7\. i386 (24 index files) WARNING: The removal action may wipe out whole directories containing index files. Select d to see detailed list. (Number nn: tag distribution or architecture nn; 0: exit; d: show details; r: remove tagged; q: quit): q ~~~ 最后，停止测试容器，删除容器，删除镜像： ~~~ $ sudo docker stop test_apt_cacher_ng $ sudo docker rm test_apt_cacher_ng $ sudo docker rmi eg_apt_cacher_ng ~~~

> 注：如果你不喜欢使用sudo，你可以查看[这里非root用户运行](https://github.com/widuu/chinese_docker/blob/master/installation/binaries.md) 这里有一个例子，使用数据卷在两个CouchDb之间共享相同的数据容器，这个可以用于热升级，测试不同版本的CouchDB数据等等。 ## 创建第一个数据库 现在我们创建/var/lib/couchdb作为数据卷 ~~~ COUCH1=$(sudo docker run -d -p 5984 -v /var/lib/couchdb shykes/couchdb:2013-05-03) ~~~ ## 添加一条数据在第一个数据库中 我们假设你的docker主机默认是本地localhost.如果不是localhost请换到你docker的公共IP ~~~ HOST=localhost URL="http://$HOST:$(sudo docker port $COUCH1 5984 | grep -Po '\d+$')/_utils/" echo "Navigate to $URL in your browser, and use the couch interface to add data" ~~~ ## 创建第二个数据库 这次，我们请求共享访问$COUCH1的卷。 ~~~ COUCH2=$(sudo docker run -d -p 5984 -volumes-from $COUCH1 shykes/couchdb:2013-05-03) ~~~ ## 在第二个数据库上来浏览数据 ~~~ HOST=localhost URL="http://$HOST:$(sudo docker port $COUCH2 5984 | grep -Po '\d+$')/_utils/" echo "Navigate to $URL in your browser. You should see the same data as in the first database"'!' ~~~ 祝贺你，你已经运行了两个Couchdb容器，并且两个都相互独立，除了他们的数据

以下是用`Dockerfile`设置sshd服务容器，您可以使用连接并检查其他容器的卷,或者可以快速访问测试容器。 ~~~ # sshd # # VERSION 0.0.1 FROM ubuntu:12.04 MAINTAINER Thatcher R. Peskens "thatcher@dotcloud.com" # make sure the package repository is up to date RUN apt-get update RUN apt-get install -y openssh-server RUN mkdir /var/run/sshd RUN echo 'root:screencast' |chpasswd EXPOSE 22 CMD ["/usr/sbin/sshd", "-D"] ~~~ 使用如下命令构建镜像： ~~~ $ sudo docker build --rm -t eg_sshd . ~~~ 然后运行它，你可以使用`docker port`来找出容器端口22映射到主机的端口 ~~~ $ sudo docker run -d -P --name test_sshd eg_sshd $ sudo docker port test_sshd 22 0.0.0.0:49154 ~~~ 现在你可以使用ssh登陆Docker进程的主机IP地址，端口是49154(IP地址可以使用ifconfig获取)： ~~~ $ ssh root@192.168.1.2 -p 49154 # The password is ``screencast``. $ ~~~ 最后，清理停止的容器，并且删除容器，然后删除镜像。 ~~~ $ sudo docker stop test_sshd $ sudo docker rm test_sshd $ sudo docker rmi eg_sshd ~~~

这个例子的目的是向您展示如何构建一个预装Riak的docker镜象。 ### 创建Dockerfile 创建一个空文件`Dockerfile` ~~~ $ touch Dockerfile ~~~ 接下来，定义你想要来建立你镜像的父镜像。我们将使用Ubuntu（tag：最新版），从Docker Hub中下载： ~~~ # Riak # # VERSION 0.1.0 # Use the Ubuntu base image provided by dotCloud FROM ubuntu:latest MAINTAINER Hector Castro hector@basho.com ~~~ 接下来,我们更新APT缓存和应用更新: ~~~ # Update the APT cache RUN sed -i.bak 's/main$/main universe/' /etc/apt/sources.list RUN apt-get update RUN apt-get upgrade -y ~~~ 之后，我们安装和设置一些依赖关系： * `CURL`来下载 Basho's APT存储库秘钥。 * `lsb-release`帮助我们查看Ubuntu版本。 * `openssh-server`允许我们登陆远程容器，加入Riak节点组成一个集群。 * `supervisor`用于管理`OpenSSH`和`Riak`进程。 # [](https://github.com/widuu/chinese_docker/blob/master/examples/running_riak_service.md#install-and-setup-project-dependencies)Install and setup project dependencies RUN apt-get install -y curl lsb-release supervisor openssh-server RUN mkdir -p /var/run/sshd RUN mkdir -p /var/log/supervisor RUN locale-gen en_US en_US.UTF-8 ADD supervisord.conf /etc/supervisor/conf.d/supervisord.conf RUN echo 'root:basho' | chpasswd 下一步，添加 Basho's APT仓库： ~~~ RUN curl -s http://apt.basho.com/gpg/basho.apt.key | apt-key add -- RUN echo "deb http://apt.basho.com $(lsb_release -cs) main" > /etc/apt/sources.list.d/basho.list RUN apt-get update ~~~ 之后，我们安装Riak和改变一些默认值： ~~~ # Install Riak and prepare it to run RUN apt-get install -y riak RUN sed -i.bak 's/127.0.0.1/0.0.0.0/' /etc/riak/app.config RUN echo "ulimit -n 4096" >> /etc/default/riak ~~~ 接下来，我们为缺少的`initctl`来添加一个软连接： ~~~ # Hack for initctl # See: https://github.com/dotcloud/docker/issues/1024 RUN dpkg-divert --local --rename --add /sbin/initctl RUN ln -s /bin/true /sbin/initctl ~~~ 然后我们开发Riak协议缓冲区、HTTP接口以及SSH： ~~~ # Expose Riak Protocol Buffers and HTTP interfaces, along with SSH EXPOSE 8087 8098 22 ~~~ 最后，运行`supervisord`这里Riak和OpenSSH将启动： ~~~ CMD ["/usr/bin/supervisord"] ~~~ ### 创建一个supervisord配置文件 创建一个supervisord.conf空文件，并且保证和Dockerfile是平级目录： ~~~ touch supervisord.conf ~~~ 填充下面定义的程序: ~~~ [supervisord] nodaemon=true [program:sshd] command=/usr/sbin/sshd -D stdout_logfile=/var/log/supervisor/%(program_name)s.log stderr_logfile=/var/log/supervisor/%(program_name)s.log autorestart=true [program:riak] command=bash -c ". /etc/default/riak && /usr/sbin/riak console" pidfile=/var/log/riak/riak.pid stdout_logfile=/var/log/supervisor/%(program_name)s.log stderr_logfile=/var/log/supervisor/%(program_name)s.log ~~~ ### 构建Riak的Docker镜像 现在你应该能够构建一个Riak的docker镜像: ~~~ $ docker build -t "<yourname>/riak" . ~~~ ### 下一步 Riak是分布式数据库。很多生产部署包括至少5个节点。查看docker-riak[https://github.com/hectcastro/docker-riak](https://github.com/hectcastro/docker-riak)项目细节来使用Docker和Pipework部署Riak集群。

> 注意:——如果你不喜欢sudo,可以查看[非root用户使用](https://github.com/widuu/chinese_docker/blob/master/examples/installation/binaries.md) ### 在Docker中安装PostgreSQL 如果Docker Hub中没有你需要的Docker镜像，你可以创建自己的镜像，开始先创建一个`Dockerfile`: > 注意:这个PostgreSQL仅设置用途。请参阅PostgreSQL文档来调整这些设置,以便它是安全的。 ~~~ # # example Dockerfile for http://docs.docker.com/examples/postgresql_service/ # FROM ubuntu MAINTAINER SvenDowideit@docker.com # Add the PostgreSQL PGP key to verify their Debian packages. # It should be the same key as https://www.postgresql.org/media/keys/ACCC4CF8.asc RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8 # Add PostgreSQL's repository. It contains the most recent stable release # of PostgreSQL, ``9.3``. RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list # Update the Ubuntu and PostgreSQL repository indexes RUN apt-get update # Install ``python-software-properties``, ``software-properties-common`` and PostgreSQL 9.3 # There are some warnings (in red) that show up during the build. You can hide # them by prefixing each apt-get statement with DEBIAN_FRONTEND=noninteractive RUN apt-get -y -q install python-software-properties software-properties-common RUN apt-get -y -q install postgresql-9.3 postgresql-client-9.3 postgresql-contrib-9.3 # Note: The official Debian and Ubuntu images automatically ``apt-get clean`` # after each ``apt-get`` # Run the rest of the commands as the ``postgres`` user created by the ``postgres-9.3`` package when it was ``apt-get installed`` USER postgres # Create a PostgreSQL role named ``docker`` with ``docker`` as the password and # then create a database `docker` owned by the ``docker`` role. # Note: here we use ``&&\`` to run commands one after the other - the ``\`` # allows the RUN command to span multiple lines. RUN /etc/init.d/postgresql start &&\ psql --command "CREATE USER docker WITH SUPERUSER PASSWORD 'docker';" &&\ createdb -O docker docker # Adjust PostgreSQL configuration so that remote connections to the # database are possible. RUN echo "host all all 0.0.0.0/0 md5" >> /etc/postgresql/9.3/main/pg_hba.conf # And add ``listen_addresses`` to ``/etc/postgresql/9.3/main/postgresql.conf`` RUN echo "listen_addresses='*'" >> /etc/postgresql/9.3/main/postgresql.conf # Expose the PostgreSQL port EXPOSE 5432 # Add VOLUMEs to allow backup of config, logs and databases VOLUME ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"] # Set the default command to run when starting the container CMD ["/usr/lib/postgresql/9.3/bin/postgres", "-D", "/var/lib/postgresql/9.3/main", "-c", "config_file=/etc/postgresql/9.3/main/postgresql.conf"] ~~~ 使用Dockerfile构建镜像并且指定名称 ~~~ $ sudo docker build -t eg_postgresql . ~~~ 并且运行PostgreSQL服务容器 ~~~ $ sudo docker run --rm -P --name pg_test eg_postgresql ~~~ 有2种方法可以连接到PostgreSQL服务器。我们可以使用链接容器,或者我们可以从我们的主机(或网络)访问它。 > 注：`--rm`删除容器，当容器存在时成功。 ### [](https://github.com/widuu/chinese_docker/blob/master/examples/postgresql_service.md#使用容器连接)使用容器连接 在客户端`docker run`中直接使用`-link remote_name:local_alias`使容器连接到另一个容器端口。 ~~~ $ sudo docker run --rm -t -i --link pg_test:pg eg_postgresql bash postgres@7ef98b1b7243:/$ psql -h $PG_PORT_5432_TCP_ADDR -p $PG_PORT_5432_TCP_PORT -d docker -U docker --password ~~~ ### 连接到你的主机系统 假设你有安装postgresql客户端,您可以使用主机端口映射测试。您需要使用`docker ps`找出映射到本地主机端口: ~~~ $ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 5e24362f27f6 eg_postgresql:latest /usr/lib/postgresql/ About an hour ago Up About an hour 0.0.0.0:49153->5432/tcp pg_test $ psql -h localhost -p 49153 -d docker -U docker --password ~~~ ### 测试数据 一旦你已经通过身份验证，并且有`docker =#`提示，您可以创建一个表并填充它。 ~~~ psql (9.3.1) Type "help" for help. $ docker=# CREATE TABLE cities ( docker(# name varchar(80), docker(# location point docker(# ); CREATE TABLE $ docker=# INSERT INTO cities VALUES ('San Francisco', '(-194.0, 53.0)'); INSERT 0 1 $ docker=# select * from cities; name | location ---------------+----------- San Francisco | (-194,53) (1 row) ~~~ ### 使用容器卷 您可以使用PostgreSQL卷检查定义日志文件、备份配置和数据: ~~~ $ docker run --rm --volumes-from pg_test -t -i busybox sh / # ls bin etc lib linuxrc mnt proc run sys usr dev home lib64 media opt root sbin tmp var / # ls /etc/postgresql/9.3/main/ environment pg_hba.conf postgresql.conf pg_ctl.conf pg_ident.conf start.conf /tmp # ls /var/log ldconfig postgresql ~~~

非常简单，没有任何修饰，redis是使用一个连接附加到一个web应用程序。 ## 创建一个redis docker容器 首先，我们先为redis创建一个Dockerfile ~~~ FROM ubuntu:12.10 RUN apt-get update RUN apt-get -y install redis-server EXPOSE 6379 ENTRYPOINT ["/usr/bin/redis-server"] ~~~ 现在你需要通过Dockerfile创建一个镜像，将替换成你自己的名字。 ~~~ sudo docker build -t <your username>/redis . ~~~ ## 运行服务 使用我们刚才创建的redis镜像 使用 -d 运行这个服务分离模式，让容器在后台运行。 重要的是我们没有开放容器端口，相反，我们将使用一个容器来连接redis容器数据库 ~~~ sudo docker run -name redis -d <your username>/redis ~~~ ## 创建你的web应用容器 现在我们可以创建我们的应用程序容器，我们使用-link参数来创建一个连接redis容器，我们使用别名db,这将会在redis容器和redis实例容器中创建一个安全的通信隧道 ~~~ sudo docker run -link redis:db -i -t ubuntu:12.10 /bin/bash ~~~ 进入我们刚才创建的容器，我们需要安装redis的redis-cli的二进制包来测试连接 ~~~ apt-get update apt-get -y install redis-server service redis-server stop ~~~ 现在我们可以测试连接，首先我么要先查看下web应用程序容器的环境变量，我们可以用我们的ip和端口来连接redis容器 ~~~ env . . . DB_NAME=/violet_wolf/db DB_PORT_6379_TCP_PORT=6379 DB_PORT=tcp://172.17.0.33:6379 DB_PORT_6379_TCP=tcp://172.17.0.33:6379 DB_PORT_6379_TCP_ADDR=172.17.0.33 DB_PORT_6379_TCP_PROTO=tcp ~~~ 我们可以看到我们有一个DB为前缀的环境变量列表，DB来自指定别名连接我们的现在的容器，让我们使用DB_PORT_6379_TCP_ADDR变量连接到Redis容器。 ~~~ redis-cli -h $DB_PORT_6379_TCP_ADDR redis 172.17.0.33:6379> redis 172.17.0.33:6379> set docker awesome OK redis 172.17.0.33:6379> get docker "awesome" redis 172.17.0.33:6379> exit ~~~ 我们可以很容易的使用这个或者其他环境变量在我们的web应用程序容器上连接到redis容器

### 描述 在这个例子里，我们会学到如何构建一个预装 `MongoDB` 的镜像。我们还将会看到如何推送镜像到 Docker Hub 并分享给其他人。 使用 Docker 容器来部署 [MongoDB](https://www.mongodb.org/) 实例将会给你带来许多好处，例如： * 易于维护、高可配置的 MongoDB 实例 * 准备好运行和毫秒级内开始工作 * 基于全球访问的共享镜像 > 注意: 如果你不喜欢sudo,可以查看[非 root 用户使用](https://github.com/widuu/chinese_docker/blob/master/examples/installation/binaries.md) ### 为 MongoDB 创建一个 Dockerfile 让我们创建一个 `Dockerfile` 并构建： ~~~ $ nano Dockerfile ~~~ 虽然这部分是可选的，但是在 `Dockerfile` 开头处添加注释，可以更好的去解释其目的： ~~~ # Dockerizing MongoDB: Dockerfile for building MongoDB images # Based on ubuntu:latest, installs MongoDB following the instructions from: # http://docs.mongodb.org/manual/tutorial/install-mongodb-on-ubuntu/ ~~~ > 小贴士：`Dockerfile`文件是灵活的。然而，他们遵循一定的格式。第一项定义的是镜像的名称，这里是 Dockerized MongoDB 应用的父镜像。 我们将使用 Docker Hub 中最新版本的 Ubuntu 镜像来构建。 ~~~ # Format: FROM repository[:version] FROM ubuntu:latest ~~~ 继续，我们将在 `Dockerfile` 中指定 `MAINTAINER` ~~~ # Format: MAINTAINER Name <email@addr.ess> MAINTAINER M.Y. Name <myname@addr.ess> ~~~ > 注：尽管 Ubuntu 系统已经有 MongoDB 包，但是它们可能过时，因此，在这个例子中，我们将使用 MongoDB 的官方包。 我们将开始导入 MongoDB 公共 GPG 秘钥。我们还将创建一个 MongoDB 库包管理器 ~~~ # Installation: # Import MongoDB public GPG key AND create a MongoDB list file RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10 RUN echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | tee /etc/apt/sources.list.d/10gen.list ~~~ 这个初步的准备后，我们将更新我们的包并且安装 MongoDB 。 ~~~ # Update apt-get sources AND install MongoDB RUN apt-get update RUN apt-get install -y -q mongodb-org ~~~ > 小贴士: 您可以通过使用所需的软件包版本列表来指定 MongoDB的特定版本,例如: ~~~ RUN apt-get install -y -q mongodb-org=2.6.1 mongodb-org-server=2.6.1 mongodb-org-shell=2.6.1 mongodb-org-mongos=2.6.1 mongodb-org-tools=2.6.1 ~~~ MongoDB 需要数据目录，让我们在最后一步中执行 ~~~ # Create the MongoDB data directory RUN mkdir -p /data/db ~~~ 最后我们设置 `ENTRYPOINT` 指令来告诉 Docker 如何在我们的 MongoDB 镜像容器内运行 `mongod` 。并且我们将使用`EXPOSE` 命令来指定端口： ~~~ # Expose port 27017 from the container to the host EXPOSE 27017 # Set usr/bin/mongod as the dockerized entry-point application ENTRYPOINT usr/bin/mongod ~~~ 现在保存我们的文件并且构建我们的镜像。 > 注：完整版的 `Dockerfile` 可以在这里[下载](https://github.com/widuu/chinese_docker/blob/master/examples/Dockerfile) ### 构建 MongoDB 的 Docker 镜像 我们可以使用我们的 `Dockerfile` 来构建我们的 MongoD B镜像。除非实验，使用 `docker build` 的 `--tag` 参数来给 docker 镜像指定标签始终是一个很好的做法。 ~~~ # Format: sudo docker build --tag/-t <user-name>/<repository> . # Example: $ sudo docker build --tag my/repo . ~~~ 当我们发出这个命令时，Docker 将会通过 `Dockerfile` 来构建镜像。最终镜像将被标记成 `my/repo` 。 ### [](https://github.com/widuu/chinese_docker/blob/master/examples/mongodb.md#推送-mongodb-镜像到-docker-hub)推送 MongoDB 镜像到 Docker Hub `docker push` 命令将会把镜像推送到 Docker Hub 上，你可以在 Docker Hub 上托管和分享推送的镜像。为此，你需要先登录： ~~~ # Log-in $ sudo docker login Username: .. # Push the image # Format: sudo docker push <user-name>/<repository> $ sudo docker push my/repo The push refers to a repository [my/repo] (len: 1) Sending image list Pushing repository my/repo (1 tags) .. ~~~ ### 使用 MongoDB 的镜像 使用我们创建的MongoDB镜像，我们可以运行一个或多个的 MongoDB 守护进程。 ~~~ # Basic way # Usage: sudo docker run --name <name for container> -d <user-name>/<repository> $ sudo docker run --name mongo_instance_001 -d my/repo # Dockerized MongoDB, lean and mean! # Usage: sudo docker run --name <name for container> -d <user-name>/<repository> --noprealloc --smallfiles $ sudo docker run --name mongo_instance_001 -d my/repo --noprealloc --smallfiles # Checking out the logs of a MongoDB container # Usage: sudo docker logs <name for container> $ sudo docker logs mongo_instance_001 # Playing with MongoDB # Usage: mongo --port <port you get from `docker ps`> $ mongo --port 12345 ~~~

# Docker中运行Node.js web应用 > *_注意:——如果你不喜欢 sudo *_,可以查看[使用非root用户](https://github.com/widuu/chinese_docker/blob/master/examples/installation/binaries.md) 这个例子的目的是向您展示如何通过使用 `Dockerfile`来构建自己的docker镜像。我们将在`Centos`上运行一个简单`node.js` web应用并输出'hello word'。您可以在[https://github.com/enokd/docker-node-hello/获得完整的源代码。](https://github.com/enokd/docker-node-hello/%E8%8E%B7%E5%BE%97%E5%AE%8C%E6%95%B4%E7%9A%84%E6%BA%90%E4%BB%A3%E7%A0%81%E3%80%82) ## 创建Node.js应用 首先，先创建一个文件存放目录`src`。然后创建`package.json`文件来描述你的应用程序和依赖关系： ~~~ { "name": "docker-centos-hello", "private": true, "version": "0.0.1", "description": "Node.js Hello world app on CentOS using docker", "author": "Daniel Gasienica <daniel@gasienica.ch>", "dependencies": { "express": "3.2.4" } } ~~~ 然后，创建一个 `index.js` 文件使用 [Express.js](http://expressjs.com/) 框架来创建一个web应用程序: ~~~ var express = require('express'); // Constants var PORT = 8080; // App var app = express(); app.get('/', function (req, res) { res.send('Hello world\n'); }); app.listen(PORT); console.log('Running on http://localhost:' + PORT); ~~~ 在接下来的步骤中，我们将看到如何使用 docker 的 centos 容器来运行这个应用程序。首先，你需要为你的应用程序构建一个 docker 镜像。 ## 创建Dockerfile 创建一个空文件叫`Dockerfile`: ~~~ touch Dockerfile ~~~ 使用你喜欢的编辑器打开Dockerfile 接下来，定义构建自己镜像的顶级镜像。在这里我们使用 Docker Hub 中 Centos（tag：6）镜像： ~~~ FROM centos:6 ~~~ 因为我们要构建一个`Node.js`应用，你需要在你的 `Centos` 镜像中安装Node.js。Node.js运行应用程序需要使用 npm 安装你 package.json 中定义的依赖关系。安装 Centos 包，你可以查看 Node.js 维基指令： ~~~ # Enable EPEL for Node.js RUN rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm # Install Node.js and npm RUN yum install -y npm ~~~ 将你的应用程序源代码添加到你的Docker镜像中，使用`ADD`指令： ~~~ # Bundle app source ADD . /src ~~~ 使用npm安装你的应用程序依赖： ~~~ # Install app dependencies RUN cd /src; npm install ~~~ 应用程序绑定到端口8080，您将使用`EXPOSE`指令对 docker 端口进程映射： ~~~ EXPOSE 8080 ~~~ 最后，定义命令，使用 `CMD` 定义运行时的node服务和应用 `src/index.js`的路径（看我们添加源代码到容器的步骤）： ~~~ CMD ["node", "/src/index.js"] ~~~ 你的`Dockerfile`现在看起来像如下这样： ~~~ FROM centos:centos6 # Enable EPEL for Node.js RUN rpm -Uvh http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm # Install Node.js and npm RUN yum install -y npm # Bundle app source COPY . /src # Install app dependencies RUN cd /src; npm install EXPOSE 8080 CMD ["node", "/src/index.js"] ~~~ ## 创建你的个人镜像 到你的 `Dockerfile` 目录下，运行命令来构建镜像。`-t` 参数给镜像添加标签，为了让我们在 `docker images` 命令更容易查找到它： ~~~ $ sudo docker build -t <your username>/centos-node-hello . ~~~ 你的镜像现在将在列表中： ~~~ $ sudo docker images # Example REPOSITORY TAG ID CREATED centos centos6 539c0211cd76 8 weeks ago <your username>/centos-node-hello latest d64d3505b0d2 2 hours ago ~~~ ## 运行镜像 使用 `-d` 参数来运行你的镜像并将容器在后台运行。使用 `-p` 参数来绑定一个公共端口到私有容器端口上。运行你之前构建的镜像： ~~~ $ sudo docker run -p 49160:8080 -d <your username>/centos-node-hello ~~~ 打印应用输出： ~~~ # Get container ID $ sudo docker ps # Print app output $ sudo docker logs <container id> # Example Running on http://localhost:8080 ~~~ ## 测试 要测试应用程序,先得到 docker 应用程序映射的端口: ~~~ $ sudo docker ps # Example ID IMAGE COMMAND ... PORTS ecce33b30ebf <your username>/centos-node-hello:latest node /src/index.js 49160->8080 ~~~ 在上面的示例中，docker 映射容器的 `49160` 端口到 `8080` 端口。 现在你可以使用`curl`来访问你的app（安装curl：sudo apt-get install curl)： ~~~ $ curl -i localhost:49160 HTTP/1.1 200 OK X-Powered-By: Express Content-Type: text/html; charset=utf-8 Content-Length: 12 Date: Sun, 02 Jun 2013 03:53:22 GMT Connection: keep-alive Hello world ~~~ 如果你使用的是 OS X 的 Boot2docker，实际上端口映射到的是 Docker 虚拟主机，你需要使用如下命令来测试： ~~~ $ curl $(boot2docker ip):49160 ~~~ 我们希望本教程能够帮助您在 Docker 上构建的 `Centos` 镜像来运行Node.js。你可以获得全部源代码[https://github.com/gasi/docker-node-hello](https://github.com/gasi/docker-node-hello)。

## 关于自动化构建 自动化构建是一个特殊的功能，它允许您在 Docker Hub 上使用构建集群，根据指定的 `Dockerfile` 或者 GitHub 、 BitBucket 仓库（或环境）来自动创建镜像。该系统将从仓库复制一份，并根据以仓库为环境的 `Dockerfile` 的描述构建镜像。由此产生的镜像将被上传到注册表，并且自动生成标记。 自动化构建有许多优势： * 你的自动化构建项目一定是准确按照预期构建的 * 在 Docker Hub 注册表上，任何拥有你仓库访问权限的用户都乐意浏览 `Dockerfile` * 自动化构建保证了你的仓库总是最新的 自动化构建支持 [GitHub](http://github.com/) 和 [BitBucket](https://bitbucket.org/) 的私有和公有的仓库。 要使用自动化构建，你必须拥有经过验证有效的 Docker Hub 账户和 GitHub/Bitbucket 账户。 ## 设置GitHub自动化构建 首先，你需要将 GitHub 账户链接到你的 [Docker Hub](https://hub.docker.com/) 账户，以允许注册表查看你的仓库。 > 注：目前我们需要有读写权限以建立 Docker Hub 和 GitHub 的挂钩服务，这是GitHub管理权限的方式，我们别无选择。抱歉！我们将保护您的账户及隐私，确保不会被他人非法获取。 开始构建！登录到你的 Docker Hub 账户，点击屏幕右上方的 "+ Add Repository" 按钮，选择[自动化构建](https://registry.hub.docker.com/builds/add/)。 选择[GitHub服务](https://registry.hub.docker.com/associate/GitHub/) 然后按照说明授权和连接你的 GitHub 账户到 Docker Hub。连接成功后，你就可以选择用来自动化构建的仓库了。 ### 创建一个自动化构建项目 你可以用你的 `Dockerfile` 从你的公共或者私有仓库[创建一个自动化构建项目](https://registry.hub.docker.com/builds/GitHub/select/)。 ### GitHub子模块 如果你的 GitHub 仓库包含了私有子模块的连接，你需要在 Docker Hub 上添加部署秘钥。 部署秘钥位于自动化构建主页的 “Build Details” 菜单。访问设置 GitHub 仓库的页面，选择 “Deploy keys” 来添加秘钥。 | Step | Screenshot | Description | | --- | --- | --- | | 1. |  | 你的自动化构建部署秘钥位于 “Build Details” 菜单的 “Deploy keys” 下。 | | 2. |  | 在你的 GitHub 子模块仓库设置页，添加部署秘钥。 | ### GitHub组织 一旦你的组织成员身份设置为公开，对应的 GitHub 组织状态便会被公开在你的 GitHub 上。为了验证，你可以查看 GitHub 上你的组织的成员选项卡。 ### GitHub服务挂钩 按照以下步骤配置自动化构建的 GitHub 服务挂钩: | Step | Screenshot | Description | | --- | --- | --- | | 1 | [](https://github.com/widuu/chinese_docker/blob/master/images/GitHub_settings.png) | 登录到 GitHub.com，并转到您的仓库页面，点击右侧页面“Settings”。 执行该操作要求你有该仓库的管理员权限。 | | 2 |  | 点击页面左侧的“Webhooks & Services”。 | | 3 |  | 找到 "Docker" 并点击它. | | 4 |  | 确认 "Active" 被选中，然后点击 “Update service” 按钮以保存您的更改。 | ## 设置BitBucket自动化构建 为了设置自动化构建，你需要先把 BitBucket 连接到你的 Docker Hub 账户，以允许其访问你的仓库。 登录到你的 Docker Hub 账户，点击屏幕右上方的 "+ Add Repository" 按钮，选择[自动化构建](https://registry.hub.docker.com/builds/add/)。 选择的 [Bitbucket 服务](https://registry.hub.docker.com/associate/bitbucket/)。 然后按照说明授权和连接你的 Bitbucket 账户到 Docker Hub。连接成功后，你就可以选择用来自动化构建的仓库了。 ### 创建自动化构建项目 你可以用你的 `Dockerfile` 从你的公共或者私有仓库[创建一个自动化构建项目](https://registry.hub.docker.com/builds/bitbucket/select/)。 ### Bitbucket服务挂钩 当你成功连接账户以后，一个 `POST` 挂钩将会自动被添加到你的仓库。请按照以下步骤确认或者更改你的挂钩设置： | Step | Screenshot | Description | | --- | --- | --- | | 1 |  | 登录到 Bitbucket.org 进入仓库页面。点击左侧导航下的 “Settings”。执行该操作要求你有该仓库的管理员权限。 | | 2 |  | 点击左侧 “Settings” 下的 "Hooks"。 | | 3 |  | 现在你应该能看到关联了该仓库的挂钩列表，包括一个指向 registry.hub.docker.com/hooks/bitbucket 的 `POST` 挂钩。 | ## [](https://github.com/widuu/chinese_docker/blob/master/docker-hub/builds.md#dockerfile和自动化构建)Dockerfile和自动化构建 在构建过程中，我们将复制 `Dockerfile` 的内容。我们也将添加它到 Docker Hub 上，使得 Docker 社区（公共仓库）或者得到许可的团队成员可以访问仓库页面。 ## README.md 如果你的仓库有一个 `README.md` 文件，我们将使用它作为仓库的描述。构建过程中会寻找 `Dockerfile` 同一目录下的`README.md`。 > 警告：如果你需要在创建之后修改描述，它会在下一次自动化构建完成之后生效。 ### 建立触发器 如果你需要 GitHub 或者 BitBucket 以外的方式来触发自动化构建，你可以创建一个构建触发器。当你打开构建触发器，它会提供给你一个 url 来发送 POST 请求。这将触发自动化构建过程，类似于 GitHub webhook。 建立触发器可在自动化构建项目的 Settings 菜单中设置。 > 注：你在五分钟内只能触发一个构建，如果你已经进行一个构建，或你最近提交了构建请求，这些请求将被忽略。你可以在设置页面来找到最后10条触发日志来验证是否一切正常工作。 ### Webhooks 也可以使用 Webhooks 来自动化构建，Webhooks 会在仓库推送成功后被调用。 此webhook调用将生成一个 HTTP POST，JSON样例如下： ~~~ { "push_data":{ "pushed_at":1385141110, "images":[ "imagehash1", "imagehash2", "imagehash3" ], "pusher":"username" }, "repository":{ "status":"Active", "description":"my docker repo that does cool things", "is_automated":false, "full_description":"This is my full description", "repo_url":"https://registry.hub.docker.com/u/username/reponame/", "owner":"username", "is_official":false, "is_private":false, "name":"reponame", "namespace":"username", "star_count":1, "comment_count":1, "date_created":1370174400, "dockerfile":"my full dockerfile is listed here", "repo_name":"username/reponame" } } ~~~ Webhooks 可在自动化构建项目的 Settings 菜单中设置。 > 注意：如果你想测试你的 webhook，我们建议使用像 [requestb.in](http://requestb.in/) 的工具。 ### 仓库链接 仓库链接是一种建立自动化项目与项目之间关联的方式。如果一个项目得到更新，连接系统还会触发另一个项目的更新构建。这使得你可以轻松地让所有关联项目保持更新同步。 要添加链接的话，访问你想要添加链接的项目的仓库设置页面，在设置菜单下地右侧点击 “Repository Links”。然后输入你想要与之链接的仓库名称。 > 警告：您可以添加多个仓库的链接，但要小心。自动化构建之间的双向关系会造成一个永不停止的构建循环。

## 搜索仓库和镜像 你可以使用 Docker 来搜索所有公开可用的仓库和镜像。 ~~~ $ docker search ubuntu ~~~ 这将通过 Docker 提供的关键字匹配来显示您可用的仓库列表。 私有仓库将不会显示到仓库搜索结果上。你可以通过 Docker Hub 的简况页面来查看仓库的状态。 ## 仓库 你的 Docker Hub 仓库有许多特性。 ### stars 你的仓库可以用星被标记，你也可以用星标记别的仓库。Stars 也是显示你喜欢这个仓库的一种方法，也是一种简单的方法来标记你喜欢的仓库。 ### 评论 你可以与其他 Docker 社区的成员和维护者留下评论。如果你发现有不当的评论，你可以标记他们以供审核。 ### 合作者及其作用 指定的合作者可以通过你提供的权限访问你的私人仓库。一旦指定，他们可以 `push` 和 `pull` 你的仓库。但他们将不会被允许执行任何管理任务，如从删除仓库或者改变其状态。 > 注：一个合作者不能添加其他合作者。只有仓库的所有者才有管理权限。 你也可以与在 Docker Hub 上的组织和团队进行协作，更多信息。 ## 官方仓库 Docker Hub 包含了许多[官方仓库](http://registry.hub.docker.com/official)。这些都是 Docker 供应商和 Docker 贡献者提供的认证库，他们包含了来自供应商，如 Oracle 和 Red Hat的镜像,您可以使用它们来构建应用程序和服务。 如果使用官方库，供应商会对镜像进行持续维护、升级和优化，从而为项目提供强大的驱动力。 > 注：如果你的组织、产品或者团队想要给官方资源库做贡献。可以再[这里](https://github.com/docker/stackbrew)查看更多信息。 ## 私有Docker仓库 私人仓库用来存储你的私有镜像，前提是你需要一个 Docker 账户，或者你已经属于 Docker Hub 上的某个组织或群组。 要使用 Docker Hub 私有仓库，首先在[这里](https://registry.hub.docker.com/account/repositories/add/)进行添加。你的 Docker Hub 账户会免费获得一个私人仓库。如果你需要更多的账户，你需要升级你的 [Docker Hub 计划](https://registry.hub.docker.com/plans/)。 私有仓库建立好后，你可以使用 Docker 来 `push` 和 `pull` 你的镜像。 > 注：你需要先登录并获得权限来访问你的私人仓库。 私有仓库和公共仓库基本相同，但是以公共身份是无法浏览或者搜索到私有仓库及其内容的，他们也不会以同样的方式被缓存。 在设置页面你可以指定哪些人有权限访问（如合作者），在这里你可以切换仓库状态（公共到私有，或者反过来）。你需要有一个可用的私有仓库，并开启相关设置才能做这样的转换。如果你无法进行相关操作，请升级你的 [Docker Hub 计划](https://registry.hub.docker.com/plans/)。 ## Webhooks 您可以在仓库设置页面来配置你的 webhooks。只有成功 `push` 以后，`webhook` 才会生效。webhooks 会调用 HTTP POST 请求一个json，类似如下所示的例子： > 你可以使用 http 工具进行测试，例如 [requestb.in.](http://requestb.in/) webhook json例子: ~~~ { "push_data":{ "pushed_at":1385141110, "images":[ "imagehash1", "imagehash2", "imagehash3" ], "pusher":"username" }, "repository":{ "status":"Active", "description":"my docker repo that does cool things", "is_automated":false, "full_description":"This is my full description", "repo_url":"https://registry.hub.docker.com/u/username/reponame/", "owner":"username", "is_official":false, "is_private":false, "name":"reponame", "namespace":"username", "star_count":1, "comment_count":1, "date_created":1370174400, "dockerfile":"my full dockerfile is listed here", "repo_name":"username/reponame" } } ~~~ Webhooks 允许你将你镜像和仓库的更新信息通知指定用户、服务以及其他应用程序。

## Docker Hub账户 当没有数字签名和账户的时候，你只能从 [Docker Hub](https://hub.docker.com/) 上 `search` 和 `pull` 一个 Docker 镜像。然后，想要 `push`镜像到服务器、发表评论或者 star 一个仓库，你就需要去创建一个 [Docker Hub](https://hub.docker.com/) 账户。 ### 注册一个Docker Hub账户 你可以通过电子邮件来[注册](https://hub.docker.com/account/signup/)一个 Docker Hub 账户，验证邮箱后即可使用。 ### 电子邮件激活过程 你至少需要有一个有效的电子邮件地址来验证你的账户。如果你未收到验证邮件，你可以通过访问[此页面](https://hub.docker.com/account/resend-email-confirmation/)来请求重新发送确认邮件。 ### 密码重置流程 如果由于某种原因，你忘记密码，不能访问您的账户，你可以从[密码重置页面](https://hub.docker.com/account/forgot-password/)来重置你的密码。 ## 组织&机构 Docker Hub 的机构和群组允许你加入组织和团队。你可以在[这里](https://hub.docker.com/account/organizations/)查看你属于哪个组织，你也可以从选项卡中添加新的组织。  在你的组织中，你可以创建群组，让您进一步管理可以与你的版本库进行交互的人员。 

先来看看 Docker Hub 的界面：  在这个章节，我们来学习 Docker Hub 的相关话题： [账户](39737) 学习如何创建一个Docker Hub账户来管理你的组织和机构。 [仓库](39738) 了解如何分享你 Docker Hub 上的 Docker 镜像，以及如何存储和管理你的私人镜像。 [自动构建](39739) 学习如何自动化构建、部署和管理

现在你已经学习了如何利用命令行在本地运行Docker，还学习了如何[拉取镜像](https://github.com/widuu/chinese_docker/blob/master/userguide/usingdocker.md)用于从现成的镜像中构建容器，并且还学习了如何[创建自己的镜像](https://github.com/widuu/chinese_docker/blob/master/userguide/dockerimages.md)。 接下来，你将会学到如何利用[Docker Hub](https://hub.docker.com/)简化和提高你的Docker工作流程。 [Docker Hub](https://hub.docker.com/)是一个由Docker公司负责维护的公共注册中心，它包含了超过15,000个可用来下载和构建容器的镜像，并且还提供认证、工作组结构、工作流工具（比如webhooks）、构建触发器以及私有工具（比如私有仓库可用于存储你并不想公开分享的镜像）。 ## Docker命令和Docker Hub Docker通过`docer search`、`pull`、`login`和`push`等命令提供了连接Docker Hub服务的功能，本页将展示这些命令如何工作的。 ## 账号注册和登陆 一般，你需要先在docker中心创建一个账户（如果您尚未有）。你可以直接在[Docker Hub](https://hub.docker.com/)创建你的账户，或通过运行： ~~~ $ sudo docker login ~~~ 这将提示您输入用户名，这个用户名将成为你的公共存储库的命名空间名称。如果你的名字可用，docker会提示您输入一个密码和你的邮箱，然后会自动登录到Docker Hub，你现在可以提交和推送镜像到Docker Hub的你的存储库。 > 注：你的身份验证凭证将被存储在你本地目录的`.dockercfg`文件中。 ### 搜索镜像 你可以通过使用搜索接口或者通过使用命令行接口在Docker Hub中搜索，可对镜像名称、用户名或者描述等进行搜索： ~~~ $ sudo docker search centos NAME DESCRIPTION STARS OFFICIAL TRUSTED centos Official CentOS 6 Image as of 12 April 2014 88 tianon/centos CentOS 5 and 6, created using rinse instea... 21 ... ~~~ 这里你可以看到两个搜索的示例结果：`centos`和`tianon/centos`。第二个结果是从名为`tianon/`的用户仓储库搜索到的，而第一个结果`centos`没有用户空间这就意味着它是可信的顶级命名空间。`/`字符分割用户镜像和存储库的名称。 当你发现你想要的镜像时，便可以用`docker pull `来下载它。 ~~~ $ sudo docker pull centos Pulling repository centos 0b443ba03958: Download complete 539c0211cd76: Download complete 511136ea3c5a: Download complete 7064731afe90: Download complete ~~~ 现在你有一个镜像，基于它你可以运行容器。 ## 向Docker Hub贡献 任何人都可以从`Docker Hub`仓库下载镜像，但是如果你想要分享你的镜像，你就必须先注册，就像你在[第一部分的docker用户指南](https://github.com/widuu/chinese_docker/blob/master/userguide/dockerhub.md)看到的一样。 ## 推送镜像到Docker Hub 为了推送到仓库的公共注册库中，你需要一个命名的镜像或者将你的容器提到为一个命名的镜像，正像[这里](https://github.com/widuu/chinese_docker/blob/master/userguide/docerimages.md)我们所看到的。 你可以将此仓库推送到公共注册库中，并以镜像名字或者标签来对其进行标记。 ~~~ $ sudo docker push yourname/newimage ~~~ 镜像上传之后你的团队或者社区的人都可以使用它。 ## Docker Hub特征 让我们再进一步看看Docker Hub的特色，[这里](http://docs.docker.com/docker-hub/)你可以看到更多的信息。 * 私有仓库 * 组织和团队 * 自动构建 * Webhooks ## 私有仓库 有时候你不想公开或者分享你的镜像，所以Docker Hub允许你有私有仓库，你可以在[这里](https://registry.hub.docker.com/plans/)登录设置它。 ## 组织和机构 私人仓库一个较有用的地方在于你可以将仓库分享给你团队或者你的组织。Docker Hub支持创建组织，这样你可以和你的同事来管理你的私有仓库，在[这里](https://registry.hub.docker.com/account/organizations/)你可以学到如何创建和管理一个组织。 ## 自动构建 自动构建功能会自动从[Github](https://www.github.com/)和[BitBucket](http://bitbucket.com/)直接将镜像构建或更新至Docker Hub，通过为Github或Bitbucket的仓库添加一个提交的hook来实现，当你推送提交的时候就会触发构建和更新。 设置一个自动化构建你需要： * 1.创建一个[Docker Hub](https://hub.docker.com/)账户并且登陆 * 2.通过[Link Accounts](https://registry.hub.docker.com/account/accounts/)菜单连接你的GitHub或者BitBucket * 3.[配置自动化构建](https://registry.hub.docker.com/builds/add/) * 4.选择一个包含`Dockerfile`的Github或BitBucket项目 * 5.选择你想用于构建的分支（默认是`master`分支） * 6.给自动构建创建一个名称 * 7.指定一个Docker标签来构建 * 8.指定`Dockerfile`的路径，默认是`/`。 一旦配置好自动构建，在几分钟内就会自动触发构建，你就会在[Docker Hub](https://hub.docker.com/)仓库源看到你新的构建，并且它将会和你的Github或者BitBucket保持同步更新直到你解除自动构建。 如果你想看到你自动化构建的状态，你可以去你的Docker Hub[自动化构建页面](https://registry.hub.docker.com/builds/)，它将会想你展示你构建的状态和构建历史。 一旦你创建了一个自动化构建，你可以禁用或删除它。但是，你不能通过`docker push`推送一个自动化构建，而只能通过在Github或者BitBucket提交你的代码来管理它。 你可以在一个仓库中创建多个自动构建，配置它们只指定的`Dockerfile`或Git 分支。 ## 构建触发器 自动构建也可以通过Docker Hub的Url来触发，这样你就可以通过命令重构自动构建镜像。 ## Webhooks webhooks属于你的存储库的一部分，当一个镜像更新或者推送到你的存储库时允许你触发一个事件。当你的镜像被推送的时候，webhook可以根据你指定的url和一个有效的Json来递送。

到目前为止，我们已经介绍了docker的一些基本概念，了解了如何使用docker镜像，以及容器之间如何通过网络连接。本节，我们来讨论如何管理容器和容器间的共享数据。 接下来，我们将主要介绍Docker管理数据的两种主要的方法： * 数据卷 * 数据卷容器 ## 数据卷 数据卷是指在存在于一个或多个容器中的特定目录，此目录能够绕过[Union File System](http://docs.docker.com/terms/layer/#ufs-def)提供一些用于持续存储或共享数据的特性。 * 数据卷可在容器之间共享或重用 * 数据卷中的更改可以直接生效 * 数据卷中的更改不会包含在镜像的更新中 * 数据卷的生命周期一直持续到没有容器使用它为止 ## 添加一个数据卷 你可以在`docker run`命令中使用`-v`标识来给容器内添加一个数据卷，你也可以在一次`docker run`命令中多次使用`-v`标识挂载多个数据卷。现在我们在web容器应用中创建单个数据卷。 ~~~ $ sudo docker run -d -P --name web -v /webapp training/webapp python app.py ~~~ 这会在容器内部创建一个新的卷`/webapp` > 注：类似的，你可以在`Dockerfile`中使用`VOLUME`指令来给创建的镜像添加一个或多个数据卷。 ## 挂载一个主机目录作为卷 使用`-v`，除了可以创建一个数据卷，还可以挂载本地主机目录到容器中： ~~~ $ sudo docker run -d -P --name web -v /src/webapp:/opt/webapp training/webapp python app.py ~~~ 这将会把本地目录`/src/webapp`挂载到容器的`/opt/webapp`目录。这在做测试时是非常有用的，例如我们可以挂载宿主机的源代码到容器内部，这样我们就可以看到改变源代码时的应用时如何工作的。宿主机上的目录必须是绝对路径，如果目录不存在docker会自动创建它。 > 注：出于可移植和分享的考虑，这种方法不能够直接在`Dockerfile`中实现。作为宿主机目录——其性质——是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。 docker默认情况下是对数据卷有读写权限，但是我们通过这样的方式让数据卷只读： ~~~ $ sudo docker run -d -P --name web -v /src/webapp:/opt/webapp:ro training/webapp python app.py ~~~ 这里我们同样挂载了`/src/webapp`目录，只是添加了`ro`选项来限制它只读。 ## 将宿主机上的特定文件挂载为数据卷 除了能挂载目录外，`-v`标识还可以将宿主机的一个特定文件挂载为数据卷： ~~~ $ sudo docker run --rm -it -v ~/.bash_history:/.bash_history ubuntu /bin/bash ~~~ 上述命令会在容器中运行一个bash shell，当你退出此容器时在主机上也能够看到容器中bash的命令历史。 > 注：很多文件编辑工具如`vi`和`sed --in-place`会导致inode change。Docker v1.1.0之后的版本，会产生一个错误：“sed cannot rename ./sedKdJ9Dy: Device or resource busy”。这种情况下如果想要更改挂载的文件，最好是直接挂载它的父目录。 ## 创建、挂载数据卷容器 如果你想要容器之间数据共享，或者从非持久化容器中使用一些持久化数据，最好创建一个指定名称的数据卷容器，然后用它来挂载数据。 让我们创建一个指定名称的数据卷容器： ~~~ $ sudo docker run -d -v /dbdata --name dbdata training/postgres echo Data-only container for postgres ~~~ 你可以在另外一个容器使用`--volumes-from`标识，通过刚刚创建的数据卷容器来挂载对应的数据卷。 ~~~ $ sudo docker run -d --volumes-from dbdata --name db1 training/postgres ~~~ 可以将对应的数据卷挂载到更多的容器中： ~~~ $ sudo docker run -d --volumes-from dbdata --name db2 training/postgres ~~~ 当然，您也可以对一个容器使用多个`--volumes-from`标识，来将多个数据卷桥接到这个容器中。 数据卷容器是可以进行链式扩展的，之前的`dbdata`数据卷依次挂载到了dbdata 、db1和db2容器，我们还可以使用这样的方式来将数据卷挂载到新的容器db3： ~~~ $ sudo docker run -d --name db3 --volumes-from db1 training/postgres ~~~ 即使你删除所有de 挂载了数据卷dbdata的容器（包括最初的`dbdata`容器和后续的`db1`和`db2`），数据卷本身也不会被删除。要删在磁盘上删除这个数据卷，只能针对最后一个挂载了数据卷的容器显式地调用`docker rm -v`命令。这种方式可使你在容器之间方便的更新和迁移数据。 ## 备份、恢复或者迁移数据卷 数据卷还可以用来备份、恢复或迁移数据。为此我们使用`--volumes-from`参数来创建一个挂载数据卷的容器，像这样： ~~~ $ sudo docker run --volumes-from dbdata -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /dbdata ~~~ 这里我们启动了一个挂载`dbdata`卷的新容器，并且挂载了一个本地目录作为`/backup`卷。最后，我们通过使用tar命令将`dbdata`卷的内容备份到容器中的`/backup`目录下的`backup.tar`文件中。当命令完成或者容器停止，我们会留下我们的`dbdata`卷的备份。 然后，你可以在同一容器或在另外的容器中恢复此数据。创建一个新的容器 ~~~ $ sudo docker run -v /dbdata --name dbdata2 ubuntu /bin/bash ~~~ 然后在新的容器中的数据卷里un-tar此备份文件。 ~~~ $ sudo docker run --volumes-from dbdata2 -v $(pwd):/backup busybox tar xvf /backup/backup.tar ~~~ 你可以对熟悉的目录应用此技术，来测试自动备份、迁移和恢复。

在使用[ Docker 部分](https://github.com/widuu/chinese_docker/blob/master/userguide/usingdocker.md), 我们谈到了如何通过网络端口来访问运行在 Docker 容器内的服务。这是与docker容器内运行应用程序交互的一种方法。在本节中，我们打算通过端口连接到一个docker容器，并向您介绍容器连接概念。 ## 网络端口映射 在[使用docker](https://github.com/widuu/chinese_docker/blob/master/userguide/usingdocker.md)部分,我们创建了一个python应用的容器。 ~~~ $ sudo docker run -d -P training/webapp python app.py ~~~ > 注：容器有一个内部网络和IP地址（在使用Docker部分我们使用`docker inspect`命令显示容器的IP地址）。Docker可以有各种网络配置方式。你可以再这里学到更多docker网络信息。 我们使用`-P`标记创建一个容器，将容器的内部端口随机映射到主机的高端口49000到49900。这时我们可以使用`docker ps`来看到端口5000绑定主机端口49155。 ~~~ $ sudo docker ps nostalgic_morse CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES bc533791f3f5 training/webapp:latest python app.py 5 seconds ago Up 2 seconds 0.0.0.0:49155->5000/tcp nostalgic_morse ~~~ 我们也可以使用`-p`标识来指定容器端口绑定到主机端口 ~~~ $ sudo docker run -d -p 5000:5000 training/webapp python app.py ~~~ 我们看这为什么不是一个好的主意呢？因为它限制了我们容器的一个端口。 我们还有很多设置`-p`标识的方法。默认`-p`标识会绑定本地主机上的指定端口。并且我们可以指定绑定的网络地址。举例设置`localhost` ~~~ $ sudo docker run -d -p 127.0.0.1:5001:5002 training/webapp python app.py ~~~ 这将绑定容器内部5002端口到主机的`localhost`或者`127.0.0.1`的5001端口。 如果要绑定容器端口5002到宿主机动态端口，并且让`localhost`访问，我们可以这样做： ~~~ $ sudo docker run -d -p 127.0.0.1::5002 training/webapp python app.py ~~~ 我们也可以绑定UDP端口，我们可以在后面添加`/udp`,举例： ~~~ $ sudo docker run -d -p 127.0.0.1:5000:5000/udp training/webapp python app.py ~~~ 我们可以使用`docker port`快捷方式来绑定我们的端口，这有助于向我们展示特定的端口。例如我们绑定`localhost`,如下是`docker port`输出： ~~~ $ docker port nostalgic_morse 5000 127.0.0.1:49155 ~~~ > 注：`-p`可以使用多次配置多个端口。 ## Docker容器连接 端口映射并不是唯一把docker连接到另一个容器的方法。docker有一个连接系统允许将多个容器连接在一起，共享连接信息。docker连接会创建一个父子关系，其中父容器可以看到子容器的信息。 ### 容器命名 执行此连接需要依靠你的docker的名字，这里我们可以看到当我们创建每一个容器的时候，它都会自动被命名。事实上我们已经熟悉了老的`nostalgic_morse`指南。你也可以自己命名容器。这种命名提供了两个有用的功能： * 1.给容器特定的名字使你更容易记住他们，例如：命名web应用程序为web容器。 * 2.它为docker提供一个参考，允许其他容器引用，举例连接web容器到db容器。 你可以使用`--name`标识来命名容器，举例： ~~~ $ sudo docker run -d -P --name web training/webapp python app.py ~~~ 我们可以看到我们启动了的容器，就是我们使用`--name`标识命名为`web`的容器。我们可以使用`docker ps`命令来查看容器名称。 ~~~ $ sudo docker ps -l CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES aed84ee21bde training/webapp:latest python app.py 12 hours ago Up 2 seconds 0.0.0.0:49154->5000/tcp web ~~~ 我们也可以使用`docker inspect`来返回容器名字。 ~~~ $ sudo docker inspect -f "{{ .Name }}" aed84ee21bde /web ~~~ > 注：容器的名称必须是唯一的。这意味着你只能调用一个web容器。如果你想使用重复的名称来命名容器，你需要使用`docker rm`命令删除以前的容器。在容器停止后删除。 ## 容器连接 连接允许容器之间可见并且安全地进行通信。使用`--link`创建连接。我们创建一个新容器，这个容器是数据库。 ~~~ $ sudo docker run -d --name db training/postgres ~~~ 这里我们使用`training/postgres`容器创建一个新的容器。容器是PostgreSQL数据库。 现在我们创建一个`web`容器来连接`db`容器。 ~~~ $ sudo docker run -d -P --name web --link db:db training/webapp python app.py ~~~ 这将使我们的web容器和db容器连接起来。`--link`的形式 ~~~ --link name:alias ~~~ `name`是我们连接容器的名字，`alias`是link的别名。让我们看如何使用alias。 让我们使用`docker ps`来查看容器连接. ~~~ $ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 349169744e49 training/postgres:latest su postgres -c '/usr About a minute ago Up About a minute 5432/tcp db aed84ee21bde training/webapp:latest python app.py 16 hours ago Up 2 minutes 0.0.0.0:49154->5000/tcp db/web,web ~~~ 我们可以看到我们命名的容器，`db`和`web`，我们还在名字列中可以看到web容器也显示`db/web`。这告诉我们web容器和db容器是父/子关系。 我们连接容器做什么？我们发现连接的两个容器是父子关系。这里的父容器是`db`可以访问子容器`web`。为此docker在容器之间打开一个安全连接隧道不需要暴露任何端口在容器外部。你会注意到当你启动db容器的时候我们没有使用`-P`或者`-p`标识。我们连接容器的时候我们不需要通过网络给PostgreSQL数据库开放端口。 Docker在父容器中开放子容器连接信息有两种方法： * 环境变量 * 更新`/etc/hosts`文件。 让我们先看看docker的环境变量。我们运行`env`命令来查看列表容器的环境变量。 ~~~ $ sudo docker run --rm --name web2 --link db:db training/webapp env . . . DB_NAME=/web2/db DB_PORT=tcp://172.17.0.5:5432 DB_PORT_5000_TCP=tcp://172.17.0.5:5432 DB_PORT_5000_TCP_PROTO=tcp DB_PORT_5000_TCP_PORT=5432 DB_PORT_5000_TCP_ADDR=172.17.0.5 . . . ~~~ > 注：这些环境变量只设置顶一个进程的容器。同样，一些守护进程(例如sshd)进行shell连接时就会去除。 我们可以看到docker为我们的数据库容器创建了一系列环境变量。每个前缀变量是`DB_`填充我们指定的别名。如果我们的别名是`db1`，前缀别名就是`DB1_`。您可以使用这些环境变量来配置您的应用程序连接到你的数据库db容器。该连接时安全、私有的，只能在web容器和db容器之间通信。 docker除了环境变量，可以添加信息到父主机的`/etc/hosts` ~~~ root@aed84ee21bde:/opt/webapp# cat /etc/hosts 172.17.0.7 aed84ee21bde . . . 172.17.0.5 db ~~~ 这里我们可以看到两个主机项。第一项是web容器用容器ID作为主机名字。第二项是使用别名引用IP地址连接数据库容器。现在我们试试ping这个主机： ~~~ root@aed84ee21bde:/opt/webapp# apt-get install -yqq inetutils-ping root@aed84ee21bde:/opt/webapp# ping db PING db (172.17.0.5): 48 data bytes 56 bytes from 172.17.0.5: icmp_seq=0 ttl=64 time=0.267 ms 56 bytes from 172.17.0.5: icmp_seq=1 ttl=64 time=0.250 ms 56 bytes from 172.17.0.5: icmp_seq=2 ttl=64 time=0.256 ms ~~~ > 注：我们不得不安装`ping`，因为容器内没有它。 我们使用`ping`命令来ping`db`容器，使用它解析到`127.17.0.5`主机。我们可以利用这个主机项配置应用程序来使用我们的`db`容器。 > 注：你可以使用一个父容器连接多个子容器。例如，我们可以有多个web容器连接到我们的db数据库容器。

在[了解Docker](https://github.com/widuu/chinese_docker/blob/master/userguide)这部分中，我们知道了 Docker 镜像是容器的基础。。在[前面的部分](https://github.com/widuu/chinese_docker/blob/master/userguide/dockerizing.md)我们使用的是已经构建好的 Docker 镜像，例如： `ubuntu` 镜像和 `training/webapp` 镜像。 我们还了解到 Docker 商店下载镜像到本地的 Docker 主机上。如果一个镜像不存在，他就会自动从 Docker 镜像仓库去下载，默认是从 `Docker Hub` 公共镜像源下载。 在这一节中，我们将探讨更多的关于 Docker 镜像的东西： * 管理和使用本地 Docker 主机镜像。 * 创建基本镜像 * 上传 Docker 镜像到 [Docker Hub Registry](https://registry.hub.docker.com/)。 ## 在主机上列出镜像列表 让我们列出本地主机上的镜像。你可以使用 `docker images` 来完成这项任务： ~~~ $ sudo docker images REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE training/webapp latest fc77f57ad303 3 weeks ago 280.5 MB ubuntu 13.10 5e019ab7bf6d 4 weeks ago 180 MB ubuntu saucy 5e019ab7bf6d 4 weeks ago 180 MB ubuntu 12.04 74fe38d11401 4 weeks ago 209.6 MB ubuntu precise 74fe38d11401 4 weeks ago 209.6 MB ubuntu 12.10 a7cf8ae4e998 4 weeks ago 171.3 MB ubuntu quantal a7cf8ae4e998 4 weeks ago 171.3 MB ubuntu 14.04 99ec81b80c55 4 weeks ago 266 MB ubuntu latest 99ec81b80c55 4 weeks ago 266 MB ubuntu trusty 99ec81b80c55 4 weeks ago 266 MB ubuntu 13.04 316b678ddf48 4 weeks ago 169.4 MB ubuntu raring 316b678ddf48 4 weeks ago 169.4 MB ubuntu 10.04 3db9c44f4520 4 weeks ago 183 MB ubuntu lucid 3db9c44f4520 4 weeks ago 183 MB ~~~ 我们可以看到之前使用的镜像。当我们每次要使用镜像启动一个容器的时候都会从 [Docker Hub](https://hub.docker.com/) 下载对应的镜像。 我们在镜像列表中看到三个至关重要的东西。 * 来自什么镜像源，例如 `ubuntu` * 每个镜像都有标签(tags)，例如 `14.04` * 每个镜像都有镜像ID 镜像源中可能存储这一个镜像源的多个版本。我们会看到 `Ubuntu` 的多个版本：10.04, 12.04, 12.10, 13.04, 13.10 and 14.04。每个容器有一个唯一的标签，让我们来识别为不同的镜像，例如： ~~~ ubuntu:14.04 ~~~ 所以我们可以运行一个带标签镜像的容器： ~~~ $ sudo docker run -t -i ubuntu:14.04 /bin/bash ~~~ 如果我们想要使用 `Ubuntu 12.04` 的镜像来构建，我们可以这样做 ~~~ $ sudo docker run -t -i ubuntu:12.04 /bin/bash ~~~ 如果你不指定一个镜像的版本标签，例如你只使用 `Ubuntu`，Docker将默认使用 `Ubuntu:latest` 镜像。 > 提示：我们建议使用镜像时指定一个标签，例如 `ubuntu:12.04` 。这样你知道你使用的是一个什么版本的镜像。 ## 获取一个新的镜像 现在如何获取一个新的镜像？当我们在本地主机上使用一个不存在的镜像时 Docker 就会自动下载这个镜像。但是这需要一段时间来下载这个镜像。如果我们想预先下载这个镜像，我们可以使用`docker pull`命令来下载它。这里我们下载`centos` 镜像。 ~~~ $ sudo docker pull centos Pulling repository centos b7de3133ff98: Pulling dependent layers 5cc9e91966f7: Pulling fs layer 511136ea3c5a: Download complete ef52fb1fe610: Download complete . . . ~~~ 我们看到镜像的每一层都被下载下来了，现在我们可以直接使用这个镜像来运行容器，而不需要在下载这个镜像了。 ~~~ $ sudo docker run -t -i centos /bin/bash bash-4.1# ~~~ ## 查找镜像 Docker 的特点之一是人们创建了各种各样的 Docker 镜像。而且这些镜像已经被上传到了 `Docker Hub` 。我们可以从`Docker Hub` 网站来搜索镜像。  我们也可以使用 `docker search` 命令来搜索镜像。譬如说我们的团队需要一个安装了 Ruby 和 Sinatra 的镜像来做我们的 web 应用程序开发。我们可以通过 `docker search` 命令来搜索所有的`sinatra` 来寻找适合我们的镜像 ~~~ $ sudo docker search sinatra NAME DESCRIPTION STARS OFFICIAL AUTOMATED training/sinatra Sinatra training image 0 [OK] marceldegraaf/sinatra Sinatra test app 0 mattwarren/docker-sinatra-demo 0 [OK] luisbebop/docker-sinatra-hello-world 0 [OK] bmorearty/handson-sinatra handson-ruby + Sinatra for Hands on with D... 0 subwiz/sinatra 0 bmorearty/sinatra 0 . . . ~~~ 我们看到了返回了大量的 `sinatra`镜像。我们看到列表中有镜像名称、描述、Stars(衡量镜像的流行程度-如果用户喜欢这个镜像他就会点击 stars )和 是否是正式以及构建状态。[官方镜像仓库](https://docs.docker.com/docker-hub/official_repos/) 是官方精心整理出来服务 Docker 的 Docker 镜像库。自动化构建的镜像仓库是允许你验证镜像的内容和来源。 ## 翻译到这里 我们回顾以前使用的镜像，我们决定使用`sinatra`镜像。到目前为止，我们已经看到了两种类型的镜像，像`ubuntu`镜像，我们称它为基础镜像或者根镜像。这些镜像是由docker公司提供建立、验证和支持。这些镜像都可以通过自己的名字来标示。 我们还可以看到用户的镜像，例如`training/sinatra`,并且我们可以使用`docker pull`命令来下载它。 ~~~ $ sudo docker pull training/sinatra ~~~ 现在我们的团队可以在自己的容器内使用这个镜像了。 ~~~ $ sudo docker run -t -i training/sinatra /bin/bash root@a8cb6ce02d85:/# ~~~ ## 创建自己的镜像 我们的团队发现`training/sinatra`镜像虽然有用但是不是我们需要的，我们需要针对这个镜像做出更改。现在又两种方法，我们可以更新和创建镜像。 * 1.我们可以从已经创建的容器中更新镜像，并且提交这个镜像。 * 2.我们可以使用`Dockerfile`指令来创建一个镜像。 ## 更新并且提交镜像 更新一个镜像，首先我们要创建一个我们想更新的容器。 ~~~ $ sudo docker run -t -i training/sinatra /bin/bash root@0b2616b0e5a8:/# ~~~ > 注意：创建容器ID`0b2616b0e5a8`,我们在后边还需要使用它。 在我们的容器内添加`json` ~~~ root@0b2616b0e5a8:/# gem install json ~~~ 当我们完成的时候，输入`exit`命令来退出这个容器。 现在我们有一个根据我们需求做出改变的容器。我们可以使用`docker commit`来提交这个容器。 ~~~ $ sudo docker commit -m="Added json gem" -a="Kate Smith" \ 0b2616b0e5a8 ouruser/sinatra:v2 4f177bd27a9ff0f6dc2a830403925b5360bfe0b93d476f7fc3231110e7f71b1c ~~~ 这里我们使用了`docker commit`命令。我们可以指定`-m`和`-a`标示。`-m`标示是允许我们指定提交的信息，就像你提交一个版本控制。`-a`标示允许对我们的更新指定一个用户。 我们也指定了我们想要创建的新镜像来自(我们先前记录的ID)`0b2616b0e5a8`和我们指定的目标镜像： ~~~ ouruser/sinatra:v2 ~~~ 让我们分解这个步骤。我们先给这个镜像分配了一个新用户名字`ouruser`；接着，未修改镜像名称，保留了原镜像名称`sinatra`；最后为镜像指定了标签`v2`。 我们可以使用`docker images`命令来查看我们的新镜像`ouruser/sinatra`。 ~~~ $ sudo docker images REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE training/sinatra latest 5bc342fa0b91 10 hours ago 446.7 MB ouruser/sinatra v2 3c59e02ddd1a 10 hours ago 446.7 MB ouruser/sinatra latest 5db5f8471261 10 hours ago 446.7 MB ~~~ 使用我们的新镜像来创建一个容器： ~~~ $ sudo docker run -t -i ouruser/sinatra:v2 /bin/bash root@78e82f680994:/# ~~~ ## 使用`Dockerfile`创建镜像 使用`docker commit`命令能非常简单的扩展镜像，但是它有点麻烦：在一个团队中不容易共享它的开发过程。为解决这个问题，我们可以使用一个新的命令来创建新的镜像。 为此，我们创建一个`Dockerfile`，其中包含一组指令告诉docker如何创建我们的镜像。 现在让我们创建一个目录，并且创建一个`Dockerfile` ~~~ $ mkdir sinatra $ cd sinatra $ touch Dockerfile ~~~ 每一个指令镜像就会创建一个新的层，让我们看一个简单的例子，我们的开发团建创建一个自己的`Sinatra`镜像： ~~~ # This is a comment FROM ubuntu:14.04 MAINTAINER Kate Smith <ksmith@example.com> RUN apt-get -qq update RUN apt-get -qqy install ruby ruby-dev RUN gem install sinatra ~~~ 【注意】： 1）、每个指令前缀都必须大写： INSTRUCTION statement 2）、可以使用`#`注释； 让我们看看`Dockerfile`做了什么： 第一个指令`FROM`，告诉Docker使用哪个镜像源，在这个案例中我们使用了一个`Ubuntu 14.04`基础镜像。 下一步，我们使用`MAINTAINER`指令指定谁是维护者。 最后，我们指定三个`RUN`指令，一个`RUN`指令在镜像内执行命令。例如安装包。这里我们在`Sinatra`中更新了APT缓存，安装了`Ruby`和`RubyGems`。 > 注意：我们还提供了更多的Dockerfile指令参数。 现在我们使用`docker build`命令和`Dockerfile`命令来创建一个镜像。 ~~~ $ sudo docker build -t="ouruser/sinatra:v2" . Uploading context 2.56 kB Uploading context Step 0 : FROM ubuntu:14.04 ---> 99ec81b80c55 Step 1 : MAINTAINER Kate Smith <ksmith@example.com> ---> Running in 7c5664a8a0c1 ---> 2fa8ca4e2a13 Removing intermediate container 7c5664a8a0c1 Step 2 : RUN apt-get -qq update ---> Running in b07cc3fb4256 ---> 50d21070ec0c Removing intermediate container b07cc3fb4256 Step 3 : RUN apt-get -qqy install ruby ruby-dev ---> Running in a5b038dd127e Selecting previously unselected package libasan0:amd64. (Reading database ... 11518 files and directories currently installed.) Preparing to unpack .../libasan0_4.8.2-19ubuntu1_amd64.deb ... . . . Setting up ruby (1:1.9.3.4) ... Setting up ruby1.9.1 (1.9.3.484-2ubuntu1) ... Processing triggers for libc-bin (2.19-0ubuntu6) ... ---> 2acb20f17878 Removing intermediate container a5b038dd127e Step 4 : RUN gem install sinatra ---> Running in 5e9d0065c1f7 . . . Successfully installed rack-protection-1.5.3 Successfully installed sinatra-1.4.5 4 gems installed ---> 324104cde6ad Removing intermediate container 5e9d0065c1f7 Successfully built 324104cde6ad ~~~ 我们使用`docker build`命令和`-t`来创建我们的新镜像，用户是`ouruser`、仓库源名称`sinatra`、标签是`v2`。 如果`Dockerfile`在我们当前目录下，我们可以使用`.`来指定`Dockerfile` > 提示：你也可以指定`Dockerfile`路径 现在我们可以看到构建过程。docker做的第一件事是通过你的上下文构建。基本上是目录的内容构建。docker会根据本地的内容来在docker进程中去构建。 下一步，我们`Dockerfile`一步一步执行命令。我们可以看到，每个步骤可以创建一个新的容器，在容器内运行指令并且提交改变，就像我们早期看到的`docker commit`流程、当所有的指令执行完成之后，我们就会得到`324104cde6ad`镜像（有助于标记ouruser/sinatra:v2）,然后所有中间容器会被删除干净。 我们可以从我们的新镜像中创建一个容器： ~~~ $ sudo docker run -t -i ouruser/sinatra:v2 /bin/bash root@8196968dac35:/# ~~~ > 注意：这是比较简单的创建镜像方法。我们跳过了你可以使用的一大堆指令。在后面的部门我们将会看到更多的指令指南，或者你可以参考`Dockerfile`参考的例子和详细描述每一个指令。 ## 设置镜像标签 你可以给现有的镜像添加标记，然后提交和构建。我们可以使用`docker tag`命令。让我们给`ouruser/sinatra`镜像添加一个新的标签。 ~~~ $ sudo docker tag 5db5f8471261 ouruser/sinatra:devel ~~~ `docker tag`指令标记镜像ID，这里是`5db5f8471261`,设定我们的用户名称、镜像源名称和新的标签。 让我们使用`docker images`命令查看新的标签。 ~~~ $ sudo docker images ouruser/sinatra REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE ouruser/sinatra latest 5db5f8471261 11 hours ago 446.7 MB ouruser/sinatra devel 5db5f8471261 11 hours ago 446.7 MB ouruser/sinatra v2 5db5f8471261 11 hours ago 446.7 MB ~~~ ## 向Docker Hub推送镜像 一旦你构建或创造一个新的镜像，你可以使用`docker push`命令推送到Docker Hub。可以对其他人公开进行分享，或把它添加到你的私人仓库中。 ~~~ $ sudo docker push ouruser/sinatra The push refers to a repository [ouruser/sinatra] (len: 1) Sending image list Pushing repository ouruser/sinatra (3 tags) . . . ~~~ ## 主机中移除镜像 你也可以删除你主机上的镜像，某种程度上我们可以使用`docker rmi`命令。 让我们删除已经不需要的容器：`training/sinatra`。 ~~~ $ sudo docker rmi training/sinatra Untagged: training/sinatra:latest Deleted: 5bc342fa0b91cabf65246837015197eecfa24b2213ed6a51a8974ae250fedd8d Deleted: ed0fffdcdae5eb2c3a55549857a8be7fc8bc4241fb19ad714364cbfd7a56b22f Deleted: 5c58979d73ae448df5af1d8142436d81116187a7633082650549c52c3a2418f0 ~~~ > 提示：在容器从主机中移除前，请确定容器没有被使用。

在上一节的 Docker 用户指南中，我们启动了我们的第一个容器。而后边的例子中我们使用 `docker run` 命令启动了两个容器 * 与前台进行交互的容器 * 以进程方式在后台运行的容器 在这个过程中，我们学习到了几个 Docker 命令： * `docker ps` 列出容器 * `docker logs` 显示容器的标准输出 * `docker stop` 停止正在运行的容器 > 提示：另一种学习 `docker` 命令的方式就是查看我们的 [交互式教程页面。](https://www.docker.com/tryit/) `docker` 客户端非常简单 。Docker 的每一项操作都是通过命令行来实现的，而每一条命令行都可以使用一系列的标识（flags）和参数。 ~~~ # Usage: [sudo] docker [flags] [command] [arguments] .. # Example: $ docker run -i -t ubuntu /bin/bash ~~~ 让我们看看这个使用 `docker version` 命令的操作，它将返回当前安装的 Docker 客户端和进程的版本信息。 ~~~ $ sudo docker version ~~~ 这个命令不仅返回了您使用的 Docker 客户端和进程的版本信息，还返回了 GO 语言的版本信息( Docker的编程语言 )。 ~~~ Client version: 0.8.0 Go version (client): go1.2 Git commit (client): cc3a8c8 Server version: 0.8.0 Git commit (server): cc3a8c8 Go version (server): go1.2 Last stable version: 0.8.0 ~~~ ## 查看一下 Docker 客户端都能做什么 我们可以通过只输入不附加任何参数的 `docker` 命令来运行 docker 二进制文件，这样我们就会查看到 Docker 客户端的所有命令选项。 ~~~ $ sudo docker ~~~ 会看到当前可用的所有命令行列表： ~~~ Commands: attach Attach to a running container build Build an image from a Dockerfile commit Create a new image from a container's changes . . . ~~~ ## 查看 Docker 命令用法 你可以更深入的去了解指定的 Docker 命令使用方法。 试着输入 Docker `[command]`，这里会看到 docker 命令的使用方法： ~~~ $ sudo docker attach Help output . . . ~~~ 或者你可以通过在 docker 命令中使用 `--help` 标识(flags) ~~~ $ sudo docker images --help ~~~ 这将返回所有的帮助信息和可用的标识(flags)： ~~~ Usage: docker attach [OPTIONS] CONTAINER Attach to a running container --no-stdin=false: Do not attach stdin --sig-proxy=true: Proxify all received signal to the process (even in non-tty mode) ~~~ > 注意：你可以点击[这里](https://docs.docker.com/reference/commandline/cli/) 来查看完整的 Docker 命令行列表和使用方法。 ## 在Docker中运行一个web应用 到这里我们了解了更多关于 docker 客户端的知识，而现在我们需要将学习的焦点转移到重要的部分：运行多个容器。到目前为止我们发现运行的容器并没有一些什么特别的用处。让我们通过使用 docker 构建一个 web 应用程序来运行一个web应用程序来体验一下。 在这个 web 应用中，我们将运行一个 Python Flask 应用。使用 `docker run` 命令。 ~~~ $ sudo docker run -d -P training/webapp python app.py ~~~ 让我们来回顾一下我们的命令都做了什么。我们指定两个标识(flags) `-d` 和 `-P` 。我们已知是 `-d` 标识是让 docker 容器在后台运行。新的 `-P` 标识通知 Docker 将容器内部使用的网络端口映射到我们使用的主机上。现在让我们看看我们的 web 应用。 This image is a pre-built image we've created that contains a simple Python Flask web application. 我们指定了 `training/web` 镜像。我们创建容器的时候使用的是这个预先构建好的镜像，并且这个镜像已经包含了简单的 Python Flask web 应用程序。 最后，我们指定了我们容器要运行的命令： `python app.py`。这样我们的 web 应用就启动了。 > 注意：你可以在[命令参考](http://docs.docker.com/reference/commandline/cli/#run)和[Docker run参考](http://docs.docker.com/reference/run/)查看更多 `docker run` 命令细节 ## 查看 WEB 应用容器 现在我们使用 `docker ps` 来查看我们正在运行的容器。 ~~~ $ sudo docker ps -l CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES bc533791f3f5 training/webapp:latest python app.py 5 seconds ago Up 2 seconds 0.0.0.0:49155->5000/tcp nostalgic_morse ~~~ 你可以看到我们在 `docker ps` 命令中指定了新的标识 `-l`。这样组合的 `docker ps` 命令会返回最后启动容器的详细信息。 > 注意：默认情况下，`docker ps` 命令只显示运行中的容器。如果你还想看已经停止的容器，请加上 `-a` 标示。 我们这里可以看到一些细节，与我们第一次运行 `docker ps` 命令的时候相比，这里多了一个 `PORTS` 列。 ~~~ PORTS 0.0.0.0:49155->5000/tcp ~~~ 我们通过在 `docker run` 中使用 `-P` 标示(flags) 来将我们 Docker 镜像内部容器端口暴露给主机。 > 提示：当我们学习[如何构建镜像的时候](https://github.com/widuu/chinese_docker/blob/master/userguide/dockerimages.md)，我们将了解更多关于如何开放 Docker 镜像端口。 在这种情况下，Docker 开放了 5000 端口（默认 Python Flask 端口）映射到主机端口 49155 上。 Docker 能够很容易的配置和绑定网络端口。在最后一个例子中 `-P` 标识(flags)是 `-p 5000` 的缩写，它将会把容器内部的 5000 端口映射到本地 Docker 主机的高位端口上(这个端口的通常范围是 32768 至 61000)。我们也可以指定 `-p` 标识来绑定指定端口。举例： ~~~ $ sudo docker run -d -p 5000:5000 training/webapp python app.py ~~~ 这将会把容器内部的 5000 端口映射到我们本地主机的 5000 端口上。你可能现在会问：为什么我们只使用 1对1端口映射的方式将端口映射到 Docker 容器， 而不是采用自动映射高位端口的方式？这里 1:1 映射方式能够保证映射到本地主机端口的唯一性。假设你想要测试两个 Python 应用程序，两个容器内部都绑定了端口5000，这样就没有足够的 Docker 的端口映射，你只能访问其中一个。 所以，现在我们打开浏览器访问端口49155。  我们的应用程序可以访问了！ > 注意：如果你在 OS X windows或者Linux上使用 boot2docker 虚拟机，你需要获取虚拟机的 ip 来代替localhost 使用，你可以通过运行 boot2docker shell 来获取 ip。 ~~~ $ boot2docker ip The VM's Host only interface IP address is: 192.168.59.103 ~~~ > 在这种情况下,你可以通过输入 [http://192.168.59.103:49155](http://192.168.59.103:49155/) 来访问上面的例子。 ### 查看网络端口快捷方式 使用 `docker ps` 命令来会返回端口的映射是一种比较笨拙的方法。为此，Docker 提供了一种快捷方式： `docker port`，使用 `docker port` 可以查看指定 （ID或者名字的）容器的某个确定端口映射到宿主机的端口号。 ~~~ $ sudo docker port nostalgic_morse 5000 0.0.0.0:49155 ~~~ 在这种情况下，我们看到容器的 5000 端口映射到了宿主机的的 49155 端口。 ### 查看WEB应用程序日志 让我们看看我们的容器中的应用程序都发生了什么，这里我们使用学习到的另一个命令 `docker logs` 来查看。 ~~~ $ sudo docker logs -f nostalgic_morse * Running on http://0.0.0.0:5000/ 10.0.2.2 - - [23/May/2014 20:16:31] "GET / HTTP/1.1" 200 - 10.0.2.2 - - [23/May/2014 20:16:31] "GET /favicon.ico HTTP/1.1" 404 - ~~~ 这次我们添加了一个 `-f` 标识。 `docker log` 命令就像使用 `tail -f` 一样来输出容器内部的标准输出。这里我们从显示屏上可以看到应用程序使用的是 5000 端口并且能够查看到应用程序的访问日志。 ### 查看WEB应用程序容器的进程 我们除了可以查看容器日志，我们还可以使用 `docker top` 来查看容器内部运行的进程： ~~~ $ sudo docker top nostalgic_morse PID USER COMMAND 854 root python app.py ~~~ 这里我们可以看到 `python app.py` 在容器里唯一进程。 ### 检查WEB应用程序 最后，我们可以使用 `docker inspect` 来查看Docker的底层信息。它会返回一个 JSON 文件记录着 Docker 容器的配置和状态信息。 ~~~ $ sudo docker inspect nostalgic_morse ~~~ 来让我们看下JSON的输出。 ~~~ [{ "ID": "bc533791f3f500b280a9626688bc79e342e3ea0d528efe3a86a51ecb28ea20", "Created": "2014-05-26T05:52:40.808952951Z", "Path": "python", "Args": [ "app.py" ], "Config": { "Hostname": "bc533791f3f5", "Domainname": "", "User": "", . . . ~~~ 我们也可以针对我们想要的信息进行过滤，例如，返回容器的 IP 地址，如下： ~~~ $ sudo docker inspect -f '{{ .NetworkSettings.IPAddress }}' nostalgic_morse 172.17.0.5 ~~~ ### 停止WEB应用容器 现在，我们的WEB应用程序处于工作状态。现在我们通过使用 `docker stop` 命令来停止名为 `nostalgic_morse` 的容器： ~~~ $ sudo docker stop nostalgic_morse nostalgic_morse ~~~ 现在我们使用 `docker ps` 命令来检查容器是否停止了。 ~~~ $ sudo docker ps -l ~~~ ### 重启WEB应用容器 哎呀！刚才你停止了另一个开发人员所使用的容器。这里你现在有两个选择：您可以创建一个新的容器或者重新启动旧的。让我们启动我们之前的容器： ~~~ $ sudo docker start nostalgic_morse nostalgic_morse ~~~ 现在再次运行 `docker ps -l` 来查看正在运行的容器，或者通过URL访问来查看我们的应用程序是否响应。 > 注意：也可以使用 `docker restart` 命令来停止容器然后再启动容器。 ### 移除WEB应用容器 你的同事告诉你他们已经完成了在容器上的工作，不在需要容器了。让我们使用 `docker rm` 命令来删除它： ~~~ $ sudo docker rm nostalgic_morse Error: Impossible to remove a running container, please stop it first or use -f 2014/05/24 08:12:56 Error: failed to remove one or more containers ~~~ 发生了什么？实际上，我们不能删除正在运行的容器。这避免你意外删除了正在使用并且运行中的容器。让我们先停止容器，然后再试一试删除容器。 ~~~ $ sudo docker stop nostalgic_morse nostalgic_morse $ sudo docker rm nostalgic_morse nostalgic_morse ~~~ 现在我们停止并删除了容器。 > 注意：删除容器是最后一步！

Docker 允许你在容器内运行应用程序， 使用 `docker run` 命令来在容器内运行一个应用程序。 ## Hello world 现在让我们来试试 ~~~ $ sudo docker run ubuntu:14.04 /bin/echo 'Hello world' Hello world ~~~ 刚才你启动了你的第一个容器！ 那么刚才发生了什么? 我们逐步来分析 `docker run` 命令做了哪些事情。 首先，我们指定了 `docker` 二进制执行文件和我们想要执行的命令 `run`。`docker run` 组合会运行容器。 接下来，我们指定一个镜像: `ubuntu 14.04` 。这是我们运行容器的来源。 Docker 称此为镜像。在本例中，我们使用一个`Ubuntu 14.04` 操作系统镜像。 当你指定一个镜像，Docker 首先会先从你的 Docker 本地主机上查看镜像是否存在，如果没有，Docker 就会从镜像仓库[Docker Hub](https://hub.docker.com/) 下载公共镜像。 接下来，我们告诉 Docker 在容器内我们需要运行什么命令： ~~~ /bin/echo 'Hello world' ~~~ 当我们的容器启动了 Docker 创建的新的 Ubuntu 14.04 环境，并在容器内执行 `/bin/echo` 命令后。我们会在命令行看到如下结果： ~~~ hello world ~~~ 那么，我们创建容器之后会发生什么呢？ 当命令状态状态处于激活状态的时候 Docker 容器就会一直运行。这里只要 "hello world" 被输出，容器就会停止。 ## 一个交互式的容器 让我们尝试再次运行 `docker run`，这次我们指定一个新的命令来运行我们的容器。 ~~~ $ sudo docker run -t -i ubuntu:14.04 /bin/bash root@af8bae53bdd3:/# ~~~ 我们继续指定了 `docker run` 命令，并启动了 `ubuntu:14.04` 镜像。但是我们添加了两个新的标识(参数flags)： `-t` 和 `-i` 。`-t` 表示在新容器内指定一个伪终端或终端，`-i`表示允许我们对容器内的 (`STDIN`) 进行交互。 我们在容器内还指定了一个新的命令： `/bin/bash` 。这将在容器内启动 `bash shell` 所以当容器（container）启动之后，我们会获取到一个命令提示符： ~~~ root@af8bae53bdd3:/# ~~~ 我们尝试在容器内运行一些命令： ~~~ root@af8bae53bdd3:/# pwd / root@af8bae53bdd3:/# ls bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var ~~~ 你可以看到我们运行 `pwd` 来显示当前目录，这时候显示的是我们的根目录。我们还列出了根目录的文件列表，通过目录列表我们看出来这是一个典型的 Linux 文件系统。 你可以在容器内随便的玩耍，你可以使用 `exit` 命令或者使用 CTRL-D 来退出容器。 ~~~ root@af8bae53bdd3:/# exit ~~~ 与我们之前的容器一样，一旦你的 Bash shell 退出之后，你的容器就停止了。 ### Hello world 守护进程 现在当一个容器运行完一个命令后就会退出，但是这样看起来有时候并不好。让我们创建一个容器以进程的方式运行，就像大多数我们运行在 Docker 中的应用程序一样，这里我们可以使用 `docker run` 命令： ~~~ $ sudo docker run -d ubuntu:14.04 /bin/sh -c "while true; do echo hello world; sleep 1; done" 1e5535038e285177d5214659a068137486f96ee5c2e85a4ac52dc83f2ebe4147 ~~~ 等等，怎么回事？我们的 “hello world” 输出呢？让我们看看它是怎么运行的。这个命令看起来应该很熟悉.我们运行`docker run` ，但是我们指定了一个 `-d` 标识。`-d` 标识告诉 docker 在容器内以后台进程模式运行。 我们也指定了一个相同的镜像: `ubuntu:14.04` 最终，我们指定命令行运行: ~~~ /bin/sh -c "while true; do echo hello world; sleep 1; done" ~~~ 这是一个忠实的 hello world 进程：一个脚本会一直输出 "hello world" 为什么我们看不到的一大堆的 "hello world" ? 而是docker返回的一个很长的字符串： ~~~ 1e5535038e285177d5214659a068137486f96ee5c2e85a4ac52dc83f2ebe4147 ~~~ 这个长的字符串叫做容器ID（container ID）。它对于每一个容器来说都是唯一的，所以我们可以使用它。 > 注意：容器 ID 是有点长并且非常的笨拙，稍后我们会看到一个短点的 ID,某些方面来说它是容器 ID 的简化版。 我们可以根据容器 ID 查看 "hello world" 进程发生了什么 首先，我们要确保容器正在运行。我们可以使用 `docker ps` 命令来查看。`docker ps` 命令可以查询 docker 进程的所有容器。 ~~~ $ sudo docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 1e5535038e28 ubuntu:14.04 /bin/sh -c 'while tr 2 minutes ago Up 1 minute insane_babbage ~~~ 这里我们看到了以进程模式运行的容器。`docker ps` 命令会返回一些有用的信息，这里包括一个短的容器 ID：`1e5535038e28`。 我们还可以查看到构建容器时使用的镜像， `ubuntu:14.04`，当命令运行之后，容器的状态随之改变并且被系统自动分配了名称 `insane_babbage`。 > 注意：当容器启动的时候 Docker 会自动给这些容器命名，稍后我们可以看到我们如何给容器指定名称。 好了，现在我们知道它正在运行。但是我们能要求它做什么呢？做到这，我们需要在我们容器内使用 `docker logs` 命令。让我们使用容器的名称来填充 `docker logs` 命令。 ~~~ $ sudo docker logs insane_babbage hello world hello world hello world . . . ~~~ `docker logs` 命令会查看容器内的标准输出：这个例子里输出的是我们的命令 `hello world` 太棒了！我们的 docker 进程是工作的，并且我们创建了我们第一个 docker 应用。 现在我们已经可以创建我们自己的容器了，让我们处理正在运行的进程容器并停止它。我们使用 `docker stop` 命令来停止容器 。 ~~~ $ sudo docker stop insane_babbage insane_babbage ~~~ `docker stop` 命令会通知 Docker 停止正在运行的容器。如果它成功了，它将返回刚刚停止的容器名称。 让我们通过 `docker ps` 命令来检查它是否还工作。 ~~~ $ sudo docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES ~~~ 太好了，我们的容器停止了。

本节讲述了 Docker Hub 的快速入门,包括如何创建一个账户。 Docker Hub 存放着 Docker 及其组件的所有资源。Docker Hub 可以帮助你与同事之间协作，并获得功能完整的 Docker。为此，它提供的服务有： * Docker 镜像主机 * 用户认证 * 自动镜像构建和工作流程工具，如构建触发器和 web hooks * 整合了 GitHub 和 BitBucket 为了使用 Docker Hub ,首先需要注册创建一个账户。别担心，创建一个账户很简单并且是免费的。 ## 创建 Docker Hub 账户 这里有两种访问可以创建和注册一个 Docker Hub 账户： * 1.通过网站，或者 * 2.通过命令行 ### 通过网站注册 填写[注册表单](https://hub.docker.com/account/signup/)，选择您的用户名和密码并指定您的电子邮箱。你也可以报名参加 Docker 邮件列表，会有很多关于 Docker 的信息。  ### 通过命令行 你可以通过使用命令行输入 `docker login` 命令来创建一个 Docker Hub 账号 ~~~ $ sudo docker login ~~~ ### 邮箱确认 一旦你填写完毕表格，请查看你的电子邮件，通过点击欢迎信息中的链接来激活您的账户。  ### 登陆 在完成确认过程之后，您可以使用web控制台登陆  或者通过在命令行中输入 `docker login` 命令来登录： ~~~ $ sudo docker login ~~~ 你的 Docker 账户现在已经生效，并随时可以使用。

# 欢迎来到docker用户指南 通过这个介绍，你可以了解到 Docker 是什么，以及它是如何工作的。在本章节中，我们将 Docker 集成到你的环境中，并且通过使用 Docker 来了解一些基础知识。 我们教你如何使用docker: * docker中运行你的应用程序。 * 运行你自己的容器。 * 创建docker镜像。 * 分享你的docker镜像。 * 和更多的信息! 我们已经将本指南分为几个主要部分： ## 开始使用Docker Hub 如何使用Docker Hub? Docker Hub是docker的中心仓库。Docker Hub里存储了公共的 Docker 镜像，并且提供服务来帮助你构建和管理你的 Docker 环境。了解解更多。 阅读使用[Docker Hub](39728). ## 在Docker中运行“hello Word”应用 如何在容器内运行应用程序？ Docker 为你将要运行的应用程序提供了一个基于容器的虚拟化平台。学习如何使用 `Dockerize` 应用程序来运行他们。 阅读[Dockerize应用程序](39729) ## 使用容器 如何管理我们的容器？ 当你在docker容器中运行和管理你的应用程序，我们会展示如何管理这些容器。了解如何检查、监控和管理容器。 阅读[使用容器](39730) ## 使用docker镜像 我是如何创建、访问和分享我自己的容器呢？ 当你学会如何使用docker的时候，是时候进行下一步来学习如何在 Docker 中构建你自己应用程序镜像。 阅读[使用docker镜像](39731) ## 容器连接 到这里我们学会了如何在 Docker 容器中构建一个单独的应用程序。而现在我们要学习如何将多个容器连接在一起构建一个完整的应用程序。 阅读[容器连接](39732) ## 管理容器数据 现在我们知道如何连接 Docker 容器，下一步，我们学习如何管理容器数据，如何将卷挂载到我们的容器中。 阅读[管理容器数据](39733) ## 使用Docker Hub 现在我们应该学习更多关于使用 Docker 的知识。例如通过 Docker Hub 提供的服务来构建私有仓库。 阅读[使用Docker Hub](39734) ## Docker Compose Docker Compose 你只需要一个简单的配置文件就可以自定义你所需要的应用组件，包括容器、配置、网络链接和挂载卷。只需要一个简单的命令就可以启动和运行你的应用程序。 阅读[Docker Compose 用户指南.](https://github.com/widuu/chinese_docker/blob/master/compose/README.md) ## Docker Machine Docker Machine 可以帮助你快速的启动和运行 Docker 引擎。 Machine 可以帮助你配置本地电脑、云服务商和你的个人数据中心上的 Docker 引擎主机，并且通过配置 Docker 客户端来让它们进行安全的通信。 查阅 [Go to Docker Machine user guide.](https://github.com/widuu/chinese_docker/blob/master/machine/README.md) ## Docker 集群 Docker 集群是将多个 Docker 引擎池连接在一起组合成一个独立的主机来提供给外界。它是以 Docker API 作为服务标准的，所以任何已经在Docker上工作的工具，现在都可以透明地扩展到多个主机上。 阅读 [Go to Docker Swarm user guide.](https://github.com/widuu/chinese_docker/blob/master/swarm)