Docker入门及进阶教程

最新推荐文章于 2024-06-07 09:33:02 发布

娄黔子

最新推荐文章于 2024-06-07 09:33:02 发布

阅读量3.4k

点赞数 1

分类专栏： docker 文章标签： docker 容器运维

本文链接：https://blog.csdn.net/herojeo/article/details/122367078

版权

docker 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

阅读声明：

该教程笔记来源于dockers——菜鸟教程

一、Docker介绍

1. Docker教程

Docker是一个开源的容器引擎，基于Go语言并遵从Apache2.0协议开源。

Docker可以让开发者打包他们的应用以及依赖包到一个轻量级，可移植的容器，然后发布到任何流行的Linux机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似iphone的app），更重要的是容器的性能开销低。

Docker从17.03版本之后分为CE(Community Edtion:社区版)和EE(Enterprise Edition:企业版)。我们在练习使用社区版的就够了。

1.1 阅读本教程适合人员

本教程适用于运维人员和后端开发人员

1.2 知识准备

阅读本教程前，你需要掌握Linux基本命令。

1.3 Docker的使用场景

Web应用的自动化打包和发布
自动化测试和持续集成，发布
在服务型环境中部署和调整数据库或其他后台应用
从头编译或者扩展现有的OpenShift或Cloud Foundry平台来搭建自己的PaaS环境

1.4 Docker的优点

Docker是一个用于开发，交付和运行应用程序的开放平台。Docker使您让应用程序和基础架构分开，从而可以快速交付软件。借助Docker，您可以像管理任何应用程序来管理基础架构。通过利用Docker的方法来快速交付，测试和部署代码，您可以大大减少编写代码和在生产环境中运行代码切换之间的延迟。

1.4.1 快速，一致的交付您的应用

Docker允许开发人员使用自己的应用程序或者服务在标准环境下工作，从而简化了开发周期。

容器非常适合持续集成和持续交付（CI/CD)的工作流程，请考虑以下示例方案。

您的开发人员在本地编写代码，并使用Docker容器共享他们的工作。
他们使用Docker容器将其应用推送到测试环境，并执行自动或者手动测试。
当开发人员发现错误时，他们可以使用开发环境对其进行修复，然后重新部署到测试环境中，以便进行测试和验证。
测试完成之后，将修补程序推送到生产环境，就像更新的镜像推送到生产环境一样简单。

1.4.2 响应式部署和扩展

Docker是基于容器的平台，允许高度集成可移动的负载。Docker可以在开发人员的本机上运行，在服务器或者虚拟机或者混合环境中运行。

Docker的可移植性和轻量性的特性，可以使开发人员轻松完成动态管理的工作负担。并根据业务需求提示，实时扩展或者拆除应用程序或者服务。

1.4.3 在同一硬件上运行更多的工作负载

Docker快速轻巧，它为基于虚拟机管理程序的虚拟机提供了可行，经济，高效的替代方案。因此您可以使用更多计算能力来实现业务目标。Docker非常适合高密度环境以及中小型部署，而您可以使用更少的资源做更多的事情。

1.4.4 参考地址

Docker官网

Github Docker 源码

2. Docker架构

2.1 三个基本概念

镜像(iamge)：Docker镜像（Image)，就相当于一个root文件系统，比如说ubuntu官方镜像16.04版本就包含了一套完整的最小系统的root文件系统。
容器(Contain)：镜像（Image）和容器（Container）的关系，就像面向对象程序设计的类和实例一样，镜像是静态的定义，容器时镜像运行的实体。容器可以被创建，启动，删除，停止，暂停等操作。
仓库(Repository)：仓库可以看成一个代码控制中心，用来保存镜像。

2.2 解释

Docker采用客户端——服务器（C/S）架构模式，使用远程API来管理和创建Docker容器。

Docker容器通过Docker镜像来创建。

2.3 图示和表格

概念	说明
Docker 镜像(Images)	Docker 镜像是用于创建 Docker 容器的模板，比如 Ubuntu 系统。
Docker 容器(Container)	容器是独立运行的一个或一组应用，是镜像运行时的实体。
Docker 客户端(Client)	Docker 客户端通过命令行或者其他工具使用 Docker SDK (https://docs.docker.com/develop/sdk/) 与 Docker 的守护进程通信。
Docker 主机(Host)	一个物理或者虚拟的机器用于执行 Docker 守护进程和容器。
Docker Registry	Docker 仓库用来保存镜像，可以理解为代码控制中的代码仓库。Docker Hub(https://hub.docker.com) 提供了庞大的镜像集合供使用。一个 Docker Registry 中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 <仓库名>:<标签> 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签。
Docker Machine	Docker Machine是一个简化Docker安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装Docker，比如VirtualBox、 Digital Ocean、Microsoft Azure。

二、Docker的安装

1. Ubuntu Docker安装

1.1 支持的版本

Docker Engine-Community支持一下的ubuntu版本：

Xenial 16.04 (LTS)
Bionic 18.04 (LTS)
Cosmic 18.10
Disco 19.04
其他更新的版本……

Docker Engine - Community 支持上 x86_64（或 amd64）armhf，arm64，s390x （IBM Z），和 ppc64le（IBM的Power）架构。

1.2 使用官方安装脚本自动安装

安装命令

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

也可以使用国内 daocloud 一键安装命令

curl -sSL https://get.daocloud.io/docker | sh

1.3 手动安装

1.3.1 卸载旧版本

Docker的旧版本被称为docker，docker.io或者docker-engine。如果安装，请卸载他们。

sudo apt-get remove docker docker-engine docker.io containerd runc

当前称为 Docker Engine-Community 软件包 docker-ce 。

1.3.2 安装 Docker Engine-Community，以下介绍两种方式。

1.3.2.1 使用Docker仓库进行安装

在新主机上首次安装 Docker Engine-Community 之前，需要设置 Docker 仓库。之后，您可以从仓库安装和更新 Docker 。

1.3.2.1.1设置仓库

更新apt包索引

sudo apt-get update

安装apt依赖包，用于通过HTTPS来获取仓库：

sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

添加 Docker 的官方 GPG 密钥：

curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key add -

9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 通过搜索指纹的后8个字符，验证您现在是否拥有带有指纹的密钥。

sudo apt-key fingerprint 0EBFCD88
   
pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           [ unknown] Docker Release (CE deb) <docker@docker.com>
sub   rsa4096 2017-02-22 [S]

使用以下指令设置稳定版仓库

sudo add-apt-repository \
   "deb [arch=amd64] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/ \
  $(lsb_release -cs) \
  stable"

1.3.2.1.2 安装 Docker Engine-Community

更新 apt 包索引。

sudo apt-get update

安装最新版本的 Docker Engine-Community 和 containerd ，或者转到下一步安装特定版本

sudo apt-get install docker-ce docker-ce-cli containerd.io

要安装特定版本的 Docker Engine-Community，请在仓库中列出可用版本，然后选择一种安装。列出您的仓库中可用的版本

apt-cache madison docker-ce

  docker-ce | 5:18.09.1~3-0~ubuntu-xenial | https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu  xenial/stable amd64 Packages
  docker-ce | 5:18.09.0~3-0~ubuntu-xenial | https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu  xenial/stable amd64 Packages
  docker-ce | 18.06.1~ce~3-0~ubuntu       | https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu  xenial/stable amd64 Packages
  docker-ce | 18.06.0~ce~3-0~ubuntu       | https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu  xenial/stable amd64 Packages
  ...

使用第二列中的版本字符串安装特定版本，例如 5:18.09.1_3-0ubuntu-xenial。

sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cli=<VERSION_STRING> containerd.io

测试 Docker 是否安装成功，输入以下指令，打印出以下信息则安装成功:

sudo docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete                                                                                                                                  Digest: sha256:c3b4ada4687bbaa170745b3e4dd8ac3f194ca95b2d0518b417fb47e5879d9b5f
Status: Downloaded newer image for hello-world:latest


Hello from Docker!
This message shows that your installation appears to be working correctly.


To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.


To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash


Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/


For more examples and ideas, visit:
 https://docs.docker.com/get-started/

1.3.2.2 使用Shell脚本进行安装

Docker 在 get.docker.com 和 test.docker.com 上提供了方便脚本，用于将快速安装 Docker Engine-Community 的边缘版本和测试版本。脚本的源代码在 docker-install 仓库中。不建议在生产环境中使用这些脚本，在使用它们之前，您应该了解潜在的风险：

脚本需要运行 root 或具有 sudo 特权。因此，在运行脚本之前，应仔细检查和审核脚本。
这些脚本尝试检测 Linux 发行版和版本，并为您配置软件包管理系统。此外，脚本不允许您自定义任何安装参数。从 Docker 的角度或您自己组织的准则和标准的角度来看，这可能导致不支持的配置。
这些脚本将安装软件包管理器的所有依赖项和建议，而无需进行确认。这可能会安装大量软件包，具体取决于主机的当前配置。
该脚本未提供用于指定要安装哪个版本的 Docker 的选项，而是安装了在 edge 通道中发布的最新版本。
如果已使用其他机制将 Docker 安装在主机上，请不要使用便捷脚本。

本示例使用 get.docker.com 上的脚本在 Linux 上安装最新版本的Docker Engine-Community。要安装最新的测试版本，请改用 test.docker.com。在下面的每个命令，取代每次出现 get 用 test。

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

如果要使用 Docker 作为非 root 用户，则应考虑使用类似以下方式将用户添加到 docker 组：

sudo usermod -aG docker your-user

1.4 卸载 Docker

删除安装包

sudo apt-get purge docker-ce

删除镜像、容器、配置文件等内容：

sudo rm -rf /var/lib/docker

2. Debian Docker 安装

Docker 支持以下的 Debian 版本：

Buster 10
Stretch 9 (stable) / Raspbian Stretch

Docker Engine-Community 在 x86_64（或 amd64 ）armhf，和 arm64 体系结构上受支持。

2.1 使用官方安装脚本自动安装

安装命令如下：

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

也可以使用国内 daocloud 一键安装命令

curl -sSL https://get.daocloud.io/docker | sh

2.2 手动安装

2.2.1 卸载旧版本

Docker的旧版本被称为docker,docker.io或者docker-engine，如果已经安装，请卸载他们。

sudo apt-get remove docker docker-engine docker.io containerd runc

2.2.2 安装 Docker Engine-Community

2.2.2.1 使用Docker仓库进行安装

在新主机上首次安装 Docker Engine-Community 之前，需要设置 Docker 仓库。之后，您可以从仓库安装和更新 Docker。

Raspbian 用户不能使用此方法！

对于 Raspbian，尚不支持使用仓库进行安装。您必须改为使用 shell 脚本方式。

2.2.2.1.1 设置仓库

更新apt包索引

sudo apt-get update

安装 apt 依赖包，用于通过 HTTPS 来获取仓库。

sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg2 \
    software-properties-common

添加 Docker 的官方 GPG 密钥：

curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/debian/gpg | sudo apt-key add -

9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 通过搜索指纹的后8个字符，验证您现在是否拥有带有指纹的密钥。

sudo apt-key fingerprint 0EBFCD88

pub   4096R/0EBFCD88 2017-02-22
      Key fingerprint = 9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid                  Docker Release (CE deb) <docker@docker.com>
sub   4096R/F273FCD8 2017-02-22

使用一下命令设置稳定版仓库

sudo add-apt-repository \
   "deb [arch=amd64] https://mirrors.ustc.edu.cn/docker-ce/linux/debian \
  $(lsb_release -cs) \
  stable"

2.2.2.1.2 安装 Docker Engine-Community

更新 apt 包索引：

sudo apt-get update

安装最新版本的 Docker Engine-Community 和 containerd ，或者转到下一步安装特定版本：

sudo apt-get install docker-ce docker-ce-cli containerd.io

要安装特定版本的 Docker Engine-Community，请在仓库中列出可用版本，然后选择一种安装。列出您的仓库中可用的版本：

apt-cache madison docker-ce

  docker-ce | 5:18.09.1~3-0~debian-stretch | https://mirrors.ustc.edu.cn/docker-ce/linux/debian stretch/stable amd64 Packages
  docker-ce | 5:18.09.0~3-0~debian-stretch | https://mirrors.ustc.edu.cn/docker-ce/linux/debian stretch/stable amd64 Packages
  docker-ce | 18.06.1~ce~3-0~debian        | https://mirrors.ustc.edu.cn/docker-ce/linux/debian stretch/stable amd64 Packages
  docker-ce | 18.06.0~ce~3-0~debian        | https://mirrors.ustc.edu.cn/docker-ce/linux/debian stretch/stable amd64 Packages
  ...

使用第二列中的版本字符串安装特定版本，例如 5:18.09.1_3-0debian-stretch 。

sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cli=<VERSION_STRING> containerd.io

测试 Docker 是否安装成功，输入以下指令，打印出以下信息则安装成功：

sudo docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete                                                                                                                                  Digest: sha256:c3b4ada4687bbaa170745b3e4dd8ac3f194ca95b2d0518b417fb47e5879d9b5f
Status: Downloaded newer image for hello-world:latest


Hello from Docker!
This message shows that your installation appears to be working correctly.


To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.


To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash


Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/


For more examples and ideas, visit:
 https://docs.docker.com/get-started/

2.3 卸载Docker

删除安装包：

sudo apt-get purge docker-ce

删除镜像、容器、配置文件等内容：

sudo rm -rf /var/lib/docker

3. CentOS Docker安装

Docker支持以下的64位的CentOS版本：

CentOS 7
CentOS 8
更高版本…

3.1 使用官方安装脚本自动安装

安装命令如下：

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

也可以使用国内 daocloud 一键安装命令：

curl -sSL https://get.daocloud.io/docker | sh

3.2 手动安装

3.2.1 卸载旧版本

较旧的 Docker 版本称为 docker 或 docker-engine 。如果已安装这些程序，请卸载它们以及相关的依赖项。

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

3.2.2 安装 Docker Engine-Community

3.2.2.1 使用Docker仓库进行安装

在新主机上首次安装 Docker Engine-Community 之前，需要设置 Docker 仓库。之后，您可以从仓库安装和更新 Docker。

3.2.2.1.1 设置仓库

安装所需的软件包。yum-utils 提供了 yum-config-manager ，并且 device mapper 存储驱动程序需要 device-mapper-persistent-data 和 lvm2

sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

使用一下命令使用稳定的仓库

使用官方地址（比较满）

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

阿里云

sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

清华大学源

sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3.2.2.1.2 安装 Docker Engine-Community

安装最新版本的 Docker Engine-Community 和 containerd，或者转到下一步安装特定版本：

sudo yum install docker-ce docker-ce-cli containerd.io

如果提示您接受 GPG 密钥，请选是。

可以有多个Docker吗？

如果启用了多个 Docker 仓库，则在未在 yum install 或 yum update 命令中指定版本的情况下，进行的安装或更新将始终安装最高版本，这可能不适合您的稳定性需求。

Docker 安装完默认未启动。并且已经创建好 docker 用户组，但该用户组下没有用户。

3.2.2.1.3 安装其他版本

列出并排序您存储库中可用的版本。此示例按版本号（从高到低）对结果进行排序。

yum list docker-ce --showduplicates | sort -r

docker-ce.x86_64  3:18.09.1-3.el7                     docker-ce-stable
docker-ce.x86_64  3:18.09.0-3.el7                     docker-ce-stable
docker-ce.x86_64  18.06.1.ce-3.el7                    docker-ce-stable
docker-ce.x86_64  18.06.0.ce-3.el7                    docker-ce-stable

通过其完整的软件包名称安装特定版本，该软件包名称是软件包名称（docker-ce）加上版本字符串（第二列），从第一个冒号（:）一直到第一个连字符，并用连字符（-）分隔。例如：docker-ce-18.09.1。

sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io

启动 Docker

sudo systemctl start docker

通过运行 hello-world 映像来验证是否正确安装了 Docker Engine-Community 。

sudo docker run hello-world

3.3 卸载Docker

删除安装包

yum remove docker-ce

删除镜像、容器、配置文件等内容：

rm -rf /var/lib/docker

4. Windows Docker安装

4.1 介绍

Docker并非一个通用的容器工具，它依赖于已存在并运行的Linux内核环境。

Docker 实质上是在已经运行的 Linux 下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的 Linux 主机。

因此，Docker 必须部署在 Linux 内核的系统上。如果其他系统想部署 Docker 就必须安装一个虚拟 Linux 环境。

在 Windows 上部署 Docker 的方法都是先安装一个虚拟机，并在安装 Linux 系统的的虚拟机中运行 Docker。

4.2 Win10系统

Docker Desktop 是 Docker 在 Windows 10 和 macOS 操作系统上的官方安装方式，这个方法依然属于先在虚拟机中安装 Linux 然后再安装 Docker 的方法。

Docker Desktop 官方下载地址：

**注意：**此方法仅适用于 Windows 10 操作系统专业版、企业版、教育版和部分家庭版！

4.2.1 安装Hyper-V

Hyper-V 是微软开发的虚拟机，类似于 VMWare 或 VirtualBox，仅适用于 Windows 10。这是 Docker Desktop for Windows 所使用的虚拟机。

但是，这个虚拟机一旦启用，QEMU、VirtualBox 或 VMWare Workstation 15 及以下版本将无法使用！如果你必须在电脑上使用其他虚拟机（例如开发 Android 应用必须使用的模拟器），请不要使用 Hyper-V！

开启Hyper-V

控制面版搜索程序和功能，然后点击启用或关闭Windows功能，选中Hype-V，打开相关功能。

现在最新版的win10系统已经可以集成linux子系统了，安装的细节有更改。

4.3 总结

博主本人在做菜鸟教程的笔记的时候，已经安装过的win10环境的docker。安装过程根据官网教程来的，和菜鸟自己总结的已经完全不一样了，在此系统，包括win7请参考官网。

5 . MacOS Docker 安装

5.1 使用Homebrew安装

macOS 我们可以使用 Homebrew 来安装 Docker。

Homebrew 的 Cask 已经支持 Docker for Mac，因此可以很方便的使用 Homebrew Cask 来进行安装：

brew install --cask --appdir=/Applications docker

==> Creating Caskroom at /usr/local/Caskroom
==> We'll set permissions properly so we won't need sudo in the future
Password:          # 输入 macOS 密码
==> Satisfying dependencies
==> Downloading https://download.docker.com/mac/stable/21090/Docker.dmg
######################################################################## 100.0%
==> Verifying checksum for Cask docker
==> Installing Cask docker
==> Moving App 'Docker.app' to '/Applications/Docker.app'.
&#x1f37a;  docker was successfully installed!

在载入 Docker app 后，点击 Next，可能会询问你的 macOS 登陆密码，你输入即可。之后会弹出一个 Docker 运行的提示窗口，状态栏上也有有个小鲸鱼的图标（)。

5.2 手动下载安装

手动安装请参考官网文档，因为安装方法在不断更新

6. Docker镜像加速

国内从 DockerHub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务，例如：

科大镜像：https://docker.mirrors.ustc.edu.cn/
网易：https://hub-mirror.c.163.com/
阿里云：https://<你的ID>.mirror.aliyuncs.com
七牛云加速器：https://reg-mirror.qiniu.com

当配置某一个加速器地址之后，若发现拉取不到镜像，请切换到另一个加速器地址。国内各大云服务商均提供了 Docker 镜像加速服务，建议根据运行 Docker 的云平台选择对应的镜像加速服务。

阿里云镜像获取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors，登陆后，左侧菜单选中镜像加速器就可以看到你的专属地址了：

6.1 Ubuntu14.04,Debian7Wheezy

对于使用 upstart 的系统而言，编辑 /etc/default/docker 文件，在其中的 DOCKER_OPTS 中配置加速器地址：

DOCKER_OPTS="--registry-mirror=https://registry.docker-cn.com"

重新启动服务:

sudo service docker restart

6.2 Ubuntu16.04+、Debian8+、CentOS7

对于使用 systemd 的系统，请在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在请新建该文件）：

{"registry-mirrors":["https://reg-mirror.qiniu.com/"]}

之后重新启动服务：

sudo systemctl daemon-reload
sudo systemctl restart docker

6.3 Windows 10

对于使用 Windows 10 的系统，在系统右下角托盘 Docker 图标内右键菜单选择 Settings，打开配置窗口后左侧导航菜单选择 Daemon。在 Registrymirrors 一栏中填写加速器地址 https://docker.mirrors.ustc.edu.cn/ ，之后点击 Apply 保存后 Docker 就会重启并应用配置的镜像地址了。

6.4 Mac OS X

对于使用 Mac OS X 的用户，在任务栏点击 Docker for mac 应用图标-> Perferences…-> Daemon-> Registrymirrors。在列表中填写加速器地址 https://reg-mirror.qiniu.com 。修改完成之后，点击 Apply&Restart 按钮，Docker 就会重启并应用配置的镜像地址

6.5 检测加速器是否生效

检查加速器是否生效配置加速器之后，如果拉取镜像仍然十分缓慢，请手动检查加速器配置是否生效，在命令行执行 docker info，如果从结果中看到了如下内容，说明配置成功。

docker info
Registry Mirrors:
    https://reg-mirror.qiniu.com

三、Docker的使用

1. 基础使用

1.1 运行hello world

Docker 允许你在容器内运行应用程序，使用 docker run 命令来在容器内运行一个应用程序。

输出Hello world

runoob@runoob:~$ docker run ubuntu:15.10 /bin/echo "Hello world"
Hello world

1.1.1 参数解析

docker: Docker的二进制执行文件

run: 与前面的docker组合来运行一个容器

ubuntu:15.10 指定要运行的镜像，Docker首先会从本地主机上寻找镜像是否存在，如果不存在，就会去镜像仓库Docker Hub下载公共镜像

/bin/echo “Hello world”: 在启动的容器中执行的命令

以上命令完整的意思可以解释为：Docker 以 ubuntu15.10 镜像创建一个新容器，然后在容器里执行 bin/echo “Hello world”，然后输出结果。

1.2 运行交互式的容器

我们通过docker的两个参数 -i, -t,让docker运行的容器实现”对话“的功能：

runoob@runoob:~$ docker run -i -t ubuntu:15.10 /bin/bash
root@0123ce188bd8:/#

1.2.1 参数解析

-t: 在新容器里面指定一个伪终端或者终端

-i: 允许你对容器的标准输入（STDING）进行交互

注意第二行 root@0123ce188bd8:/#，此时我们已进入一个 ubuntu15.10 系统的容器

1.2.2 进行练习

我们尝试在容器中运行命令 cat /proc/version和ls分别查看当前系统的版本信息和当前目录下的文件列表

root@0123ce188bd8:/#  cat /proc/version
Linux version 4.4.0-151-generic (buildd@lgw01-amd64-043) (gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.10) ) #178-Ubuntu SMP Tue Jun 11 08:30:22 UTC 2019
root@0123ce188bd8:/# ls
bin  boot  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@0123ce188bd8:/#

1.2.3 退出容器

我们可以通过运行 exit 命令或者使用 CTRL+D 来退出容器。

root@0123ce188bd8:/#  exit
exit
root@runoob:~#

注意第三行中 root@runoob:~# 表明我们已经退出了当前的容器，返回到当前的主机中。

1.3 启动容器（后台模式）

使用以下命令创建一个以进程方式运行的容器

runoob@runoob:~$ docker run -d ubuntu:15.10 /bin/sh -c "while true; do echo hello world; sleep 1; done"
2b1b7a428627c51ab8810d541d759f072b4fc75487eed05812646b8534a2fe63

在输出中，我们没有看到期望的 “hello world”，而是一串长字符

2b1b7a428627c51ab8810d541d759f072b4fc75487eed05812646b8534a2fe63

这个长字符串叫做容器 ID，对每个容器来说都是唯一的，我们可以通过容器 ID 来查看对应的容器发生了什么。

首先，我们需要确认容器有在运行，可以通过 docker ps 来查看：

runoob@runoob:~$ docker ps
CONTAINER ID        IMAGE                  COMMAND              ...  
5917eac21c36        ubuntu:15.10           "/bin/sh -c 'while t…"    ...

输出详情介绍

CONTAINER ID: 容器 ID。

IMAGE: 使用的镜像。

COMMAND: 启动容器时运行的命令。

CREATED: 容器的创建时间。

STATUS: 容器状态。

状态包含7种

created（已创建）
restarting（重启中）
restarting（重启中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）

PORTS: 容器的端口信息和使用的连接类型（tcp\udp）。

NAMES: 自动分配的容器名称。

在宿主主机内使用 docker logs 命令，查看容器内的标准输出：

runoob@runoob:~$ docker logs 2b1b7a428627
hello world
hello world
hello world
hello world
hello world

1.4 停止容器

我们使用Docker stop [id] 命令来停止容器

通过 docker ps 查看，容器已经停止工作:

2. 容器的使用

2.1 Docker客户端

docker 客户端非常简单 ,我们可以直接输入 docker 命令来查看到 Docker 客户端的所有命令选项。

runoob@runoob:~# docker

在这里插入图片描述

可以通过命令 docker command --help 更深入的了解指定的 Docker 命令使用方法。

例如我们要查看 docker stats 指令的具体使用方法：

runoob@runoob:~# docker stats --help

2.2 容器的使用

2.2.1 获取镜像

如果我们本地没有 ubuntu 镜像，我们可以使用 docker pull 命令来载入 ubuntu 镜像：

docker pull ubuntu

2.2.2 启动容器

以下命令使用 ubuntu 镜像启动一个容器，参数为以命令行模式进入该容器：

docker run -it ubuntu /bin/bash

参数说明

-i: 交互式操作
-t: 终端
ubuntu: ubuntu镜像
/bin/bash: 放在镜像名后的是命令，这里我们希望有个交互式 Shell，因此用的是 /bin/bash。

要退出终端，直接输入exit:

root@ed09e4490c57:/# exit

2.2.3 启动已经停止运行的容器

查看所有的容器的命令如下：

docker ps -a

使用docker start启动一个已经停止运行的容器

docker start [id]

2.2.4 后台运行

在大部分的场景下，我们希望 docker 的服务是在后台运行的，我们可以过 -d 指定容器的运行模式。

docker run -itd --name ubuntu-test ubuntu /bin/bash

**注：**加了 -d 参数默认不会进入容器，想要进入容器需要使用指令 docker exec（下面会介绍到）

2.2.5 停止一个容器

停止容器的命令如下：

docker stop <容器 ID>

停止的容器可以通过docker restart重启

docker restart [id]

2.2.6 进入容器

在使用 -d 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令进入：

docker attach
docker exec：推荐大家使用 docker exec 命令，因为此退出容器终端，不会导致容器的停止。

2.2.6.1 attach命令

下面演示了使用 docker attach 命令。

docker attach id

注意： 如果从这个容器退出，会导致容器的停止。

2.2.6.2 exec命令

下面演示了使用 docker exec 命令。

docker exec -it 243c32535da7 /bin/bash

注意： 如果从这个容器退出，容器不会停止，这就是为什么推荐大家使用 docker exec 的原因。

更多参数说明请使用 docker exec --help 命令查看。

2.2.7 导入和导出容器

2.2.7.1 导出容器

如果要导出本地某个容器，可以使用 docker export 命令。

docker export 1e560fca3906 > ubuntu.tar

2.2.7.2 导入容器快照

可以使用 docker import 从容器快照文件中再导入为镜像，以下实例将快照文件 ubuntu.tar 导入到镜像 test/ubuntu:v1:

cat docker/ubuntu.tar | docker import - test/ubuntu:v1

此外，也可以通过指定的URL或者某个目录来导入，例如

docker import http://example.com/exampleimage.tgz example/imagerepo

2.2.8 删除容器

删除容器使用docker rm命令

docker rm -f id

2.2.9 删除所有处于终止状态的容器

$ docker container prune

2.2.10 运行一个Web应用

前面我们运行的容器并没有一些什么特别的用处。

接下来让我们尝试使用 docker 构建一个 web 应用程序。

我们将在docker容器中运行一个 Python Flask 应用来运行一个web应用。

runoob@runoob:~# docker pull training/webapp  # 载入镜像
runoob@runoob:~# docker run -d -P training/webapp python app.py

参数说明：

-d: 让容器在后台运行

-P: 将容器内使用的网络端口，随机映射到我们使用的主机上

2.2.11 查看WEB应用程序

使用Docker ps 来查看我们正在运行的容器：

runoob@runoob:~#  docker ps
CONTAINER ID        IMAGE               COMMAND             ...        PORTS                 
d3d5e39ed9d3        training/webapp     "python app.py"     ...        0.0.0.0:32769->5000/tcp

这里多了端口信息

PORTS
0.0.0.0:32769->5000/tcp

Docker 开放了 5000 端口（默认 Python Flask 端口）映射到主机端口 32769 上。

这时我们可以通过浏览器访问WEB应用：本机IP:32769

我们也可以通过-p参数设置不一样的端口：

runoob@runoob:~$ docker run -d -p 5000:5000 training/webapp python app.py

docker ps查看正在运行的容器

runoob@runoob:~#  docker ps
CONTAINER ID        IMAGE                             PORTS                     NAMES
bf08b7f2cd89        training/webapp     ...        0.0.0.0:5000->5000/tcp    wizardly_chandrasekhar
d3d5e39ed9d3        training/webapp     ...        0.0.0.0:32769->5000/tcp   xenodochial_hoov

容器内部的 5000 端口映射到我们本地主机的 5000 端口上

2.2.12 网络端口的快捷方式

通过docker ps命令可以查看容器的端口映射，Docker还提供了另一个快捷方式：docker port。使用Docker可以查看指定（ID或者名字）容器的某个确定端口映射到宿主的端口号。

runoob@runoob:~$ docker port bf08b7f2cd89
5000/tcp -> 0.0.0.0:5000

2.2.13 查看WEB应用程序日志

docker logs [ID或者名字]可以查看容器内部的标准输出。

runoob@runoob:~$ docker logs -f

 bf08b7f2cd89
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
192.168.239.1 - - [09/May/2016 16:30:37] "GET / HTTP/1.1" 200 -
192.168.239.1 - - [09/May/2016 16:30:37] "GET /favicon.ico HTTP/1.1" 404 -

-f 让docker logs 像使用tail -f 一样来输出容器内部的标准输出。

从上面，我们可以看到应用程序使用的是5000端口并且能够查看应用程序的访问日志。

2.2.14 查看WEB应用程序的进程

我们可以使用docker top来查看docker内部运行的进程

runoob@runoob:~$ docker top wizardly_chandrasekhar
UID     PID         PPID          ...       TIME                CMD
root    23245       23228         ...       00:00:00            python app.py

2.2.15 检查WEB应用程序

使用docker inspect来查看Docker的底层信息。它会返回一个JSON文件记录着Docker容器的配置和状态信息。

runoob@runoob:~$ docker inspect wizardly_chandrasekhar
[
    {
        "Id": "bf08b7f2cd897b5964943134aa6d373e355c286db9b9885b1f60b6e8f82b2b85",
        "Created": "2018-09-17T01:41:26.174228707Z",
        "Path": "python",
        "Args": [
            "app.py"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 23245,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2018-09-17T01:41:26.494185806Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
......

2.2.16 停止web应用程序

runoob@runoob:~$ docker stop wizardly_chandrasekhar   
wizardly_chandrasekhar

2.2.17 重启WEB应用容器

已经停止的容器，我们可以使用docker start来启动

runoob@runoob:~$ docker start wizardly_chandrasekhar
wizardly_chandrasekhar

docker ps -I 查询最后一次创建的容器：

 docker ps -l 
CONTAINER ID        IMAGE                             PORTS                     NAMES
bf08b7f2cd89        training/webapp     ...        0.0.0.0:5000->5000/tcp    wizardly_chandrasekhar

正在运行的容器，我们可以使用docker restart命令来重启

2.2.18 移除WEB应用容器

我们可以使用docker rm命令来删除不需要的容器。

runoob@runoob:~$ docker rm wizardly_chandrasekhar  
wizardly_chandrasekhar

删除容器时，容器必须是停止状态，否则会报如下错误

runoob@runoob:~$ docker rm wizardly_chandrasekhar
Error response from daemon: You cannot remove a running container bf08b7f2cd897b5964943134aa6d373e355c286db9b9885b1f60b6e8f82b2b85. Stop the container before attempting removal or force remove

2.3 Docker镜像的使用

当运行容器时，如果镜像本地不存在，Docker就会自动从Docker镜像仓库中下载，默认是从Docker hub公共镜像源中下载，

下面我们来学习

管理和使用本地镜像
创建镜像

2.3.1 列出镜像列表

我们可以使用Docker images来列出本地主机上的镜像

runoob@runoob:~$ docker images           
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              14.04               90d5884b1ee0        5 days ago          188 MB
php                 5.6                 f40e9e0f10c8        9 days ago          444.8 MB
nginx               latest              6f8d099c3adc        12 days ago         182.7 MB
mysql               5.6                 f2e8d6c772c0        3 weeks ago         324.6 MB
httpd               latest              02ef73cf1bc0        3 weeks ago         194.4 MB
ubuntu              15.10               4e3b13c8a266        4 weeks ago         136.3 MB
hello-world         latest              690ed74de00f        6 months ago        960 B
training/webapp     latest              6fae60ef3446        11 months ago       348.8 MB

各个选项说明：

repository: 表示镜像的仓库源
tag: 镜像的标签
image id：镜像的id
created: 镜像创建的时间
size：镜像的大小

同一个仓库源可能有多个Tag，代表这个仓库源的不同版本，如ubuntu仓库源里，有15.10，16.04，20.04等多个版本。我们使用repository:tag来定义不同的镜像

所以，如果想使用版本为16.04的ubuntu系统镜像来运行容器时，命令如下：

runoob@runoob:~$ docker run -t -i ubuntu:15.10 /bin/bash 
root@d77ccb2e5cca:/#

参数说明：

-i : 交互式操作

-t: 终端

ubuntu16.04:这里指用的是ubuntu系统的16.04版本镜像为基础来启动镜像

/bin/bash: 放在镜像名后的是命令，这里我们希望有一个交互式的Shell,因此用的式/bin/bash

如果你不指定一个镜像的版本标签，例如你只使用ubuntu，docker将使用默认的latest版本来使用。

2.3.2 获取一个新的镜像

当我们使用一个本地主机上并不存在的镜像时Docker就会自动下载这个镜像，如果想要自动下载这个镜像，需要使用docker pull命令下载

Crunoob@runoob:~$ docker pull ubuntu:13.10
13.10: Pulling from library/ubuntu
6599cadaf950: Pull complete 
23eda618d451: Pull complete 
f0be3084efe9: Pull complete 
52de432f084b: Pull complete 
a3ed95caeb02: Pull complete 
Digest: sha256:15b79a6654811c8d992ebacdfbd5152fcf3d165e374e264076aa435214a947a3
Status: Downloaded newer image for ubuntu:13.10

下载完成后，我们可以使用这个镜像来运行容器。

2.3.3 查找镜像

我们可以从docker hub网站来搜索镜像。

初次之外，我们还可以使用docker search来搜索镜像。比如我们需要一个httpd的镜像来作为我们的web服务。我们就可以使用docker search httpd来寻找适合我们的镜像。

runoob@runoob:~$  docker search httpd

参数说明：

Name: 镜像仓库源的名称

description: 镜像的描述

official: 是不是官方的镜像

stars：类似git hub的标星数，表示喜欢，点赞的意思。

automated: 是否自动构建

2.3.4 拖取镜像

我们决定使用上图的http官方版本的镜像，使用docker pull来拉取镜像。

runoob@runoob:~$ docker pull httpd
Using default tag: latest
latest: Pulling from library/httpd
8b87079b7a06: Pulling fs layer 
a3ed95caeb02: Download complete 
0d62ec9c6a76: Download complete 
a329d50397b9: Download complete 
ea7c1f032b5c: Waiting 
be44112b72c7: Waiting

下载完成之后，我们就可以使用这个镜像了。

runoob@runoob:~$ docker run httpd

2.3.5 删除镜像

镜像的删除使用docker rmi命令，比如我们删除hello-world镜像。

docker rmi hello-world

2.3.6 创建镜像

当使用官方下载的镜像不能满足我们的需求时，我们可以使用下面两种方式对镜像进行更改。

从已经创建的容器中更新内容，并且再次提交这个镜像。
使用dockerfile指令来创建一个镜像。

2.3.6.1 更新镜像

在更新镜像之前，我们需要使用镜像来创建一个容器。

runoob@runoob:~$ docker run -t -i ubuntu:15.10 /bin/bash
root@e218edb10161:/#

在运行的容器内使用 apt-get update 命令进行更新。

在完成操作之后，输入 exit 命令来退出这个容器。

此时 ID 为 e218edb10161 的容器，是按我们的需求更改的容器。我们可以通过命令 docker commit 来提交容器副本。

runoob@runoob:~$ docker commit -m="has update" -a="runoob" e218edb10161 runoob/ubuntu:v2
sha256:70bf1840fd7c0d2d8ef0a42a817eb29f854c1af8f7c59fc03ac7bdee9545aff8

各个参数说明：

-m: 提交的描述信息

-a: 指定镜像作者

e218edb10161: 容器ID

runoob/ubuntu:v2: 指定要创建的目标镜像名

我们可以使用docker images 来查看我们的新镜像。

runoob@runoob:~$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
runoob/ubuntu       v2                  70bf1840fd7c        15 seconds ago      158.5 MB
ubuntu              14.04               90d5884b1ee0        5 days ago          188 MB
php                 5.6                 f40e9e0f10c8        9 days ago          444.8 MB
nginx               latest              6f8d099c3adc        12 days ago         182.7 MB
mysql               5.6                 f2e8d6c772c0        3 weeks ago         324.6 MB
httpd               latest              02ef73cf1bc0        3 weeks ago         194.4 MB
ubuntu              15.10               4e3b13c8a266        4 weeks ago         136.3 MB
hello-world         latest              690ed74de00f        6 months ago        960 B
training/webapp     latest              6fae60ef3446        12 months ago       348.8 MB

然后使用我们的新镜像 runoob/ubuntu 来启动一个容器

runoob@runoob:~$ docker run -t -i runoob/ubuntu:v2 /bin/bash                            
root@1a9fbdeb5da3:/#

2.3.6.2 构建镜像

我们使用命令docker build 来构建一个新的镜像。为此，我们需要创建一个dockerFile文件，其中包含一组指令告诉docker如何构建我们的镜像。

runoob@runoob:~$ cat Dockerfile 
FROM    centos:6.7
MAINTAINER      Fisher "fisher@sudops.com"

RUN     /bin/echo 'root:123456' |chpasswd
RUN     useradd runoob
RUN     /bin/echo 'runoob:123456' |chpasswd
RUN     /bin/echo -e "LANG=\"en_US.UTF-8\"" >/etc/default/local
EXPOSE  22
EXPOSE  80
CMD     /usr/sbin/sshd -D

每一条指令都会在镜像创建一个新的层，每一个指令的前缀都是大写的。

第一条FROM，指定使用的是哪一个镜像源

RUN指令告诉docker在镜像内执行命令，安装了什么。。。

然后，我们使用docker build命令来构建一个镜像。

runoob@runoob:~$ docker build -t runoob/centos:6.7 .
Sending build context to Docker daemon 17.92 kB
Step 1 : FROM centos:6.7
 ---&gt; d95b5ca17cc3
Step 2 : MAINTAINER Fisher "fisher@sudops.com"
 ---&gt; Using cache
 ---&gt; 0c92299c6f03
Step 3 : RUN /bin/echo 'root:123456' |chpasswd
 ---&gt; Using cache
 ---&gt; 0397ce2fbd0a
Step 4 : RUN useradd runoob
......

参数说明：

-t: 指定要创建的目标镜像名

.: Dockerfile文件所在目录，可以指定dockerfile的绝对路径

使用docker images查看创建的镜像已经在列表中。

runoob@runoob:~$ docker images 
REPOSITORY          TAG                 IMAGE ID            CREATED              SIZE
runoob/centos       6.7                 860c279d2fec        About a minute ago   190.6 MB
runoob/ubuntu       v2                  70bf1840fd7c        17 hours ago         158.5 MB
ubuntu              14.04               90d5884b1ee0        6 days ago           188 MB
php                 5.6                 f40e9e0f10c8        10 days ago          444.8 MB
nginx               latest              6f8d099c3adc        12 days ago          182.7 MB
mysql               5.6                 f2e8d6c772c0        3 weeks ago          324.6 MB
httpd               latest              02ef73cf1bc0        3 weeks ago          194.4 MB
ubuntu              15.10               4e3b13c8a266        5 weeks ago          136.3 MB
hello-world         latest              690ed74de00f        6 months ago         960 B
centos              6.7                 d95b5ca17cc3        6 months ago         190.6 MB
training/webapp     latest              6fae60ef3446        12 months ago        348.8 MB

新创建的镜像可以用来创建容器。

2.3.7 设置镜像标签

我们可以使用docker tag命令，给镜像添加一个新的标签

runoob@runoob:~$ docker tag 860c279d2fec runoob/centos:dev

docker tag 镜像ID，这里是 860c279d2fec ,用户名称、镜像源名(repository name)和新的标签名(tag)。

使用 docker images 命令可以看到，ID为860c279d2fec的镜像多一个标签。

runoob@runoob:~$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
runoob/centos       6.7                 860c279d2fec        5 hours ago         190.6 MB
runoob/centos       dev                 860c279d2fec        5 hours ago         190.6 MB
runoob/ubuntu       v2                  70bf1840fd7c        22 hours ago        158.5 MB
ubuntu              14.04               90d5884b1ee0        6 days ago          188 MB
php                 5.6                 f40e9e0f10c8        10 days ago         444.8 MB
nginx               latest              6f8d099c3adc        13 days ago         182.7 MB
mysql               5.6                 f2e8d6c772c0        3 weeks ago         324.6 MB
httpd               latest              02ef73cf1bc0        3 weeks ago         194.4 MB
ubuntu              15.10               4e3b13c8a266        5 weeks ago         136.3 MB
hello-world         latest              690ed74de00f        6 months ago        960 B
centos              6.7                 d95b5ca17cc3        6 months ago        190.6 MB
training/webapp     latest              6fae60ef3446        12 months ago       348.8 MB

2.4 Docker 容器的连接

前面我们介绍了通过网络端口实现查看运行在docker容器内部的服务，容器内可以运行一些网络应用，要让外部也可以访问这些应用，需要使用-p或者-p参数来指定端口映射，下面我们来实现通过端口连接docker容器。

2.4.1 网络端口映射

以python创建的容器为例

runoob@runoob:~$ docker run -d -P training/webapp python app.py
fce072cc88cee71b1cdceb57c2821d054a4a59f67da6b416fceb5593f059fc6d

另外，我们可以指定容器绑定的网络地址，比如绑定的是127.0.0.1

我们使用**-P**绑定端口号，使用docker -ps 查看容器绑定的端口号5000绑定的主机端口号32768

runoob@runoob:~$ docker ps
CONTAINER ID    IMAGE               COMMAND            ...           PORTS                     NAMES
fce072cc88ce    training/webapp     "python app.py"    ...     0.0.0.0:32768->5000/tcp   grave_hopper

我们使用-p标识来指定容器端口绑定的主机端口号

两种方式的区别是：

-P:指的是容器的端口随机映射到主机的端口

-p:指的是容器的端口绑定主机的端口

runoob@runoob:~$ docker run -d -p 5000:5000 training/webapp python app.py
33e4523d30aaf0258915c368e66e03b49535de0ef20317d3f639d40222ba6bc0

runoob@runoob:~$ docker ps
CONTAINER ID        IMAGE               COMMAND           ...           PORTS                     NAMES
33e4523d30aa        training/webapp     "python app.py"   ...   0.0.0.0:5000->5000/tcp    berserk_bartik
fce072cc88ce        training/webapp     "python app.py"   ...   0.0.0.0:32768->5000/tcp   grave_hopper

另外，我们可以指定容器绑定的网络地址，比如绑定127.0.0.1

runoob@runoob:~$ docker run -d -p 127.0.0.1:5001:5000 training/webapp python app.py
95c6ceef88ca3e71eaf303c2833fd6701d8d1b2572b5613b5a932dfdfe8a857c
runoob@runoob:~$ docker ps
CONTAINER ID        IMAGE               COMMAND           ...     PORTS                                NAMES
95c6ceef88ca        training/webapp     "python app.py"   ...  5000/tcp, 127.0.0.1:5001->5000/tcp   adoring_stonebraker
33e4523d30aa        training/webapp     "python app.py"   ...  0.0.0.0:5000->5000/tcp               berserk_bartik
fce072cc88ce        training/webapp     "python app.py"   ...    0.0.0.0:32768->5000/tcp              grave_hopper

这样子我们就可以通过访问127.0.0.1:5001来访问容器的5000端口

上面的例子中，我们都默认绑定的是tcp端口，如果要绑定udp端口，可以在端口后面加/udp/

runoob@runoob:~$ docker run -d -p 127.0.0.1:5000:5000/udp training/webapp python app.py
6779686f06f6204579c1d655dd8b2b31e8e809b245a97b2d3a8e35abe9dcd22a
runoob@runoob:~$ docker ps
CONTAINER ID        IMAGE               COMMAND           ...   PORTS                                NAMES
6779686f06f6        training/webapp     "python app.py"   ...   5000/tcp, 127.0.0.1:5000->5000/udp   drunk_visvesvaraya
95c6ceef88ca        training/webapp     "python app.py"   ...    5000/tcp, 127.0.0.1:5001->5000/tcp   adoring_stonebraker
33e4523d30aa        training/webapp     "python app.py"   ...     0.0.0.0:5000->5000/tcp               berserk_bartik
fce072cc88ce        training/webapp     "python app.py"   ...    0.0.0.0:32768->5000/tcp              grave_hopper

docker port命令可以让我们快捷地查看端口的绑定情况

runoob@runoob:~$ docker port adoring_stonebraker 5000
127.0.0.1:5001

2.4.2 Docker容器互联

端口映射并不是唯一把docker连接到另一个容器的方法

docker有一个连接系统，可以将各个容器的资源实现共享

docker连接会创建一个父子关系，其中父容器可以看到子容器的信息。

2.4.2.1 容器命名

当我们创建一个容器的时候，docker会自动对它进行命名。另外，我们可以使用–name标识来命名容器。

runoob@runoob:~$  docker run -d -P --name runoob training/webapp python app.py
43780a6eabaaf14e590b6e849235c75f3012995403f97749775e38436db9a441

使用docker ps命令来查看容器名称

runoob@runoob:~$ docker ps -l
CONTAINER ID     IMAGE            COMMAND           ...    PORTS                     NAMES
43780a6eabaa     training/webapp   "python app.py"  ...     0.0.0.0:32769->5000/tcp   runoob

2.4.2.2 新建网络

下面先创建一个新的Docker网络

docker network create -d bridge test-net

参数说明：

-d: 参数指定网络类型，有bridge，overlay

其中overlay网络适用于Swarm mode，在本小节中你可以忽略它

2.4.2.3 连接容器

运行一个容器并连接到新建的test-net网络

docker run -itd --name test1 --network test-net ubuntu /bin/bash

打开新的终端，再运行一个容器并加入到test-net网络

ocker run -itd --name test2 --network test-net ubuntu /bin/bash

下面通过ping来证明test1和test2容器建立了互联关系

如果test1和test2容器内没有ping命令，则在容器内执行以下命令安装ping(即学即用：可以在一个容器内安装好，提交到容器到镜像，在新的镜像中运行以上两个容器)。

apt-get update
apt install iputils-ping

在test1容器内输入一下命令

ping test2

查看是否可以成功可以ping到，同理在test2容器输入相同的命令。

这样，test1和test2两个容器建立了互联关系

如果你有多个容器之间相互连接，推荐使用Docker Compose，后面会介绍。

2.4.2.4 配置DNS

我们可以在宿主机的/etc/docker/daemon.json文件增加以下内容来设置全部容器的DNS

{
  "dns" : [
    "114.114.114.114",
    "8.8.8.8"
  ]
}

设置后，启动容器的 DNS 会自动配置为 114.114.114.114 和 8.8.8.8。

配置完之后，需要重启docker才能生效

查看容器的DNS是否生效可以使用以下命令：它会输出DNS命令。

$ docker run -it --rm  ubuntu  cat etc/resolv.conf

2.4.2.4.1 手动指定容器的配置

如果只想在指定的容器设置DNS，则可以使用以下的命令

$ docker run -it --rm -h host_ubuntu --dns=114.114.114.114 --dns-search=test.com ubuntu

参数说明：

–rm: 容器退出时自动清理容器内部的文件系统。

-h HOSTNAME 或者 --hostname=HOSTNAME: 设定容器的主机名，它会被写到容器内的/etc/hostname 和 /etc/hosts。

–dns=IP_ADDRESS: 添加DNS的服务器到容器的/etc/resolv.conf中，让容器用这个服务器解析所有不在/etc/hosts的主机名

–dns-search=DOMAIN:设定容器的搜索域，当设定搜索域为.example.com时，在搜索一个名为host的主机名时，dns不仅搜索host，而且还搜索host.example.com。

如果在容器启动没有指定–dns和–dns-search,Docker会使用宿主机上的/etc/resolv.conf来配置容器的DNS

2.5 Docker 仓库的管理

仓库(Repository)是集中存放镜像的地方，以下介绍Docker hub，当然不只限docker hub，还有其他的仓库地址，只是服务的厂商不一样。

2.5.1 Docker Hub

目前，Docker官方维护了一个公共仓库docker hub。

大部分需求都可以通过直接从docker hub 中下载镜像来实现。

2.5.1.1 注册

在 https://hub.docker.com 免费注册一个 Docker 账号。

2.5.1.2 登录和退出

登录需要输入用户名和密码，登录成功后，我们就可以从docker hub上拉取自己账号下的全部镜像。

docker login

退出docker hub 可以使用以下的命令

docker logout

拉取镜像

你可以通过docker search命令来查找官方仓库的镜像，并利用docker pull 命令来将它下载到本地

以ubuntu为关键词进行搜索

docker search ubuntu

然后使用docker pull，将镜像拉到本地

docker pull ubuntu

2.5.1.3 推送镜像

用户登录后，可以通过dokcer push命令来将自己的镜像推送到docker hub上。

以下命令中的username请替换成自己的docker账号用户名

$ docker tag ubuntu:18.04 username/ubuntu:18.04
$ docker image ls

REPOSITORY      TAG        IMAGE ID            CREATED           ...  
ubuntu          18.04      275d79972a86        6 days ago        ...  
username/ubuntu 18.04      275d79972a86        6 days ago        ...  
$ docker push username/ubuntu:18.04
$ docker search username/ubuntu

NAME             DESCRIPTION       STARS         OFFICIAL    AUTOMATED
username/ubuntu

2.6 Docker DockerFile

2.6.1 什么是DockerFile?

DockerFile是一个用来构建镜像的文本文件，文本文件包含了构建镜像的一系列指令和说明

2.6.2 使用DockerFile定制镜像

这里讲解如何通过Dockerfile来定制一个镜像，具体的Dockerfile文件内指令详解，将在下一节介绍，这里你只需要知道构建的流程即可。

2.6.2.1 下面以定制一个nginx镜像为例

构建好的镜像内会有一个/usr/share/nginx/html/index.html文件

在一个空目录下，新建一个名为Dockerfile文件，并在文件内添加以下内容：

FROM nginx
RUN echo '这是一个本地构建的nginx镜像' > /usr/share/nginx/html/index.html

2.6.2.2 FROM和RUN指令的作用

FROM: 定制的镜像都是基于FROM的镜像，这里的nginx就是定制需要的基础镜像。后续的操作都是基于nginx.

RUN: 用于执行后面跟着的命令行命令，有以下两种格式：

shell格式：
RUN <命令行命令>
# <命令行命令> 等同于, 在终端操作的shell命令

exec格式：
RUN ["可执行文件", "参数1", "参数2"]
# RUN ["./test.php","dev","offline"] 等价于RUN ./test.php dev offline

注意：Dockerfile的指令每执行一次，都会在docker上新建一层。所以过多无意义的层，会导致镜像膨胀过大，例如：

FROM centos
RUN yum -y install wget
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
RUN tar -xvf redis.tar.gz

以上执行会创建三层镜像，可简化成以下格式

FROM centos
RUN yum -y install wget \
	&& wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \
	&& tar -xvf redis.tar.gz

如上，以&&符号连接命令，这样执行后，只会创建一层镜像

2.6.3 开始构建镜像

在Dockerfile文件的存放目录下，执行构建动作

以下示例，通过目录下的Docerfile构建一个nginx:v3(镜像名称:镜像标签)

注：最后的**.**代表本次执行的上下文路径，下一节会介绍。

docker build -t nginx:v3 .

2.6.4 上下文路径

上一节中，有提到指令最后一个**.**是上下文路径，那么什么是上下文路径呢？

上下文路径，是指docker在构建镜像的时候，有时候会使用到本机的文件（比如复制），docker build命令在得知这个路径后，会将该路径下的所有文件打包。

解释：由于Docker的运行模式是C/S模式，我们本机是C，Dockers引擎是S。实际的构建过程是在docker引擎下完成的，所以这个时候无法用到我们本机的文件，这就需要我们本机的指定目录下的文件一起打包提供给docker引擎使用。

如果未说明最后一个参数，那么默认上下文路径就是DockerFile所在位置。

注意：上下文路径不要存放无用的文件，因为会一起打包发送给Docker引擎，如果文件过多会造成过程缓慢。

2.6.5 指令详解

2.6.5.1 COPY

复制指令：从上下文复制文件或者目录到指定路径

格式如下

COPY [--chown=<user>:<group>] <源路径>... <目标路径>
COPY [--chown=<user>:<group>] ["<源路径>",... "<目标路径>"]

[–chown=<user>:<group>]：可选参数，用户改变复制到容器内文件的拥有者和属组。

<源路径>: 源文件或者源目录，这里可以是通配符表达式，其通配符规则要满足GO的filepath.Match规则，例如：

COPY hom* /mydir/
COPY hom?.txt /mydir/

<目标路径>：容器内的指定路径，该路径可以不用事先建好，路径不存在的话，会自动创建。

2.6.5.2 ADD

addd和copy使用格式类似（同样的需求下，官方建议使用copy），因为功能类似，稍有区别介绍如下：

ADD的优点：在执行<源文件>为tar打包的压缩包，并且后缀为gzip，bzip2以及xz的情况下，会自动复制并解压到<目标路径>。
ADD的缺点：在不解压的情况下，会无法复制tar压缩文件。会令镜像构建缓冲失败，从而使得镜像构建速度缓慢，具体是否使用，可以根据是否需要自动解压来决定。

2.6.5.2 CMD

类似RUN指令，用于运行程序，但二者的运行时间点不同：

CMD是在Docker run 时运行，RUN是在构建镜像docker build时运行

作用：为启动容器指定默认要运行的程序，程序运行结束，容器就运行结束了。CMD所指定要运行的程序可以被docker run命令行运行参数指定要运行的程序所覆盖。

注意：如果DockerFile中存在多条CMD指令，那么只有最后一条生效。

格式如下：

CMD <shell 命令> 
CMD ["<可执行文件或命令>","<param1>","<param2>",...] 
CMD ["<param1>","<param2>",...]  # 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数

推荐使用第二种格式，因为执行过程比较明确。第一种执行过程实质上也是以第二种格式执行，并且默认执行文件时sh。

2.6.5.3 ENTRYPOINT

类似CMD指令，但其不会被docker run 的命令参数指定的指令所覆盖，而且这些命令行参数会被当做参数送给ENTERPOINT指令所指定的程序。

但是，如果使用了可选项–entrypoint，将覆盖CMD指令所指定的程序。

优点：在执行docker run的时候可以指定ENTRYPOINT运行所需的参数。

注意：如果DockerFIle中存在多个ENTYRYPOINT指令，仅最后一个生效。

格式如下：

ENTRYPOINT ["<ENTRYPOINT ["<executeable>","<param1>","<param2>",...]>","<param1>","<param2>",...]

可以搭配 CMD 命令使用：一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参，以下示例会提到。

示例：

假设已经通过DockerFIle构建了nginx:test镜像：

FROM nginx

ENTRYPOINT ["nginx", "-c"] # 定参
CMD ["/etc/nginx/nginx.conf"] # 变参

1. 不传参运行

$ docker run  nginx:test

容器内默认运行以下命令，启动主线程。

nginx -c /etc/nginx/nginx.conf

2. 传参运行

$ docker run  nginx:test -c /etc/nginx/new.conf

容器会默认运行以下命令，启动主进程（假设/etc/nginx/new.conf此文件存在）

nginx -c /etc/nginx/new.conf

2.6.5.4 ENV

设置环境变量，定义了环境变量，那么在后续的指令中，就可以使用这个环境变量。

格式如下：

ENV <key> <value>
ENV <key1>=<value1> <key2>=<value2>...

以下示例设置 NODE_VERSION = 7.2.0 ，在后续的指令中可以通过 $NODE_VERSION 引用：

ENV NODE_VERSION 7.2.0

RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
  && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc"

2.6.5.5 ARG

构建参数，与 ENV 作用一致。不过作用域不一样。ARG 设置的环境变量仅对 Dockerfile 内有效，也就是说只有 docker build 的过程中有效，构建好的镜像内不存在此环境变量。

构建命令 docker build 中可以用 --build-arg <参数名>=<值> 来覆盖。

格式：

ARG <参数名>[=<默认值>]

2.6.5.6 Volumn

定义匿名数据卷。在启动容器时，如果忘记挂载数据卷，会自动挂载到匿名卷。

作用：

避免重要的数据，因容器重启而丢失，这是非常致命的。
避免容器不断变大

格式：

VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>

在启动容器 docker run 的时候，我们可以通过 -v 参数修改挂载点。

2.6.5.7 EXPOSE

仅仅是声明端口

作用：

帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射。
在运行时使用随机端口映射时，也就是使用命令docker run -P时，会自动映射到EXPOSE暴露的端口。

格式如下：

EXPOSE <端口1> [<端口2>...]

2.6.5.8 WORKDIR

指定工作目录。用WORKDIR构建的目录，会在docker构建的每一层都存在。（WORKDIR 指定的工作目录，必须是提前创建好的）

docker build 构建镜像过程中的，每一个 RUN 命令都是新建的一层。只有通过 WORKDIR 创建的目录才会一直存在。

格式如下：

USER <用户名>[:<用户组>]

2.6.5.9 HEALTHCHECK

用于指定某个程序或者指令来监控 docker 容器服务的运行状态。

格式如下:

HEALTHCHECK [选项] CMD <命令>：设置检查容器健康状况的命令
HEALTHCHECK NONE：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令

HEALTHCHECK [选项] CMD <命令> : 这边 CMD 后面跟随的命令使用，可以参考 CMD 的用法。

2.6.5.10 ONBUILD

用于延迟构建命令的执行。简单的说，就是 Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。当有新的 Dockerfile 使用了之前构建的镜像 FROM test-build ，这时执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令。

格式如下：

ONBUILD <其它指令>

2.6.5.11 LABEL

LABEL 指令用来给镜像添加一些元数据（metadata），以键值对的形式，语法格式如下：

LABEL <key>=<value> <key>=<value> <key>=<value> ...

比如我们可以添加镜像的作者

LABEL org.opencontainers.image.authors="runoob"

2.6.6 总结

Dockerfile指令说明简洁版：

FROM

构建镜像基于哪个镜像

MAINTAINER

镜像维护者姓名或邮箱地址

RUN

构建镜像时运行的指令

CMD

运行容器时执行的shell环境

VOLUME

指定容器挂载点到宿主机自动生成的目录或其他容器

USER

为RUN、CMD、和 ENTRYPOINT 执行命令指定运行用户

WORKDIR

为 RUN、CMD、ENTRYPOINT、COPY 和 ADD 设置工作目录，就是切换目录

HEALTHCHECH

健康检查

ARG

构建时指定的一些参数

EXPOSE

声明容器的服务端口（仅仅是声明）

ENV

设置容器环境变量

ADD

拷贝文件或目录到容器中，如果是URL或压缩包便会自动下载或自动解压

COPY

拷贝文件或目录到容器中，跟ADD类似，但不具备自动下载或解压的功能

ENTRYPOINT

运行容器时执行的shell命令

2.7 Docker Compose

2.7.1 Compose简介

Compose是用于定义和运行多容器Docker的一个工具。通过Compose，我们可以使用Yml文件来配置应用程序所需要的所有服务。然后，使用一个命令，就可以从YML文件配置中创建并启动所有服务。

2.7.2 Compose使用的三个步骤

使用Dockerfile来定义应用程序的环境
使用docker-compose.yml定义构成应用程序的服务，这样他们可以在隔离环境中一起运行。
最后，使用命令docker-compose up 来启动并运行整个应用程序

2.7.3 yml文件的示例

docker-compose.yml配置参数参考下文

# yaml 配置实例
version: '3'
services:
  web:
    build: .
    ports:
   - "5000:5000"
    volumes:
   - .:/code
    - logvolume01:/var/log
    links:
   - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

2.7.4 Compose安装

2.7.4.1 linux环境安装compose

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：https://github.com/docker/compose/releases。

运行以下命令以下载 Docker Compose 的当前稳定版本：

$ sudo curl -L "https://github.com/docker/compose/releases/download/v2.2.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

要安装其他版本的 Compose，请替换 1.24.1。

将可执行权限应用于二进制文件：

$ sudo chmod +x /usr/local/bin/docker-compose

创建软链：

$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

测试是否安装成功

$ docker-compose --version
cker-compose version 1.24.1, build 4667896b

**注意：**对于 alpine，需要以下依赖包： py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。

2.7.4.2 macOS安装compose

Mac 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Mac 用户不需要单独安装 Compose。Docker 安装说明可以参阅 MacOS Docker 安装。

2.7.4.3 windows PC

Windows 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Windows 用户不需要单独安装 Compose。Docker 安装说明可以参阅 Windows Docker 安装。

2.7.5 使用

2.7.5.1 准备

创建一个测试目录

$ mkdir composetest
$ cd composetest

在测试目录中创建一个名为app.py的文件，并且复制黏贴以下内容

import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

在此示例中，redis是应用程序网络上的redis容器的主机名，该主机使用的端口为6379。

在composetest目录中创建一个名为requirements.txt的文件，内容如下：

flask
redis

2.7.5.2 创建Dockerfile文件

在 composetest 目录中，创建一个名为 Dockerfile 的文件，内容如下：

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["flask", "run"]

Dockerfile 内容解释：
FROM python:3.7-alpine: 从 Python 3.7 映像开始构建镜像。

WORKDIR /code: 将工作目录设置为 /code。’
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
设置 flask 命令使用的环境变量。
RUN apk add --no-cache gcc musl-dev linux-headers: 安装 gcc，以便诸如 MarkupSafe 和 SQLAlchemy 之类的 Python 包可以编译加速。
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
复制 requirements.txt 并安装 Python 依赖项。
COPY . .: 将 . 项目中的当前目录复制到 . 镜像中的工作目录。

CMD [“flask”, “run”]: 容器提供默认的执行命令为：flask run。

2.7.5.3 创建一个docker-compose.yml

在测试目录中创建一个名为 docker-compose.yml 的文件，然后粘贴以下内容：

# yaml 配置
version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

该Compose文件定义了两个服务：web和redis

web：该 web 服务使用从 Dockerfile 当前目录中构建的镜像。然后，它将容器和主机绑定到暴露的端口 5000。此示例服务使用 Flask Web 服务器的默认端口 5000 。
redis：该 redis 服务使用 Docker Hub 的公共 Redis 映像。

2.7.5.4 使用compose命令构建和运行您的应用

在测试目录中，执行以下命令来启动应用程序：

docker-compose up

如果你想在后台执行该服务可以加上 -d 参数：

docker-compose up -d

2.7.6 yml配置指令参考

2.7.6.1 version

指定本yml依从的compose哪个版本制定的。

2.7.6.2 build

指定为构建镜像上下文路径：

例如webapp服务，指定为从上下文路径，./dir/Dockerfile所构建的镜像：

version: "3.7"
services:
  webapp:
    build: ./dir

或者，作为具有在上下文指定的路径的对象，以及可选的 Dockerfile 和 args：

version: "3.7"
services:
  webapp:
    build:
      context: ./dir
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1
      labels:
        - "com.example.description=Accounting webapp"
        - "com.example.department=Finance"
        - "com.example.label-with-empty-value"
      target: prod

context：上下文路径。
dockerfile：指定构建镜像的 Dockerfile 文件名。
args：添加构建参数，这是只能在构建过程中访问的环境变量。
labels：设置构建镜像的标签。
target：多层构建，可以指定构建哪一层。

2.7.6.3 cap_add，cap_drop

添加或删除容器拥有的宿主机的内核功能。

cap_add:
  - ALL # 开启全部权限

cap_drop:
  - SYS_PTRACE # 关闭 ptrace权限

2.7.6.4 cgroup_parent

为容器指定父 cgroup 组，意味着将继承该组的资源限制。

cgroup_parent: m-executor-abcd

2.7.6.5 command

覆盖容器启动的默认命令。

command: ["bundle", "exec", "thin", "-p", "3000"]

2.7.6.6 container_name

指定自定义容器名称，而不是生成的默认名称。

container_name: my-web-container

2.7.6.7 depends_on

设置依赖关系。

docker-compose up ：以依赖性顺序启动服务。在以下示例中，先启动 db 和 redis ，才会启动 web。
docker-compose up SERVICE ：自动包含 SERVICE 的依赖项。在以下示例中，docker-compose up web 还将创建并启动 db 和 redis。
docker-compose stop ：按依赖关系顺序停止服务。在以下示例中，web 在 db 和 redis 之前停止。

version: "3.7"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres

注意：web 服务不会等待 redis db 完全启动之后才启动。

2.7.6.8 deploy

指定与服务的部署和运行有关的配置。只在 swarm 模式下才会有用。

version: "3.7"
services:
  redis:
    image: redis:alpine
    deploy:
      mode：replicated
      replicas: 6
      endpoint_mode: dnsrr
      labels: 
        description: "This redis service label"
      resources:
        limits:
          cpus: '0.50'
          memory: 50M
        reservations:
          cpus: '0.25'
          memory: 20M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s

可以选参数：

endpoint_mode：访问集群服务的方式。

endpoint_mode: vip 
# Docker 集群服务一个对外的虚拟 ip。所有的请求都会通过这个虚拟 ip 到达集群服务内部的机器。
endpoint_mode: dnsrr
# DNS 轮询（DNSRR）。所有的请求会自动轮询获取到集群 ip 列表中的一个 ip 地址。

labels：在服务上设置标签。可以用容器上的 labels（跟 deploy 同级的配置）覆盖 deploy 下的 labels。

mode：指定服务提供的模式。

replicated：复制服务，复制指定服务到集群的机器上。
global：全局服务，服务将部署至集群的每个节点。
图解：下图中黄色的方块是 replicated 模式的运行情况，灰色方块是 global 模式的运行情况。

replicas：mode 为 replicated 时，需要使用此参数配置具体运行的节点数量。

resources：配置服务器资源使用的限制，例如上例子，配置 redis 集群运行需要的 cpu 的百分比和内存的占用。避免占用资源过高出现异常。

restart_policy：配置如何在退出容器时重新启动容器。

condition：可选 none，on-failure 或者 any（默认值：any）。
delay：设置多久之后重启（默认值：0）。
max_attempts：尝试重新启动容器的次数，超出次数，则不再尝试（默认值：一直重试）。
window：设置容器重启超时时间（默认值：0）。

rollback_config：配置在更新失败的情况下应如何回滚服务。

parallelism：一次要回滚的容器数。如果设置为0，则所有容器将同时回滚。
delay：每个容器组回滚之间等待的时间（默认为0s）。
failure_action：如果回滚失败，该怎么办。其中一个 continue 或者 pause（默认pause）。
monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。
max_failure_ratio：在回滚期间可以容忍的故障率（默认为0）。
order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认 stop-first ）。

update_config：配置应如何更新服务，对于配置滚动更新很有用。

parallelism：一次更新的容器数。
delay：在更新一组容器之间等待的时间。
failure_action：如果更新失败，该怎么办。其中一个 continue，rollback 或者pause （默认：pause）。
monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。
max_failure_ratio：在更新过程中可以容忍的故障率。
order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认stop-first）。

注：仅支持 V3.4 及更高版本。

2.7.6.9 devices

指定设备映射列表

devices:
  - "/dev/ttyUSB0:/dev/ttyUSB0"

2.7.6.10 dns

自定义 DNS 服务器，可以是单个值或列表的多个值。

dns: 8.8.8.8

dns:
  - 8.8.8.8
  - 9.9.9.9

2.7.6.11 dns_search

自定义 DNS 搜索域。可以是单个值或列表。

dns_search: example.com

dns_search:
  - dc1.example.com
  - dc2.example.com

2.7.6.12 entrypoint

覆盖容器默认的 entrypoint。

entrypoint: /code/entrypoint.sh

也可以是以下格式

entrypoint:
    - php
    - -d
    - zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
    - -d
    - memory_limit=-1
    - vendor/bin/phpunit

2.7.6.13 env_file

从文件添加环境变量。可以是单个值或列表的多个值。

env_file: .env

也可以是列表格式：

env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env

2.7.6.14 environment

添加环境变量。您可以使用数组或字典、任何布尔值，布尔值需要用引号引起来，以确保 YML 解析器不会将其转换为 True 或 False。

environment:
  RACK_ENV: development
  SHOW: 'true'

2.7.6.15 expose

暴露端口，但不映射到宿主机，只被连接的服务访问。

仅可以指定内部端口为参数：

expose:
 - "3000"
 - "8000"

2.7.6.16 extra_hosts

添加主机名映射。类似 docker client --add-host。

extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"

以上会在此服务的内部容器中 /etc/hosts 创建一个具有 ip 地址和主机名的映射关系：

162.242.195.82  somehost
50.31.209.229   otherhost

2.7.6.17 healthcheck

用于检测 docker 服务是否健康运行。

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
  interval: 1m30s # 设置检测间隔
  timeout: 10s # 设置检测超时时间
  retries: 3 # 设置重试次数
  start_period: 40s # 启动后，多少秒开始启动检测程序

2.7.6.18 image

指定容器运行的镜像。以下格式都可以：

image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # 镜像id

2.7.6.19 logging

服务的日志记录配置。

driver：指定服务容器的日志记录驱动程序，默认值为json-file。有以下三个选项

driver: "json-file"
driver: "syslog"
driver: "none"

仅在 json-file 驱动程序下，可以使用以下参数，限制日志得数量和大小。

logging:
  driver: json-file
  options:
    max-size: "200k" # 单个文件大小为200k
    max-file: "10" # 最多10个文件

当达到文件限制上限，会自动删除旧得文件。

syslog 驱动程序下，可以使用 syslog-address 指定日志接收地址。

logging:
  driver: syslog
  options:
    syslog-address: "tcp://192.168.0.42:123"

network_mode

设置网络模式。

network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"

networks

配置容器连接的网络，引用顶级 networks 下的条目。

services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2
networks:
  some-network:
    # Use a custom driver
    driver: custom-driver-1
  other-network:
    # Use a custom driver which takes special options
    driver: custom-driver-2

aliases ：同一网络上的其他容器可以使用服务名称或此别名来连接到对应容器的服务。

2.7.6.20 restart

no：是默认的重启策略，在任何情况下都不会重启容器。
always：容器总是重新启动。
on-failure：在容器非正常退出时（退出状态非0），才会重启容器。
unless-stopped：在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

注：swarm 集群模式，请改用 restart_policy。

2.7.6.21 secrets

存储敏感数据，例如密码：

version: "3.1"
services:

mysql:
  image: mysql
  environment:
    MYSQL_ROOT_PASSWORD_FILE: /run/secrets/my_secret
  secrets:
    - my_secret

secrets:
  my_secret:
    file: ./my_secret.txt

2.7.6.22 security_opt

修改容器默认的 schema 标签。

security-opt：
  - label:user:USER   # 设置容器的用户标签
  - label:role:ROLE   # 设置容器的角色标签
  - label:type:TYPE   # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签

2.7.6.23 stop_grace_period

指定在容器无法处理 SIGTERM (或者任何 stop_signal 的信号)，等待多久后发送 SIGKILL 信号关闭容器。

stop_grace_period: 1s # 等待 1 秒
stop_grace_period: 1m30s # 等待 1 分 30 秒

默认的等待时间是10s

2.7.6.24 stop_signal

设置停止容器的替代信号。默认情况下使用 SIGTERM 。

以下示例，使用 SIGUSR1 替代信号 SIGTERM 来停止容器。

stop_signal: SIGUSR1

2.7.6.25 sysctls

设置容器中的内核参数，可以使用数组或字典格式。

sysctls:
  net.core.somaxconn: 1024
  net.ipv4.tcp_syncookies: 0

sysctls:
  - net.core.somaxconn=1024
  - net.ipv4.tcp_syncookies=0

2.7.6.26 tmpfs

在容器内安装一个临时文件系统。可以是单个值或列表的多个值。

tmpfs: /run

tmpfs:
  - /run
  - /tmp

2.7.6.27 ulimits

覆盖容器默认的 ulimit。

ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000

2.7.6.28 volumes

将主机的数据卷或着文件挂载到容器里。

version: "3.7"
services:
  db:
    image: postgres:latest
    volumes:
      - "/localhost/postgres.sock:/var/run/postgres/postgres.sock"
      - "/localhost/data:/var/lib/postgresql/data"

2.8 Docker Machine

2.8.1 简介

Docker Machine是一款可以让您在虚拟主机安装dockers的工具，并可以使用docker-machine命令来管理主机。

Docker Machine也可以管理所有的docker主机，比如快速的给100台主机安装docker。

Docker Machine可以是本地主机的，也可以是云服务器，例如阿里云，腾讯云等。

使用 docker-machine 命令，您可以启动，检查，停止和重新启动托管主机，也可以升级 Docker 客户端和守护程序，以及配置 Docker 客户端与您的主机进行通信。

2.8.2 安装

安装 Docker Machine 之前你需要先安装 Docker。

Docker Machine 可以在多种平台上安装使用，包括 Linux 、MacOS 以及 windows。

2.8.2.1 Linux安装命令

$ base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine &&
  sudo mv /tmp/docker-machine /usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine

2.8.2.2 macOS安装命令

$ base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine

2.8.2.3 windows安装命令

如果你是 Windows 平台，可以使用 Git BASH，并输入以下命令：

$ base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  mkdir -p "$HOME/bin" &&
  curl -L $base/docker-machine-Windows-x86_64.exe > "$HOME/bin/docker-machine.exe" &&
  chmod +x "$HOME/bin/docker-machine.exe"

2.8.2.4 查看是否安装成功

$ docker-machine version
docker-machine version 0.16.0, build 9371605

2.8.3 使用

本章通过 virtualbox 来介绍 docker-machine 的使用方法。其他云服务商操作与此基本一致。具体可以参考每家服务商的指导文档。

2.8.3.1 列出可用的机器

可以看到目前只有这里默认的 default 虚拟机。

$ docker-machine ls

2.8.3.2 创建机器

创建一个名为test的机器

docker-machine create --driver virtualbox test

–driver：指定用来创建机器的驱动类型，这里是 virtualbox。

3.8.3.3 查看机器的ip

$ docker-machine ip test

3.8.3.4 停止机器

$ docker-machine stop test

3.8.3.5 启动机器

$ docker-machine start test

3.8.3.6 进入机器

$ docker-machine ssh test

docker-machine 命令参数说明
docker-machine active：查看当前激活状态的 Docker 主机。
$ docker-machine ls

NAME      ACTIVE   DRIVER         STATE     URL
dev       -        virtualbox     Running   tcp://192.168.99.103:2376
staging   *        digitalocean   Running   tcp://203.0.113.81:2376

$ echo $DOCKER_HOST
tcp://203.0.113.81:2376

$ docker-machine active
staging
config：查看当前激活状态 Docker 主机的连接信息。

create：创建 Docker 主机

env：显示连接到某个主机需要的环境变量

inspect：以 json 格式输出指定Docker的详细信息

ip：获取指定 Docker 主机的地址

kill：直接杀死指定的 Docker 主机

ls：列出所有的管理主机

provision：重新配置指定主机

regenerate-certs：为某个主机重新生成 TLS 信息

restart：重启指定的主机

rm：删除某台 Docker 主机，对应的虚拟机也会被删除

ssh：通过 SSH 连接到主机上，执行命令

scp：在 Docker 主机之间以及 Docker 主机和本地主机之间通过 scp 远程复制数据

mount：使用 SSHFS 从计算机装载或卸载目录

start：启动一个指定的 Docker 主机，如果对象是个虚拟机，该虚拟机将被启动

status：获取指定 Docker 主机的状态(包括：Running、Paused、Saved、Stopped、Stopping、Starting、Error)等

stop：停止一个指定的 Docker 主机

upgrade：将一个指定主机的 Docker 版本更新为最新

url：获取指定 Docker 主机的监听 URL

version：显示 Docker Machine 的版本或者主机 Docker 版本

help：显示帮助信息

2.9 Swarm 集群管理

2.9.1 简介

Docker Swarm 是 Docker 的集群管理工具。它将 Docker 主机池转变为单个虚拟 Docker 主机。 Docker Swarm 提供了标准的 Docker API，所有任何已经与 Docker 守护程序通信的工具都可以使用 Swarm 轻松地扩展到多个主机。

支持的工具包括但不限于以下各项：

Dokku
Docker Compose
Docker Machine
Jenkins

2.9.2 原理

如下图所示，swarm 集群由管理节点（manager）和工作节点（work node）构成。

swarm mananger：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。
work node：即图中的 available node，主要负责运行相应的服务来执行任务（task）。

在这里插入图片描述

2.9.3 使用

以下示例，均以 Docker Machine 和 virtualbox 进行介绍，确保你的主机已安装 virtualbox

2.9.3.1 创建swarm集群管理节点（manager)

创建docker机器

$ docker-machine create -d virtualbox swarm-manager

初始化swarm集群，进行初始化的这台机器，就是集群的管理节点。

$ docker-machine ssh swarm-manager
$ docker swarm init --advertise-addr 192.168.99.107 #这里的 IP 为创建机器时分配的 ip。

在这里插入图片描述

以上输出，证明初始化成功。需要把以下这行复制出来，在增加节点会用到。

docker swarm join --token SWMTKN-1-4oogo9qziq768dma0uh3j0z0m5twlm10iynvz7ixza96k6jh9p-ajkb6w7qd06y1e33yrgko64sk 192.168.99.107:2377

2.9.3.2 创建Swarm集群工作节点（worker)

这里直接创建好这两台机器，swarm-worker1和swarm-worker2

分别进入两个机器里，指定添加至上一步中创建的集群，这里会用到上一步复制的内容。

在这里插入图片描述

以上数据输出说明已经添加成功。

上图中，由于上一步复制的内容比较长，会被自动截断，实际上在图中的运行的命令如下。

docker@swarm-worker1:~$ docker swarm join --token SWMTKN-1-4oogo9qziq768dma0uh3j0z0m5twlm10iynvz7ixza96k6jh9p-ajkb6w7qd06y1e33yrgko64sk 192.168.99.107:2377

2.9.3.3 查看集群信息

进入管理节点，执行：docker info可以查看当前的集群信息

$ docker info

在这里插入图片描述

通过画红圈的地方可以看出，当前集群一共有3个节点，其中一个是管理节点。

2.9.3.4 部署服务到集群中

注意：跟集群管理有关的任何操作，都是在管理节点上操作的。

以下例子，在一个工作节点上创建一个名为 helloworld 的服务，这里是随机指派给一个工作节点：

docker@swarm-manager:~$ docker service create --replicas 1 --name helloworld alpine ping docker.com

2.9.3.5 查看服务部署情况

查看helloworld服务是运行在哪个节点上

docker@swarm-manager:~$ docker service ps helloworld

查看helloworld部署的具体情况

docker@swarm-manager:~$ docker service inspect --pretty helloworld

2.9.3.6 扩展集群服务

我们将上述的helloworld服务扩展到其他两个节点

docker@swarm-manager:~$ docker service scale helloworld=2

2.9.3.7 删除服务

docker@swarm-manager:~$ docker service rm helloworld

查看服务是否删除

docker service ps helloworld

2.9.3.8 滚动升级服务

以下实例，我们将介绍 redis 版本如何滚动升级至更高版本。

创建一个 3.0.6 版本的 redis。

docker@swarm-manager:~$ docker service create --replicas 1 --name redis --update-delay 10s redis:3.0.6

滚动升级redis

docker@swarm-manager:~$ docker service update --image redis:3.0.7 redis

查看是否升级

docker service ps redis

2.9.3.9 停止某个节点接受新的任务

查看所有的节点

docker@swarm-manager:~$ docker node ls

可以查看到AVAILABILITY的状态都是active，可以接受新的任务分配

停止节点swarm-worker1:

$ docker node update --availability drain swarm-worker1

注意：swarm-worker1 状态变为 Drain。不会影响到集群的服务，只是 swarm-worker1 节点不再接收新的任务，集群的负载能力有所下降。

可以通过以下命令重新激活节点：

docker@swarm-manager:~$  docker node update --availability active swarm-worker1

三、Docker实例

1. Docker 安装ubuntu

Ubuntu是基于Debian的Linux操作系统。

1.1 查看可用的ubuntu版本

访问 Ubuntu 镜像库地址： https://hub.docker.com/

可以通过 Sort by 查看其他版本的 Ubuntu。默认是最新版本 ubuntu:latest 。

你可以在下拉列表找到其他想要的版本。

1.2 拉取最新的ubuntu镜像

$ docker pull ubuntu

或者

$ docker pull ubuntu:latest

1.3 查看本地镜像

$ docker images

1.4 运行容器，并且可以通过exec命令进入容器

$ docker run -itd --name ubuntu-test ubuntu

1.5 安装成功

最后我们可以通过 docker ps 命令查看容器的运行信息：

2. Docker安装CentOS

CentOS（Community Enterprise Operating System）是 Linux 发行版之一，它是来自于 Red Hat Enterprise Linux(RHEL) 依照开放源代码规定发布的源代码所编译而成。由于出自同样的源代码，因此有些要求高度稳定性的服务器以 CentOS 替代商业版的 Red Hat Enterprise Linux 使用。

2.1 查看可用的CentOS版本

进入Docker官网，查看所有的版本

2.2 拉取指定版本的CentOS镜像，这里我们以安装指定版本为例（centOS7）

$ docker pull centos:centos7

1.3 查看本地的镜像

使用以下命令来查看是否已安装了 centos7：

$ docker images

1.4 运行容器，并且可以通过 exec 命令进入 CentOS 容器

$ docker run -itd --name centos-test centos:centos7

1.5 安装成功

最后我们可以通过 docker ps 命令查看容器的运行信息

3. Docker 安装 nginx

Nginx 是一个高性能的 HTTP 和反向代理 web 服务器，同时也提供了 IMAP/POP3/SMTP 服务。

3.1 查看可用的nginx版本

进入docker镜像搜索网址，搜索nginx，寻找自己所想要的版本。

此外，我们还可以用 docker search nginx 命令来查看可用版本：

$ docker search nginx
NAME                      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
nginx                     Official build of Nginx.                        3260      [OK]       
jwilder/nginx-proxy       Automated Nginx reverse proxy for docker c...   674                  [OK]
richarvey/nginx-php-fpm   Container running Nginx + PHP-FPM capable ...   207                  [OK]
million12/nginx-php       Nginx + PHP-FPM 5.5, 5.6, 7.0 (NG), CentOS...   67                   [OK]
maxexcloo/nginx-php       Docker framework container with Nginx and ...   57                   [OK]
...

3.2 拉取最新版的Nginx镜像

这里我们拉取官方的最新版本的镜像：

$ docker pull nginx:latest

3.3 查看本地镜像

使用以下命令来查看是否已安装了 nginx：

$ docker images

3.4 运行容器

安装完成，我们可以使用以下命令来运行nginx容器

$ docker run --name nginx-test -p 8080:80 -d nginx

参数说明：

–name nginx-test：容器名称。
-p 8080:80：端口进行映射，将本地 8080 端口映射到容器内部的 80 端口。
-d nginx：设置容器在在后台一直运行。

3.5 安装成功

最后我们可以通过浏览器可以直接访问 8080 端口的 nginx 服务：

本机IP:8080

4. Dokcer 安装 node.js

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，是一个让 JavaScript 运行在服务端的开发平台。

4.1 查看可用的node版本

docker hub搜索node，查看所有镜像，选择自己想要的版本。

此外，我们可以使用docker search node命令来查看可用版本

$ docker search node

4.2 拉取最新版的node镜像

这里我们拉取官方最新版的镜像

$ docker pull node:latest

4.3 查看本地镜像

使用以下命令来查看是否已安装了 node

$ docker images

4.4 运行容器

安装完成后，我们可以使用以下命令来运行 node 容器：

$ docker run -itd --name node-test node

参数说明：

–name node-test：容器名称。

4.5 安装成功

最后进入查看容器运行的 node 版本:

$ docker exec -it node-test /bin/bash
root@6c5d265c68a6:/# node -v

5. Docker 安装 PHP

5.1 方法一：Docker pull php

查找docker hub上的镜像。

可以通过 Sort by 查看其他版本的 php，默认是最新版本 php:latest。

此外，我们还可以用 docker search php 命令来查看可用版本：

runoob@runoob:~/php-fpm$ docker search php
NAME                      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
php                       While designed for web development, the PH...   1232      [OK]       
richarvey/nginx-php-fpm   Container running Nginx + PHP-FPM capable ...   207                  [OK]
phpmyadmin/phpmyadmin     A web interface for MySQL and MariaDB.          123                  [OK]
eboraas/apache-php        PHP5 on Apache (with SSL support), built o...   69                   [OK]
php-zendserver            Zend Server - the integrated PHP applicati...   69        [OK]       
million12/nginx-php       Nginx + PHP-FPM 5.5, 5.6, 7.0 (NG), CentOS...   67                   [OK]
webdevops/php-nginx       Nginx with PHP-FPM                              39                   [OK]
webdevops/php-apache      Apache with PHP-FPM (based on webdevops/php)    14                   [OK]
phpunit/phpunit           PHPUnit is a programmer-oriented testing f...   14                   [OK]
tetraweb/php              PHP 5.3, 5.4, 5.5, 5.6, 7.0 for CI and run...   12                   [OK]
webdevops/php             PHP (FPM and CLI) service container             10                   [OK]
...

这里我们拉取官方的镜像,标签为5.6-fpm

runoob@runoob:~/php-fpm$ docker pull php:5.6-fpm

等待下载完成后，我们就可以在本地镜像列表里查到REPOSITORY为php,标签为5.6-fpm的镜像。

runoob@runoob:~/php-fpm$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
php                 5.6-fpm             025041cd3aa5        6 days ago          456.3 MB

5.2 方法二：Nginx+Php部署

启动php

$ docker run --name  myphp-fpm -v ~/nginx/www:/www  -d php:5.6-fpm

命令说明：

–name myphp-fpm : 将容器命名为 myphp-fpm。
-v ~/nginx/www:/www : 将主机中项目的目录 www 挂载到容器的 /www

创建 ~/nginx/conf/conf.d 目录：

mkdir ~/nginx/conf/conf.d

在该目录下添加 ~/nginx/conf/conf.d/runoob-test-php.conf 文件，内容如下：

server {
    listen       80;
    server_name  localhost;

    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm index.php;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    location ~ \.php$ {
        fastcgi_pass   php:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  /www/$fastcgi_script_name;
        include        fastcgi_params;
    }
}

配置文件说明：

php:9000: 表示 php-fpm 服务的 URL，下面我们会具体说明。
/www/: 是 myphp-fpm 中 php 文件的存储路径，映射到本地的 ~/nginx/www 目录。

启动nginx:

docker run --name runoob-php-nginx -p 8083:80 -d \
    -v ~/nginx/www:/usr/share/nginx/html:ro \
    -v ~/nginx/conf/conf.d:/etc/nginx/conf.d:ro \
    --link myphp-fpm:php \
    nginx

-p 8083:80: 端口映射，把 nginx 中的 80 映射到本地的 8083 端口。
~/nginx/www: 是本地 html 文件的存储目录，/usr/share/nginx/html 是容器内 html 文件的存储目录。
~/nginx/conf/conf.d: 是本地 nginx 配置文件的存储目录，/etc/nginx/conf.d 是容器内 nginx 配置文件的存储目录。
–link myphp-fpm:php: 把 myphp-fpm 的网络并入 *nginx*，并通过修改 nginx 的 /etc/hosts，把域名 php 映射成 127.0.0.1，让 nginx 通过 php:9000 访问 php-fpm。

接下来我们在 ~/nginx/www 目录下创建 index.php，代码如下：

<?php
echo phpinfo();
?>

浏览器打开 http://127.0.0.1:8083/index.php，显示如下：

在这里插入图片描述

6. Docker 安装 MySql

MySQL 是世界上最受欢迎的开源数据库。凭借其可靠性、易用性和性能，MySQL 已成为 Web 应用程序的数据库优先选择。

6.1 查看可用的MySql版本

通过Docker hub官网搜索mysql，寻找自己需要的镜像

此外，我们还可以用 docker search mysql命令来查看可用版本：

$ docker search mysql
NAME                     DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                    MySQL is a widely used, open-source relati...   2529      [OK]       
mysql/mysql-server       Optimized MySQL Server Docker images. Crea...   161                  [OK]
centurylink/mysql        Image containing mysql. Optimized to be li...   45                   [OK]
sameersbn/mysql                                                          36                   [OK]
google/mysql             MySQL server for Google Compute Engine          16                   [OK]
appcontainers/mysql      Centos/Debian Based Customizable MySQL Con...   8                    [OK]
marvambass/mysql         MySQL Server based on Ubuntu 14.04              6                    [OK]
drupaldocker/mysql       MySQL for Drupal                                2                    [OK]
azukiapp/mysql           Docker image to run MySQL by Azuki - http:...   2                    [OK]
...

6.2 拉取MySQL镜像

这里我们拉取官方最新版的镜像

$ docker pull mysql:latest

6.3 查看本地的镜像

使用以下命令来查看是否已安装了 mysql：

$ docker images

在上图中可以看到我们已经安装了最新版本（latest）的 mysql 镜像。

6.4 运行容器

安装完成后，我们可以使用以下命令来运行 mysql 容器：

$ docker run -itd --name mysql-test -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

参数说明：

-p 3306:3306 ：映射容器服务的 3306 端口到宿主机的 3306 端口，外部主机可以直接通过 宿主机ip:3306 访问到 MySQL 的服务。
MYSQL_ROOT_PASSWORD=123456：设置 MySQL 服务 root 用户的密码。

6.5 安装成功

通过 docker ps 命令查看是否安装成功：

本机可以通过 root 和密码 123456 访问 MySQL 服务。

/# mysql -h localhost -u root -p

7. Dokcer 安装 Tomcat

7.1 方法一：Docker pull tomcat

在Docker官网寻找Tomcat镜像。

此外，我们还可以在控制台使用 docker search tomcat 命令来查看可用版本：

runoob@runoob:~/tomcat$ docker search tomcat
NAME                       DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
tomcat                     Apache Tomcat is an open source implementa...   744       [OK]       
dordoka/tomcat             Ubuntu 14.04, Oracle JDK 8 and Tomcat 8 ba...   19                   [OK]
consol/tomcat-7.0          Tomcat 7.0.57, 8080, "admin/admin"              16                   [OK]
consol/tomcat-8.0          Tomcat 8.0.15, 8080, "admin/admin"              14                   [OK]
cloudesire/tomcat          Tomcat server, 6/7/8                            8                    [OK]
davidcaste/alpine-tomcat   Apache Tomcat 7/8 using Oracle Java 7/8 wi...   6                    [OK]
andreptb/tomcat            Debian Jessie based image with Apache Tomc...   4                    [OK]
kieker/tomcat                                                              2                    [OK]
fbrx/tomcat                Minimal Tomcat image based on Alpine Linux      2                    [OK]
jtech/tomcat               Latest Tomcat production distribution on l...   1                    [OK]

这里我们拉取官方的镜像

runoob@runoob:~/tomcat$ docker pull tomcat

等待下载完成后，我们就可以在本地镜像列表中找到tomcat的镜像

runoob@runoob:~/tomcat$ docker images|grep tomcat
tomcat              latest              70f819d3d2d9        7 days ago          335.8 MB

7.2 方法二：通过Dokcerfile 构建

创建Dockerfile

首先，创建目录tomcat,用于存放后面的相关东西。

runoob@runoob:~$ mkdir -p ~/tomcat/webapps ~/tomcat/logs ~/tomcat/conf

webapps 目录将映射为 tomcat 容器配置的应用程序目录。

logs 目录将映射为 tomcat 容器的日志目录。

conf 目录里的配置文件将映射为 tomcat 容器的配置文件。

进入创建的 tomcat 目录，创建 Dockerfile。

FROM openjdk:8-jre

ENV CATALINA_HOME /usr/local/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH
RUN mkdir -p "$CATALINA_HOME"
WORKDIR $CATALINA_HOME

# let "Tomcat Native" live somewhere isolated
ENV TOMCAT_NATIVE_LIBDIR $CATALINA_HOME/native-jni-lib
ENV LD_LIBRARY_PATH ${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$TOMCAT_NATIVE_LIBDIR

# runtime dependencies for Tomcat Native Libraries
# Tomcat Native 1.2+ requires a newer version of OpenSSL than debian:jessie has available
# > checking OpenSSL library version >= 1.0.2...
# > configure: error: Your version of OpenSSL is not compatible with this version of tcnative
# see http://tomcat.10.x6.nabble.com/VOTE-Release-Apache-Tomcat-8-0-32-tp5046007p5046024.html (and following discussion)
# and https://github.com/docker-library/tomcat/pull/31
ENV OPENSSL_VERSION 1.1.0f-3+deb9u2
RUN set -ex; \
    currentVersion="$(dpkg-query --show --showformat '${Version}\n' openssl)"; \
    if dpkg --compare-versions "$currentVersion" '<<' "$OPENSSL_VERSION"; then \
        if ! grep -q stretch /etc/apt/sources.list; then \
# only add stretch if we're not already building from within stretch
            { \
                echo 'deb http://deb.debian.org/debian stretch main'; \
                echo 'deb http://security.debian.org stretch/updates main'; \
                echo 'deb http://deb.debian.org/debian stretch-updates main'; \
            } > /etc/apt/sources.list.d/stretch.list; \
            { \
# add a negative "Pin-Priority" so that we never ever get packages from stretch unless we explicitly request them
                echo 'Package: *'; \
                echo 'Pin: release n=stretch*'; \
                echo 'Pin-Priority: -10'; \
                echo; \
# ... except OpenSSL, which is the reason we're here
                echo 'Package: openssl libssl*'; \
                echo "Pin: version $OPENSSL_VERSION"; \
                echo 'Pin-Priority: 990'; \
            } > /etc/apt/preferences.d/stretch-openssl; \
        fi; \
        apt-get update; \
        apt-get install -y --no-install-recommends openssl="$OPENSSL_VERSION"; \
        rm -rf /var/lib/apt/lists/*; \
    fi

RUN apt-get update && apt-get install -y --no-install-recommends \
        libapr1 \
    && rm -rf /var/lib/apt/lists/*

# see https://www.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/KEYS
# see also "update.sh" (https://github.com/docker-library/tomcat/blob/master/update.sh)
ENV GPG_KEYS 05AB33110949707C93A279E3D3EFE6B686867BA6 07E48665A34DCAFAE522E5E6266191C37C037D42 47309207D818FFD8DCD3F83F1931D684307A10A5 541FBE7D8F78B25E055DDEE13C370389288584E7 61B832AC2F1C5A90F0F9B00A1C506407564C17A3 713DA88BE50911535FE716F5208B0AB1D63011C7 79F7026C690BAA50B92CD8B66A3AD3F4F22C4FED 9BA44C2621385CB966EBA586F72C284D731FABEE A27677289986DB50844682F8ACB77FC2E86E29AC A9C5DF4D22E99998D9875A5110C01C5A2F6059E7 DCFD35E0BF8CA7344752DE8B6FB21E8933C60243 F3A04C595DB5B6A5F1ECA43E3B7BBB100D811BBE F7DA48BB64BCB84ECBA7EE6935CD23C10D498E23

ENV TOMCAT_MAJOR 8
ENV TOMCAT_VERSION 8.5.32
ENV TOMCAT_SHA512 fc010f4643cb9996cad3812594190564d0a30be717f659110211414faf8063c61fad1f18134154084ad3ddfbbbdb352fa6686a28fbb6402d3207d4e0a88fa9ce

ENV TOMCAT_TGZ_URLS \
# https://issues.apache.org/jira/browse/INFRA-8753?focusedCommentId=14735394#comment-14735394
    https://www.apache.org/dyn/closer.cgi?action=download&filename=tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
# if the version is outdated, we might have to pull from the dist/archive :/
    https://www-us.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
    https://www.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
    https://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz

ENV TOMCAT_ASC_URLS \
    https://www.apache.org/dyn/closer.cgi?action=download&filename=tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc \
# not all the mirrors actually carry the .asc files :'(
    https://www-us.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc \
    https://www.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc \
    https://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc

RUN set -eux; \
    \
    savedAptMark="$(apt-mark showmanual)"; \
    apt-get update; \
    \
    apt-get install -y --no-install-recommends gnupg dirmngr; \
    \
    export GNUPGHOME="$(mktemp -d)"; \
    for key in $GPG_KEYS; do \
        gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$key"; \
    done; \
    \
    apt-get install -y --no-install-recommends wget ca-certificates; \
    \
    success=; \
    for url in $TOMCAT_TGZ_URLS; do \
        if wget -O tomcat.tar.gz "$url"; then \
            success=1; \
            break; \
        fi; \
    done; \
    [ -n "$success" ]; \
    \
    echo "$TOMCAT_SHA512 *tomcat.tar.gz" | sha512sum -c -; \
    \
    success=; \
    for url in $TOMCAT_ASC_URLS; do \
        if wget -O tomcat.tar.gz.asc "$url"; then \
            success=1; \
            break; \
        fi; \
    done; \
    [ -n "$success" ]; \
    \
    gpg --batch --verify tomcat.tar.gz.asc tomcat.tar.gz; \
    tar -xvf tomcat.tar.gz --strip-components=1; \
    rm bin/*.bat; \
    rm tomcat.tar.gz*; \
    rm -rf "$GNUPGHOME"; \
    \
    nativeBuildDir="$(mktemp -d)"; \
    tar -xvf bin/tomcat-native.tar.gz -C "$nativeBuildDir" --strip-components=1; \
    apt-get install -y --no-install-recommends \
        dpkg-dev \
        gcc \
        libapr1-dev \
        libssl-dev \
        make \
        "openjdk-${JAVA_VERSION%%[.~bu-]*}-jdk=$JAVA_DEBIAN_VERSION" \
    ; \
    ( \
        export CATALINA_HOME="$PWD"; \
        cd "$nativeBuildDir/native"; \
        gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)"; \
        ./configure \
            --build="$gnuArch" \
            --libdir="$TOMCAT_NATIVE_LIBDIR" \
            --prefix="$CATALINA_HOME" \
            --with-apr="$(which apr-1-config)" \
            --with-java-home="$(docker-java-home)" \
            --with-ssl=yes; \
        make -j "$(nproc)"; \
        make install; \
    ); \
    rm -rf "$nativeBuildDir"; \
    rm bin/tomcat-native.tar.gz; \
    \
# reset apt-mark's "manual" list so that "purge --auto-remove" will remove all build dependencies
    apt-mark auto '.*' > /dev/null; \
    [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark; \
    apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
    rm -rf /var/lib/apt/lists/*; \
    \
# sh removes env vars it doesn't support (ones with periods)
# https://github.com/docker-library/tomcat/issues/77
    find ./bin/ -name '*.sh' -exec sed -ri 's|^#!/bin/sh$|#!/usr/bin/env bash|' '{}' +

# verify Tomcat Native is working properly
RUN set -e \
    && nativeLines="$(catalina.sh configtest 2>&1)" \
    && nativeLines="$(echo "$nativeLines" | grep 'Apache Tomcat Native')" \
    && nativeLines="$(echo "$nativeLines" | sort -u)" \
    && if ! echo "$nativeLines" | grep 'INFO: Loaded APR based Apache Tomcat Native library' >&2; then \
        echo >&2 "$nativeLines"; \
        exit 1; \
    fi

EXPOSE 8080
CMD ["catalina.sh", "run"]

通过Dockerfile创建一个镜像，替换成你自己的名字

runoob@runoob:~/tomcat$ docker build -t tomcat .

创建完成后，我们可以在本地的镜像列表里查找到刚刚创建的镜像：

runoob@runoob:~/tomcat$ docker images|grep tomcat
tomcat              latest              70f819d3d2d9        7 days ago          335.8 MB

7.3 使用 tomcat 镜像

运行容器

runoob@runoob:~/tomcat$ docker run --name tomcat -p 8080:8080 -v $PWD/test:/usr/local/tomcat/webapps/test -d tomcat  
acb33fcb4beb8d7f1ebace6f50f5fc204b1dbe9d524881267aa715c61cf75320
runoob@runoob:~/tomcat$

命令说明：

**-p 8080:8080：**将主机的 8080 端口映射到容器的 8080 端口。

**-v $PWD/test:/usr/local/tomcat/webapps/test：**将主机中当前目录下的 test 挂载到容器的 /test。

查看容器启动情况

runoob@runoob:~/tomcat$ docker ps 
CONTAINER ID    IMAGE     COMMAND               ... PORTS                    NAMES
acb33fcb4beb    tomcat    "catalina.sh run"     ... 0.0.0.0:8080->8080/tcp   tomcat

通过浏览器访问：

本机IP:8080

8. Docker 安装 Python

8.1 方法一：docker pull python:3.5

在dockers hub上寻找你想要的python

此外，我们可以使用docker search python命令来查看可用版本

runoob@runoob:~/python$ docker search python
NAME                           DESCRIPTION                        STARS     OFFICIAL   AUTOMATED
python                         Python is an interpreted,...       982       [OK]       
kaggle/python                  Docker image for Python...         33                   [OK]
azukiapp/python                Docker image to run Python ...     3                    [OK]
vimagick/python                mini python                                  2          [OK]
tsuru/python                   Image for the Python ...           2                    [OK]
pandada8/alpine-python         An alpine based python image                 1          [OK]
1science/python                Python Docker images based on ...  1                    [OK]
lucidfrontier45/python-uwsgi   Python with uWSGI                  1                    [OK]
orbweb/python                  Python image                       1                    [OK]
pathwar/python                 Python template for Pathwar levels 1                    [OK]
rounds/10m-python              Python, setuptools and pip.        0                    [OK]
ruimashita/python              ubuntu 14.04 python                0                    [OK]
tnanba/python                  Python on CentOS-7 image.          0                    [OK]

这里我们拉取官方的镜像,标签为3.5

runoob@runoob:~/python$ docker pull python:3.5

等待下载完成后，我们就可以在本地镜像列表里查到 REPOSITORY 为python, 标签为 3.5 的镜像。

runoob@runoob:~/python$ docker images python:3.5 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
python              3.5              045767ddf24a        9 days ago          684.1 MB

8.2 方法二：通过Dockerfile构建

创建 Dockerfile</p>

首先，创建目录 python，用于存放后面的相关东西。

runoob@runoob:~$ mkdir -p ~/python ~/python/myapp

myapp 目录将映射为 python 容器配置的应用目录。

进入创建的 python 目录，创建 Dockerfile。

FROM buildpack-deps:jessie

# remove several traces of debian python
RUN apt-get purge -y python.*

# http://bugs.python.org/issue19846
# > At the moment, setting "LANG=C" on a Linux system *fundamentally breaks Python 3*, and that's not OK.
ENV LANG C.UTF-8

# gpg: key F73C700D: public key "Larry Hastings <larry@hastings.org>" imported
ENV GPG_KEY 97FC712E4C024BBEA48A61ED3A5CA953F73C700D

ENV PYTHON_VERSION 3.5.1

# if this is called "PIP_VERSION", pip explodes with "ValueError: invalid truth value '<VERSION>'"
ENV PYTHON_PIP_VERSION 8.1.2

RUN set -ex \
        && curl -fSL "https://www.python.org/ftp/python/${PYTHON_VERSION%%[a-z]*}/Python-$PYTHON_VERSION.tar.xz" -o python.tar.xz \
        && curl -fSL "https://www.python.org/ftp/python/${PYTHON_VERSION%%[a-z]*}/Python-$PYTHON_VERSION.tar.xz.asc" -o python.tar.xz.asc \
        && export GNUPGHOME="$(mktemp -d)" \
        && gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$GPG_KEY" \
        && gpg --batch --verify python.tar.xz.asc python.tar.xz \
        && rm -r "$GNUPGHOME" python.tar.xz.asc \
        && mkdir -p /usr/src/python \
        && tar -xJC /usr/src/python --strip-components=1 -f python.tar.xz \
        && rm python.tar.xz \
        \
        && cd /usr/src/python \
        && ./configure --enable-shared --enable-unicode=ucs4 \
        && make -j$(nproc) \
        && make install \
        && ldconfig \
        && pip3 install --no-cache-dir --upgrade --ignore-installed pip==$PYTHON_PIP_VERSION \
        && find /usr/local -depth \
                \( \
                    \( -type d -a -name test -o -name tests \) \
                    -o \
                    \( -type f -a -name '*.pyc' -o -name '*.pyo' \) \
                \) -exec rm -rf '{}' + \
        && rm -rf /usr/src/python ~/.cache

# make some useful symlinks that are expected to exist
RUN cd /usr/local/bin \
        && ln -s easy_install-3.5 easy_install \
        && ln -s idle3 idle \
        && ln -s pydoc3 pydoc \
        && ln -s python3 python \
        && ln -s python3-config python-config

CMD ["python3"]

通过 Dockerfile 创建一个镜像，替换成你自己的名字：

runoob@runoob:~/python$ docker build -t python:3.5 .

创建完成后，我们可以在本地的镜像列表里查找到刚刚创建的镜像：

8.3 使用python镜像

在~/python/myapp 目录下创建一个 helloworld.py 文件，代码如下：

#!/usr/bin/python

print("Hello, World!");

运行容器

runoob@runoob:~/python$ docker run  -v $PWD/myapp:/usr/src/myapp  -w /usr/src/myapp python:3.5 python helloworld.py

命令说明：

-v $PWD/myapp:/usr/src/myapp: 将主机中当前目录下的 myapp 挂载到容器的 /usr/src/myapp。

-w /usr/src/myapp: 指定容器的 /usr/src/myapp 目录为工作目录。

python helloworld.py: 使用容器的 python 命令来执行工作目录中的 helloworld.py 文件。

输出结果：

Hello, World!

9. Dokcer 安装 redis

Redis 是一个开源的使用 ANSI C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 的 NoSQL 数据库，并提供多种语言的 API。

9.1 查看可用的redis版本

进入docker hub官网，搜索redis，寻找自己所想使用的版本。

此外，我们还可以用 docker search redis 命令来查看可用版本：

$ docker search  redis
NAME                      DESCRIPTION                   STARS  OFFICIAL  AUTOMATED
redis                     Redis is an open source ...   2321   [OK]       
sameersbn/redis                                         32                   [OK]
torusware/speedus-redis   Always updated official ...   29             [OK]
bitnami/redis             Bitnami Redis Docker Image    22                   [OK]
anapsix/redis             11MB Redis server image ...   6                    [OK]
webhippie/redis           Docker images for redis       4                    [OK]
clue/redis-benchmark      A minimal docker image t...   3                    [OK]
williamyeh/redis          Redis image for Docker        3                    [OK]
unblibraries/redis        Leverages phusion/baseim...   2                    [OK]
greytip/redis             redis 3.0.3                   1                    [OK]
servivum/redis            Redis Docker Image            1                    [OK]
...

9.2 拉取最新版的Redis镜像

这里我们拉取最新版的redis镜像

$ docker pull redis:latest

9.3 查看本地镜像

使用以下命令查看是否安装了redis

$ docker images

9.4 运行容器

安装完成后，我们可以使用以下命令来运行 redis 容器：

$ docker run -itd --name redis-test -p 6379:6379 redis

参数说明：

-p 6379:6379：映射容器服务的 6379 端口到宿主机的 6379 端口。外部可以直接通过宿主机ip:6379 访问到 Redis 的服务。

9.5 安装成功

最后我们可以使用docker ps 命令来查看容器的运行信息

接着我们使用redis-cli连接测试使用redis服务

$ docker exec -it redis-test /bin/bash

10. Docker 安装 mongoDB

MongoDB 是一个免费的开源跨平台面向文档的 NoSQL 数据库程序。

10.1 查看可用的mongoDB版本

通过docker hub搜索mongoDB，寻找我们所使用的产品。

此外，我们还可以使用docker search monge命令来查看可用版本

$ docker search mongo
NAME                              DESCRIPTION                      STARS     OFFICIAL   AUTOMATED
mongo                             MongoDB document databases ...   1989      [OK]       
mongo-express                     Web-based MongoDB admin int...   22        [OK]       
mvertes/alpine-mongo              light MongoDB container          19                   [OK]
mongooseim/mongooseim-docker      MongooseIM server the lates...   9                    [OK]
torusware/speedus-mongo           Always updated official Mon...   9                    [OK]
jacksoncage/mongo                 Instant MongoDB sharded cluster  6                    [OK]
mongoclient/mongoclient           Official docker image for M...   4                    [OK]
jadsonlourenco/mongo-rocks        Percona Mongodb with Rocksd...   4                    [OK]
asteris/apache-php-mongo          Apache2.4 + PHP + Mongo + m...   2                    [OK]
19hz/mongo-container              Mongodb replicaset for coreos    1                    [OK]
nitra/mongo                       Mongo3 centos7                   1                    [OK]
ackee/mongo                       MongoDB with fixed Bluemix p...  1                    [OK]
kobotoolbox/mongo                 https://github.com/kobotoolb...  1                    [OK]
valtlfelipe/mongo                 Docker Image based on the la...  1                    [OK]

10.2 拉取最新版的MongoDB镜像

这里我们拉取官方最新版的镜像

$ docker pull mongo:latest

10.3 查看本地镜像

使用以下命令来查看是否已安装了 mongo：

$ docker images

10.4 运行容器

安装完成后，我们可以使用以下命令来运行 mongo 容器：

$ docker run -itd --name mongo -p 27017:27017 mongo --auth

参数说明：

-p 27017:27017 ：映射容器服务的 27017 端口到宿主机的 27017 端口。外部可以直接通过宿主机 ip:27017 访问到 mongo 的服务。
–auth：需要密码才能访问容器服务。

10.5 安装成功

最后我们可以通过 docker ps 命令查看容器的运行信息：

接着使用以下命令添加用户和设置密码，并且尝试连接。

$ docker exec -it mongo mongo admin
# 创建一个名为 admin，密码为 123456 的用户。
>  db.createUser({ user:'admin',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'},"readWriteAnyDatabase"]});
# 尝试使用上面创建的用户信息进行连接。
> db.auth('admin', '123456')

11. Docker 安装 Apache

11.1 方法一：docker pull httpd

在docker hub查找httpd，寻找自己需要的版本。。

此外，我们可以使用docker search httpd命令查看可用版本

runoob@runoob:~/apache$ docker search httpd
NAME                           DESCRIPTION                  STARS  OFFICIAL AUTOMATED
httpd                          The Apache HTTP Server ..    524     [OK]       
centos/httpd                                                7                [OK]
rgielen/httpd-image-php5       Docker image for Apache...   1                [OK]
microwebapps/httpd-frontend    Httpd frontend allowing...   1                [OK]
lolhens/httpd                  Apache httpd 2 Server        1                [OK]
publici/httpd                  httpd:latest                 0                [OK]
publicisworldwide/httpd        The Apache httpd webser...   0                [OK]
rgielen/httpd-image-simple     Docker image for simple...   0                [OK]
solsson/httpd                  Derivatives of the offi...   0                [OK]
rgielen/httpd-image-drush      Apache HTTPD + Drupal S...   0                [OK]
learninglayers/httpd                                        0                [OK]
sohrabkhan/httpd               Docker httpd + php5.6 (...   0                [OK]
aintohvri/docker-httpd         Apache HTTPD Docker ext...   0                [OK]
alizarion/httpd                httpd on centos with mo...   0                [OK]
...

这里我们拉取官方的镜像

runoob@runoob:~/apache$ docker pull httpd

等待下载完成之后，我们就可以看到镜像库中存在httpd的镜像

11.2 通过Dockerfile 构建

创建Dockerfile

首先，创建一个目录apache，用于存放后面相关的东西。

runoob@runoob:~$ mkdir -p  ~/apache/www ~/apache/logs ~/apache/conf

www 目录将映射为 apache 容器配置的应用程序目录。

logs 目录将映射为 apache 容器的日志目录。

conf 目录里的配置文件将映射为 apache 容器的配置文件。

进入创建的 apache 目录，创建 Dockerfile。

FROM debian:jessie

# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added
#RUN groupadd -r www-data && useradd -r --create-home -g www-data www-data

ENV HTTPD_PREFIX /usr/local/apache2
ENV PATH $PATH:$HTTPD_PREFIX/bin
RUN mkdir -p "$HTTPD_PREFIX" \
    && chown www-data:www-data "$HTTPD_PREFIX"
WORKDIR $HTTPD_PREFIX

# install httpd runtime dependencies
# https://httpd.apache.org/docs/2.4/install.html#requirements
RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        libapr1 \
        libaprutil1 \
        libaprutil1-ldap \
        libapr1-dev \
        libaprutil1-dev \
        libpcre++0 \
        libssl1.0.0 \
    && rm -r /var/lib/apt/lists/*

ENV HTTPD_VERSION 2.4.20
ENV HTTPD_BZ2_URL https://www.apache.org/dist/httpd/httpd-$HTTPD_VERSION.tar.bz2

RUN buildDeps=' \
        ca-certificates \
        curl \
        bzip2 \
        gcc \
        libpcre++-dev \
        libssl-dev \
        make \
    ' \
    set -x \
    && apt-get update \
    && apt-get install -y --no-install-recommends $buildDeps \
    && rm -r /var/lib/apt/lists/* \
    \
    && curl -fSL "$HTTPD_BZ2_URL" -o httpd.tar.bz2 \
    && curl -fSL "$HTTPD_BZ2_URL.asc" -o httpd.tar.bz2.asc \
# see https://httpd.apache.org/download.cgi#verify
    && export GNUPGHOME="$(mktemp -d)" \
    && gpg --keyserver ha.pool.sks-keyservers.net --recv-keys A93D62ECC3C8EA12DB220EC934EA76E6791485A8 \
    && gpg --batch --verify httpd.tar.bz2.asc httpd.tar.bz2 \
    && rm -r "$GNUPGHOME" httpd.tar.bz2.asc \
    \
    && mkdir -p src \
    && tar -xvf httpd.tar.bz2 -C src --strip-components=1 \
    && rm httpd.tar.bz2 \
    && cd src \
    \
    && ./configure \
        --prefix="$HTTPD_PREFIX" \
        --enable-mods-shared=reallyall \
    && make -j"$(nproc)" \
    && make install \
    \
    && cd .. \
    && rm -r src \
    \
    && sed -ri \
        -e 's!^(\s*CustomLog)\s+\S+!\1 /proc/self/fd/1!g' \
        -e 's!^(\s*ErrorLog)\s+\S+!\1 /proc/self/fd/2!g' \
        "$HTTPD_PREFIX/conf/httpd.conf" \
    \
    && apt-get purge -y --auto-remove $buildDeps

COPY httpd-foreground /usr/local/bin/

EXPOSE 80
CMD ["httpd-foreground"]

Dockerfile文件中 COPY httpd-foreground /usr/local/bin/ 是将当前目录下的httpd-foreground拷贝到镜像里，作为httpd服务的启动脚本，所以我们要在本地创建一个脚本文件httpd-foreground

#!/bin/bash
set -e

# Apache gets grumpy about PID files pre-existing
rm -f /usr/local/apache2/logs/httpd.pid

exec httpd -DFOREGROUND

赋予 httpd-foreground 文件可执行权限。

runoob@runoob:~/apache$ chmod +x httpd-foreground

通过 Dockerfile 创建一个镜像，替换成你自己的名字。

runoob@runoob:~/apache$ docker build -t httpd .

创建完成后，我们可以在本地的镜像列表里查找到刚刚创建的镜像。

runoob@runoob:~/apache$ docker images httpd
REPOSITORY     TAG        IMAGE ID        CREATED           SIZE
httpd          latest     da1536b4ef14    23 seconds ago    195.1 MB

11.3 使用Apache镜像

运行容器

docker run -p 80:80 -v $PWD/www/:/usr/local/apache2/htdocs/ -v $PWD/conf/httpd.conf:/usr/local/apache2/conf/httpd.conf -v $PWD/logs/:/usr/local/apache2/logs/ -d httpd

命令说明：

-p 80:80: 将容器的 80 端口映射到主机的 80 端口。

-v $PWD/www/:/usr/local/apache2/htdocs/: 将主机中当前目录下的 www 目录挂载到容器的 /usr/local/apache2/htdocs/。

-v $PWD/conf/httpd.conf:/usr/local/apache2/conf/httpd.conf: 将主机中当前目录下的 conf/httpd.conf 文件挂载到容器的 /usr/local/apache2/conf/httpd.conf。

-v $PWD/logs/:/usr/local/apache2/logs/: 将主机中当前目录下的 logs 目录挂载到容器的 /usr/local/apache2/logs/。

查看容器启动情况：

runoob@runoob:~/apache$ docker ps
CONTAINER ID  IMAGE   COMMAND             ... PORTS               NAMES
79a97f2aac37  httpd   "httpd-foreground"  ... 0.0.0.0:80->80/tcp  sharp_swanson

通过浏览器访问：

本机IP

四、Docker 参考手册

1. Docker 命令大全(菜鸟)

容器生命周期管理

run
start/stop/restart
kill
rm
pause/unpause
create
exec

容器操作

ps
inspect
top
attach
events
logs
wait
export
port

容器rootfs命令

commit
cp
diff

镜像仓库

login
pull
push
search

本地镜像管理

images
rmi
tag
build
history
save
load
import

info|version

info
version

2. Docker资源汇总

Docker 资源

Docker 官方主页: https://www.docker.com
Docker 官方博客: https://blog.docker.com/
Docker 官方文档: https://docs.docker.com/
Docker Store: https://store.docker.com
Docker Cloud: https://cloud.docker.com
Docker Hub: https://hub.docker.com
Docker 的源代码仓库: https://github.com/moby/moby
Docker 发布版本历史: https://docs.docker.com/release-notes/
Docker 常见问题: https://docs.docker.com/engine/faq/
Docker 远端应用 API: https://docs.docker.com/develop/sdk/

Docker 国内镜像

阿里云的加速器：https://help.aliyun.com/document_detail/60750.html

网易加速器：http://hub-mirror.c.163.com

官方中国加速器：https://registry.docker-cn.com

ustc 的镜像：https://docker.mirrors.ustc.edu.cn

daocloud：https://www.daocloud.io/mirror#accelerator-doc（注册后使用）

如果有更好的资源，欢迎通过下面的笔记来分享。

娄黔子

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Docker入门及进阶教程

阅读声明：该教程笔记来源于dockers——菜鸟教程一、Docker介绍1. Docker教程Docker是一个开源的容器引擎，基于Go语言并遵从Apache2.0协议开源。Docker可以让开发者打包他们的应用以及依赖包到一个轻量级，可移植的容器，然后发布到任何流行的Linux机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似iphone的app），更重要的是容器的性能开销低。Docker从17.03版本之后分为CE(Community Edt
复制链接

扫一扫

专栏目录