Docker简介
开源的应用容器引擎，基于 Go 语言 遵从 Apache2.0 协议开源。
打包应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 上，也可实现虚拟化。
容器完全使用沙箱机制，相互之间没有任何接口,容器性能开销极低。
Docker应用场景
1，Web 应用的自动化打包和发布。
2，自动化测试和持续集成、发布。
3，在服务型环境中部署和调整数据库或其他的后台应用。
4，从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。
Docker 的优点
用于开发，交付和运行应用程序的开放平台。能够将应用程序与基础架构分开，从而可以快速交付软件。可以与管理应用程序相同的方式来管理基础架构。通过利用 Docker 的方法来快速交付，测试和部署代码，可以减少编写代码和在生产环境中运行代码之间的延迟。
1、快速，一致地交付您的应用程序
允许开发人员使用提供的应用程序或服务的本地容器在标准化环境中工作，从而简化开发的生命周期。
非常适合持续集成和持续交付（CI / CD）工作流程
2、响应式部署和扩展
基于容器的平台，允许高度可移植的工作负载。可以在开发人员的本机上，数据中心的物理或虚拟机上，云服务上或混合环境中运行。
可移植性和轻量级的特性，可以轻松地完成动态管理的工作负担，并根据业务需求指示，实时扩展或拆除应用程序和服务。
3、在同一硬件上运行更多工作负载
轻巧快速。为基于虚拟机管理程序的虚拟机提供了可行、经济、高效的替代方案，因此可以利用更多的计算能力来实现业务目标。非常适合于高密度环境以及中小型部署，可以用更少的资源做更多的事情。
Docker 架构
Docker 包括三个基本概念:
镜像（Image）：Docker 镜像（Image），相当于一个 root 文件系统。
linux系统就包含了完整的一套linux最小系统的 root 文件系统。
容器（Container）：镜像（Image）和容器（Container）的关系
像是面向对象程序设计中的类和实例一样，镜像是静态的定义
容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
仓库（Repository）：可看成一个代码控制中心，用来保存镜像。
Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器。
Docker 容器通过 Docker 镜像来创建。
容器与镜像的关系类似于面向对象编程中的对象与类。
概念 说明
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。
Ubuntu Docker 安装
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
使用官方安装脚本自动安装
curl -sSL https://get.daocloud.io/docker | sh
国内 daocloud 一键安装命令
手动安装
卸载旧版本
Docker 的旧版本为 docker，docker.io 或 docker-engine 。如已安装，请卸载：
$ sudo apt-get remove docker docker-engine docker.io containerd runc
当前称为 Docker Engine-Community 软件包 docker-ce
安装 Docker Engine-Community
使用 Docker 仓库进行安装
在新主机上首次安装 Docker Engine-Community 之前，需要设置 Docker 仓库。之后，可从仓库安装和更新 Docker 。
设置仓库
$ sudo apt-get update
更新 apt 包索引
$ sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
安装 apt 依赖包，用于通过HTTPS来获取仓库
$ curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
添加 Docker 的官方 GPG 密钥
$ 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]
# 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 通过搜索指纹的后8个字符，验证您现在是否拥有带有指纹的密钥。
$ sudo add-apt-repository "deb [arch=amd64] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/ $(lsb_release -cs) stable"
设置稳定版仓库
安装 Docker Engine-Community
$ sudo apt-get update
更新 apt 包索引
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
安装最新版本的 Docker Engine-Community 和 containerd ，或安装特定版本
$ apt-cache madison docker-ce
安装特定版本的 Docker Engine-Community，请在仓库中列出可用版本，然后选择一种安装。列出仓库中可用的版本
$ 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/
使用 Shell 脚本进行安装
get.docker.com 和 test.docker.com 提供了脚本，用于快速安装 Docker Engine-Community 的边缘版本和测试版本。源代码在 docker-install 仓库中。 不建议在生产环境中使用这些脚本，使用之前，应了解潜在风险：
1，脚本需要运行 root 或具有 sudo 特权。因此，在运行脚本之前，应仔细检查和审核脚本。
2，这些脚本尝试检测 Linux 发行版和版本，并配置软件包管理系统。此外，脚本不允许自定义任何安装参数。可能导致不支持的配置。
3，这些脚本将安装软件包管理器的所有依赖项和建议，而无需确认。可能会安装大量软件包，具体取决于主机的当前配置。
4，该脚本未提供用于指定要安装哪个版本的 Docker 的选项，而是安装了在 edge 通道中发布的最新版本
5，如果已使用其他机制将 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
卸载 docker
删除安装包
sudo apt-get purge docker-ce
删除镜像、容器、配置文件等内容
sudo rm -rf /var/lib/docker
Windows Docker 安装
Docker 并非一个通用容器工具，依赖于已存在并运行的 Linux 内核环境。
Docker 实质上是在已经运行的 Linux 下制造了一个隔离的文件环境，因此执行的效率几乎等同于所部署的 Linux 主机。
因此，Docker 必须部署在 Linux 内核的系统上。其他系统想部署 Docker 就必须安装一个虚拟 Linux 环境。
在 Windows 上部署 Docker 的方法都是先安装一个虚拟机，并在安装 Linux 系统的的虚拟机中运行 Docker。
Win10 系统
Docker Desktop 是 Docker 在 Windows 10 和 macOS 操作系统上的官方安装方式，属于先在虚拟机中安装 Linux 然后再安装 Docker 的方法。
Docker Desktop 官方下载地址： https://hub.docker.com/editions/community/docker-ce-desktop-windows
此方法仅适用于 Windows 10 操作系统专业版、企业版、教育版和部分家庭版
安装 Hyper-V
Hyper-V 是微软开发的虚拟机，类似于 VMWare 或 VirtualBox，仅适用于 Windows 10。是 Docker Desktop for Windows 所使用的虚拟机。
虚拟机一旦启用，QEMU、VirtualBox 或 VMWare Workstation 15 及以下版本将无法使用！如果必须在电脑上使用其他虚拟机，请不要使用 Hyper-V
开启 Hyper-V
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All
命令启用 Hyper-V ，右键开始菜单以管理员身份运行 PowerShell，执行
安装 Docker Desktop for Windows
https://www.docker.com/get-started
选择Windows进行下载
下载后运行exe执行文件进行安装
安装完成后，Docker 自动启动。通知栏上会出现个小鲸鱼图标，表示 Docker 正在运行。
可在命令行执行 docker version 来查看版本号，
docker run hello-world 来载入测试镜像测试。
如果没启动，可在 Windows 搜索 Docker 来启动
如果启动中遇到因 WSL 2 导致地错误，请安装 WSL 2。
安装后，打开 PowerShell 运行命令检测是否运行成功
docker run hello-world
win7、win8 系统
win7、win8 等需要利用 docker toolbox 来安装，国内使用阿里云的镜像下载
下载地址：http://mirrors.aliyun.com/docker-toolbox/windows/docker-toolbox/
安装比较简单，双击运行，点下一步即可，勾选自己需要的组件
docker toolbox 是一个工具集，它主要包含以下一些内容：
Docker CLI - 客户端，用来运行 docker 引擎创建镜像和容器。
Docker Machine - 可以让你在 Windows 的命令行中运行 docker 引擎命令。
Docker Compose - 用来运行 docker-compose 命令。
Kitematic - 这是 Docker 的 GUI 版本。
Docker QuickStart shell - 这是一个已经配置好Docker的命令行环境。
Oracle VM Virtualbox - 虚拟机。
下载完成后点击安装，安装后，会出现三个图标
点击 Docker QuickStart 图标来启动 Docker Toolbox 终端。
如果系统显示 User Account Control 窗口来运行 VirtualBox 修改你的电脑，选择 Yes。
安装后，打开 PowerShell 运行命令检测是否运行成功
docker run hello-world
MacOS Docker 安装
使用 Homebrew 安装
使用 Homebrew 来安装 Docker
Homebrew 的 Cask 已经支持 Docker for Mac，因此可以很方便的使用 Homebrew Cask 来进行安装
brew install --cask --appdir=/Applications docker
载入 Docker app 后，点击 Next，可能会询问 macOS 登陆密码，输入即可。之后会弹出一个 Docker 运行的提示窗口，状态栏上也有鲸鱼的图标
手动下载安装
下载网址
https://hub.docker.com
对应Mac芯片进行选择下载
下载完成后打开DMG文件，对APP进行拖拽到本机
从应用中找到 Docker 图标并点击运行。可能会询问 macOS 的登陆密码，输入即可。
点击顶部状态栏中的鲸鱼图标会弹出操作菜单
启动终端后，通过命令可以检查安装后的 Docker 版本。
% docker --version
Docker version 20.10.11, build dea9396
镜像加速
网络问题，拉取 Docker 镜像十分缓慢，需要配置加速器解决，使用的是网易的镜像地址：http://hub-mirror.c.163.com。
点击任务栏鲸鱼图标选择Perferences进入界面，选择Resource，选择Proxies，打开选项，添加web server，进行确认并重启即可
通过 docker info 查看是否配置成功
$ docker info
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 的云平台选择对应的镜像加速服务。
之前还有 Docker 官方加速器 https://registry.docker-cn.com ，可多添加几个国内的镜像，如果不能使用的，会切换到可以使用个的镜像来拉取。
Ubuntu14.04、Debian7Wheezy
使用 upstart 版本的系统，编辑 /etc/default/docker 文件，其中的 DOCKER_OPTS 配置加速器地址：
DOCKER_OPTS = "--registry-mirror=http://docker.mirrors.ustc.edu.cn"
重新启动服务:
$ sudo service docker restart
Ubuntu16.04+、Debian8+、CentOS7
使用 systemd 版本的系统，在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在新建文件）
{"registry-mirrors":["http://docker.mirrors.ustc.edu.cn"]}
重启服务
$ sudo systemctl daemon-reload
$ sudo systemctl restart docker
Windows 10
使用 Windows 10 的系统，在系统右下角托盘 Docker 图标内右键菜单选择 Settings，打开配置窗口后左侧导航菜单选择 Daemon。
在 Registrymirrors 一栏中填写加速器地址 https://docker.mirrors.ustc.edu.cn/ ，之后点击 Apply 保存后 Docker 重启并应用配置的镜像地址。
Mac OS
使用 Mac OS 的系统，在任务栏点击 Docker for mac 应用图标-> Perferences-> Docker Engine。在列表中填写加速器地址 https://reg-mirror.qiniu.com 。修改完成之后，点击 Apply&Restart 按钮，Docker 就会重启并应用配置的镜像地址了。
检查加速器是否生效
检查加速器是否生效配置加速器之后，如果拉取镜像仍然十分缓慢，手动检查加速器配置是否生效，在命令行执行 docker info，结果中看到如下内容，说明配置成功
Docker Hello World
Docker 允许在容器内运行应用程序， 使用 docker run 命令在容器内运行应用程序。
输出Hello world
docker run ubuntu /bin/echo 'hello world'
**参数解析**
docker: Docker 的二进制执行文件。
run: 与前面的 docker 组合来运行一个容器。
ubuntu 指定要运行的镜像，Docker 首先从本地主机上查找镜像是否存在，如果不存在，Docker 会从镜像仓库 Docker Hub 下载公共镜像。
/bin/echo "Hello world": 在启动的容器里执行的命令
#Docker 以 ubuntu 镜像创建一个容器，然后在容器里执行 bin/echo "Hello world"，输出结果。
运行交互式的容器
通过 docker 的两个参数 -i -t，让 docker 运行的容器实现"对话"能力
docker run -it ubuntu /bin/bash
**参数解析**
-t: 在新容器内指定一个伪终端或终端。
-i: 允许你对容器内的标准输入 (STDIN) 进行交互。
尝试在容器中运行命令 cat /proc/version和ls分别查看当前系统的版本信息和当前目录下的文件列表
通过 exit 命令或者使用 CTRL+D 来退出容器。
后台模式启动容器
使用以下命令创建一个以进程方式运行的容器
docker run -d ubuntu /bin/sh -c "while true; do echo hello world; sleep 1; done"
输出中，没有看到期望的 “hello world”，而是一串字符
这串字符是容器 ID，对每个容器来说都是唯一的，可通过容器 ID 查看对应的容器
需确认容器正在运行，通过 docker ps 查看
docker ps
**参数解释**
CONTAINER ID: 容器 ID。
IMAGE: 使用的镜像。
COMMAND: 启动容器时运行的命令。
CREATED: 容器的创建时间。
STATUS: 容器状态。
**状态有7种**
created（已创建）
restarting（重启中）
running 或 Up（运行中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）
PORTS: 容器的端口信息和使用的连接类型（tcp\udp）。
NAMES: 自动分配的容器名称。
在宿主机内使用 docker logs 命令，查看容器内的标准输出
docker logs 561c55b1440c
docker logs hardcore_lehmann
停止容器
使用 docker stop 命令停止容器
通过 docker ps 查看，容器已经停止工作
docker stop hardcore_lehmann
#使用容器名字一样可以终止容器运行
Docker 容器使用
Docker 客户端
docker 客户端非常简单 ,可直接输入 docker 命令查看 Docker 客户端所有命令选项
dockre
#查看 Docker 客户端所有命令选项
通过命令 docker command --help 更深入了解指定 Docker 命令使用方法
docker wait --help
#查看 docker wait 指令的具体使用方法
容器使用
获取镜像
如果本地没有 ubuntu 镜像，使用 docker pull 命令载入 ubuntu 镜像
docker pull ubuntu
启动容器
使用 ubuntu 镜像启动一个容器，参数为以命令行模式进入该容器
docker run -it ubuntu /bin/bash
**参数说明**
-i: 交互式操作。
-t: 终端。
ubuntu: ubuntu 镜像。
/bin/bash：放在镜像名后的是命令，交互式 Shell，用的是 /bin/bash。
退出终端，输入 exit
启动已停止运行的容器
docker ps -a
#查看所有的容器命令
使用 docker start 启动一个已停止的容器
docker start eeec43de41c0
后台运行
大部分的场景下，希望 docker 服务在后台运行，通过 -d 指定容器的运行模式。
docker run -itd --name ubuntu-test ubuntu /bin/bash
注：-d 参数默认不进入容器，进入容器需要使用指令 docker exec
停止容器
docker stop <容器 ID>
#停止容器命令
docker restart <容器 ID>
#停止的容器可通过 docker restart 重启
进入容器
使用 -d 参数时，容器启动后会进入后台。不会直接进入容器，可通过命令进入
docker attach
docker exec
推荐使用 docker exec 命令，因为退出容器终端，不会导致容器停止
attach 命令
docker attach 87786c5cba4b
注意： 如果从容器退出，会导致容器的停止
exec 命令
docker exec -it 87786c5cba4b /bin/bash
注意： 如果从容器退出，容器不会停止
更多参数说明请使用 docker exec --help 命令查看
导出和导入容器
导出容器
如果要导出本地容器，使用 docker export 命令
docker export 87786c5cba4b > ubuntu.tar
导出容器 87786c5cba4b 快照到本地文件 ubuntu.tar。
导入容器
使用 docker import 从容器快照文件中导入为镜像
cat docker/ubuntu.tar | docker import - test/ubuntu:v1
#将快照文件 ubuntu.tar 导入到镜像 test/ubuntu:v1
docker images
#查看docker的镜像文件
也可通过指定 URL 或者某个目录来导入
docker import http://example.com/exampleimage.tgz example/imagerepo
删除容器
删除容器使用 docker rm 命令
docker rm -f 64f910e2ac0f
删除 Docker 镜像
docker images
#查看全部镜像
docker rmi a57d7a057031
#根据Image ID进行删除镜像
运行 web 应用
使用 docker 构建一个 web 应用程序
在docker容器中运行一个 Python Flask 应用运行一个web应用
docker pull training/webapp # 载入镜像
docker run -d -P training/webapp python app.py
**参数说明**
-d:让容器在后台运行。
-P:将容器内部使用的网络端口随机映射到我们使用的主机上。
查看 WEB 应用容器
使用 docker ps 查看正在运行的容器
多了端口信息,使用云服务器需要进行配置端口放行，如果系统防火墙IPTABLE进行了配置，也要进行放行。
Docker 开放了 5000 端口（默认 Python Flask 端口）映射到主机端口 49153
通过浏览器访问WEB应用
通过 -p 参数设置端口
docker run -d -p 6000:5000 training/webapp python app.py
容器内部的 5000 端口映射到本地主机的 6000 端口
网络端口的快捷方式
docker ps 命令可以查看容器端口映射，使用 docker port 可以查看指定 （ID 或者名字）容器的某个确定端口映射到宿主机的端口号
创建的 web 应用容器 ID 为 6fba802c8f66 名字为 dreamy_faraday。
使用 docker port 6fba802c8f66 或 docker port dreamy_faraday 查看容器端口的映射情况。
docker port 6fba802c8f66
#通过ID进行查询
docker port dreamy_faraday
#通过名称进行查询
查看 WEB 应用程序日志
docker logs [ID或者名字] 查看容器内部的标准输出
docker logs -f 6fba802c8f66
-f: 让 docker logs 像使用 tail -f 一样来输出容器内部的标准输出。
应用程序使用的是 5000 端口并且能够查看到应用程序的访问日志。
查看WEB应用程序容器的进程
使用 docker top 查看容器内部运行的进程
docker top 6fba802c8f66/name
检查 WEB 应用程序
使用 docker inspect 查看 Docker 的底层信息。
返回一个 JSON 文件记录 Docker 容器的配置和状态信息。
docker inspect 6fba802c8f66/name
停止 WEB 应用容器
docker stop 6fba802c8f66/name
重启WEB应用容器
停止的容器，使用命令 docker start 进行启动
docker start 6fba802c8f66/name
docker ps -l
#查询最后一次创建的容器
正在运行的容器，可以使用 docker restart 命令进行重启
移除WEB应用容器
使用 docker rm 命令删除容器
docker rm -f dreamy_faraday
删除容器时，容器必须是停止状态，否则会报错
Docker 镜像使用
当运行容器时，使用的镜像如果在本地中不存在，docker 就会自动从 docker 镜像仓库中下载，默认从 Docker Hub 公共镜像源下载。
**列出镜像列表**
使用 docker images 来列出本地主机上的镜像
**参数说明**
REPOSITORY： 镜像的仓库源
TAG： 镜像的标签
IMAGE ID： 镜像ID
CREATED： 镜像创建时间
SIZE： 镜像大小
同一仓库源可以有多个 TAG，代表仓库源的不同版本，如 ubuntu 仓库源里，有 15.10、14.04 等多个不同的版本，使用 REPOSITORY:TAG 定义不同的镜像。
因为容量原因，服务器并没多保存很多镜像，但是确实会有相同名字，不同TAG的镜像，假如还有一个ubuntu系统，TAG 16.10 但是我们要选择latest版本进行创建所以应该键入以下命令
docker run -t -i ubuntu:latest /bin/bash
**参数说明**
-i: 交互式操作。
-t: 终端。
ubuntu:latest: 这是指用 ubuntu latest 版本镜像为基础来启动容器。
/bin/bash：放在镜像名后的是命令，交互式 Shell，用的是 /bin/bash。
如果不指定镜像的版本标签，只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像。
获取新的镜像
在本地主机上使用一个不存在的镜像时 Docker 就会自动下载这个镜像。如果预先下载，使用 docker pull 命令进行下载
下载完成后，可直接使用镜像运行容器
查找镜像
从 Docker Hub 网站搜索镜像，Docker Hub 网址为： https://hub.docker.com/
也可以使用 docker search 命令搜索镜像。比如需要一个 apache2 的镜像作 web 服务。通过 docker search 命令搜索 apache2 寻找适合的镜像。
docker search apache2
NAME: 镜像仓库源的名称
DESCRIPTION: 镜像的描述
OFFICIAL: 是否 docker 官方发布
stars: 类似 Github 里面的 star，表示点赞、喜欢的意思。
AUTOMATED: 自动构建。
拉取镜像
随意选择apache2的镜像，使用命令 docker pull 下载镜像
docker pull ascdc/apache2-php7
下载完成，就可以使用镜像
在这里插入代码片
docker run ascdc/apache2-php7
删除镜像
镜像删除使用 docker rmi 命令
docker rmi ascdc/apache2-php7
创建镜像
从 docker 镜像仓库中下载的镜像不能满足需求时，通过以下两种方式对镜像进行更改。
1、从已经创建的容器中更新镜像，并提交这个镜像
2、使用 Dockerfile 指令来创建一个新的镜像
更新镜像
更新镜像之前，需使用镜像来创建一个容器
docker run -it ubuntu /bin/bash
在运行的容器内使用 apt update 命令进行更新。
在完成操作之后，输入 exit 命令来退出这个容器。
此时 ID 为 95beb2680d48 的容器，是按需求更改的容器。通过命令 docker commit 提交容器副本
**参数说明**
-m: 提交的描述信息
-a: 指定镜像作者
95beb2680d48：容器 ID
desitn/ubuntu:v2: 指定创建的目标镜像名
使用 docker images 命令查看新镜像 destin/ubuntu:v2：
使用新镜像 destinubuntu 启动容器
docker run -it destin/ubuntu:v2 /bin/bash
构建镜像
使用命令 docker build ， 从零开始创建一个新镜像。需要创建一个 Dockerfile 文件，其中包含一组指令指示 Docker 如何构建镜像
vim Dockerfile
#写入以下内容
FROM ubuntu:latest
#指定镜像源
RUN /bin/echo 'root:123' |chpasswd
RUN useradd destin
RUN /bin/echo 'destin:123' |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 在镜像内执行命令
标签 功能 用法 说明
FROM 声明系统镜像 FROM <image> [AS <name>]
FROM <image>[:<tag>] [AS <name>]
FROM <image>[@<digest>] [AS <name>]
RUN 运行命令或文件 RUN <command> 创建镜像时运行
RUN ["executable", "param1", "param2"]
CMD 运行命令或文件 CMD ["executable","param1","param2"] 启动镜像时运行
CMD ["param1","param2"]
CMD command param1 param2
LABEL 设置说明性标签 LABEL <key>=<value> <key>=<value> <key>=<value>
MAINTAINER 设置作者 MAINTAINER <name> 弃用，用LABEL maintainer=替代
EXPOSE 暴露端口 EXPOSE <port> [<port>/<protocol>…] 仅起说明作用
ENV 设置环境变量 ENV <key> <value> 创建、启动镜像时均有效
ENV <key>=<value> …
ADD 添加文件 ADD [--chown=<user>:<group>] <src>... <dest>
ADD [--chown=<user>:<group>] ["<src>",... "<dest>"]
COPY 复制文件 VOLUME ["/data"]
COPY [--chown=<user>:<group>] ["<src>",... "<dest>"]
ENTRYPOINT 设置入口点 ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2
VOLUME 挂载卷 VOLUME ["/data"] 容器的文件操作针对挂载卷
USER 设置用户与组 USER <user>[:<group>]
USER <UID>[:<GID>]
WORKDIR 设置工作路径 WORKDIR /path/to/workdir
ARG 设置变量 ARG <name>[=<default value>] 仅创建镜像时有效
ONBUILD 设置触发指令 ONBUILD [INSTRUCTION] 用于构建另一个镜像时触发
STOPSIGNAL 设置停止信号 STOPSIGNAL signal
HEALTHVHECK 健康检查 HEALTHCHECK [OPTIONS] CMD command 检查命令执行状态
HEALTHCHECK NONE
SHELL 覆盖默认shell SHELL ["executable", "parameters"]
使用 Dockerfile 文件，通过 docker build 命令构建镜像
docker build -t ubuntu:latest docker
#文件创建到docker目录下
#使用build 最后的PATH参数必须使用目录，而不能使用文件
**参数说明**
-t ：指定要创建的目标镜像名
. ：Dockerfile 文件所在目录，可指定Dockerfile 的绝对路径
使用docker images 查看创建的镜像已经在列表中存在,镜像ID为29aa91f42e05
docker images
使用新镜像创建容器
id destin
#查看用户权限
新镜像已经包含创建的用户 destin。
设置镜像标签
使用 docker tag 命令，为镜像添加新的标签
docker tag 29aa91f42e05 ubuntu:dev
docker tag 镜像ID，这里是 29aa91f42e05 ,用户名称、镜像源名(repository name)和新的标签名(tag)。
使用 docker images 命令可以看到，ID为29aa91f42e05存在两个标签不同的的镜像。
Docker 容器连接
前面实现了通过网络端口访问运行在 docker 容器内的服务
容器中可以运行一些网络应用，要让外部也可以访问这些应用，通过 -P 或 -p 参数来指定端口映射
网络端口映射
创建一个 python 应用的容器
docker run -d -P training/webapp python app.py
使用 -P 绑定端口号，使用 docker ps 可以看到容器端口 5000 绑定主机端口 49155。
docker ps
也可以使用 -p 标识指定容器端口绑定到主机端口。
两种方式的区别
-P :是容器内部端口随机映射到主机的高端口。
-p : 是容器内部端口绑定到指定的主机端口。
docker run -d -p 5555:5000 training/webapp python app.py
指定容器绑定的网络地址，比如绑定 127.0.0.1
docker run -d -p 127.0.0.1:5556:5000 training/webapp python app.py
这样我们就可以通过访问 127.0.0.1:5556 访问容器的 5000 端口。
默认都是绑定 tcp 端口，如果要绑定 UDP 端口，在端口后面加上 /udp。
docker port #查看端口的绑定情况
docker port hungry_boyd 5000
Docker 容器互联
端口映射并不是唯一把 docker 连接到另一个容器的方法。
docker 有一个连接系统允许将多个容器连接在一起，共享连接信息。
docker 连接会创建一个父子关系，其中父容器可以看到子容器的信息。
容器命名
当创建一个容器时，docker 会自动进行命名。另外，也可以使用 --name 标识来命名容器
docker run -d -P --name destin training/webapp python app.py
新建网络
创建一个新的 Docker 网络
docker network create -d bridge deatin-net
docker network ls
#查看docker网络
**参数说明**
-d：参数指定 Docker 网络类型，有 bridge、overlay。
overlay 网络类型用于 Swarm mode
1、创建网络
docker network create
2、将容器加入到网络
docker network connect
3、 查看网络
docker network ls
4、 断开和移除网络
docker network rm
移除网络之前需要断开所有连接到网络的容器
docker network disconnect
5、 查看网络内部信息
docker network inspect
连接容器
运行一个容器并连接到新建的 destin-net 网络:
docker run -itd --name destin-test --network destin-net ubuntu /bin/bash
打开新的终端，再运行一个容器并加入到 destin-net 网络
docker run -itd --name destin-test2 --network destin-net ubuntu /bin/bash
通过 ping 证明 test 容器和 test2 容器建立了互联关系。
如果 test、test2 容器无 ping 命令，在容器内安装 ping
（可以在一个容器里安装好，提交容器到镜像，以新的镜像重新运行以上俩个容器）
apt update
apt install iputils-ping
destin-test ping destin-test2
destin-test2 ping destin-test
test 容器和 test2 容器建立了互联关系。
如果多个容器之间需要互相连接，推荐使用 Docker Compose
配置 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
手动指定容器的配置
如果只想在指定的容器设置 DNS，则使用以下命令
docker run -it --rm -h destin --dns=114.114.114.114 --dns-search=test.com ubuntu /bin/bash
参数说明：
--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。
Docker 仓库管理
仓库（Repository）是集中存放镜像的地方。以下介绍 Docker Hub。不止 docker hub一个仓库，只是服务商不同，操作一样。
Docker Hub
目前 Docker 官方维护了一个公共仓库 Docker Hub。
大部分需求都可以通过在 Docker Hub 中直接下载镜像实现。
注册
在 https://hub.docker.com 免费注册一个 Docker 账号。
https://hub.docker.com/signup
#注册站点
https://hub.docker.com
#登陆站点
点击蓝色的Sign In
进入站点，输入账号密码 进行登录
https://login.docker.com/u/login
登录和退出
登录需要输入用户名和密码，登录成功后，就可以从 docker hub 上拉取账号下全部镜像。
docker login
#登陆
退出 docker hub
docker logout
拉取镜像
通过 docker search 命令查找官方仓库中的镜像，利用 docker pull 命令下载到本地。
以 apache2 为关键词进行搜索
docker search apache2
使用 docker pull 将 apache2 镜像下载到本地
docker pull ascdc/apache2-php7
推送镜像
用户登录后，通过 docker push 命令将自己的镜像推送到 Docker Hub。
以下命令中的 username 替换为自己懂得多 Docker 账号用户名
docker tag ubuntu username/ubuntu
#创建指定tag的镜像文件
docker image ls
#查看docker镜像
docker push username/ubuntu
#上传镜像
docker search username/ubuntu
#对刚上传的文件镜像进行查找
查找不到上传的镜像，但是可以下载，证明上传成功
Docker Dockerfile
用来构建镜像的文本文件，文本内容包含构建镜像所需的指令和说明
使用 Dockerfile 定制镜像
1、定制一个 nginx 镜像（构建好的镜像内会有一个 /usr/share/nginx/html/index.html 文件）
在一个空目录下，新建名为 Dockerfile 的文件，并添加内容：
FROM nginx
RUN echo '本地构建Nginx镜像' > /usr/share/nginx/html/index.html
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
# 执行会创建 3 层镜像。可简化为：
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
如上，以 && 符号连接命令，执行后，只会创建 1 层镜像。
开始构建镜像
在 Dockerfile 文件目录上一级目录，执行构建动作。
通过目录下的 Dockerfile 构建 nginx:v3（镜像名称:镜像标签）。
注：最后的 . 代表本次执行的上下文路径
docker build -t nginx:v3 dockerfile
# 必须在名称后面接dockerfile文本文件所在的目录路径
docker images
# 查看是否创建成功
上下文路径
docker build -t nginx:v3 dockerfile
docker 构建镜像时想要使用到本机的文件（比如复制），docker build 命令得知路径后，将路径下的所有内容打包。
docker 的运行模式是 C/S。本机是 C，docker 引擎是 S。实际的构建过程是在 docker 引擎下完成的，所以无法用到本机的文件。需要把本机指定目录下的文件一起打包提供给 docker 引擎使用。
如果未说明最后一个参数，那默认上下文路径是 Dockerfile 所在的位置。
注意：上下文路径下不要放无用的文件，因为会一起打包发送给 docker 引擎，如果文件过多会造成过程缓慢
指令详解
COPY
复制指令，从上下文目录中复制文件或者目录到容器里指定路径。
格式：
COPY [--chown=<user>:<group>] <源路径1>... <目标路径>
COPY [--chown=<user>:<group>] ["<源路径1>",... "<目标路径>"]
[--chown=<user>:<group>]：可选参数，用户改变复制到容器内文件的拥有者和属组。
<源路径>：源文件或者源目录，可以是通配符表达式，通配符规则要满足 Go 的 filepath.Match 规则。
例如：
COPY hom* /mydir/
COPY hom?.txt /mydir/
<目标路径>：容器内指定路径，路径不存在，会自动创建。
ADD
和 COPY 的使用类似（同样需求下，推荐使用 COPY）。功能类似
不同之处：
ADD 的优点：执行 <源文件> 为 tar 压缩文件时，压缩格式为 gzip, bzip2 以及 xz 的情况下，会自动复制并解压到 <目标路径>。
ADD 的缺点：不解压前提下，无法复制 tar 压缩文件。令镜像构建缓存失效，从而会令镜像构建变得比较缓慢。是否使用，可根据是否需要自动解压来决定
CMD
类似 RUN 指令，用于运行程序，但运行的时间点不同:
CMD 在docker run 时运行
RUN 在 docker build时运行
作用：为启动的容器指定默认要运行的程序，程序运行结束，容器也结束。CMD 指令指定的程序可被 docker run 命令行参数中指定要运行的程序所覆盖
注意：如果 Dockerfile 中如果存在多个 CMD 指令，仅最后一个生效。
格式：
CMD <shell 命令>
CMD ["<可执行文件或命令>","<param1>","<param2>",...]
CMD ["<param1>","<param2>",...] # 为 ENTRYPOINT 指令指定的程序提供默认参数
推荐第二种格式，执行过程明确。第一种格式在运行的过程中也会自动转换成第二种格式运行，并且默认可执行文件是 sh
ENTRYPOINT
类似于 CMD 指令，但不会被 docker run 的命令行参数指定的指令覆盖，而且这些命令行参数会当作参数送给 ENTRYPOINT 指令指定的程序。
但如果运行 docker run 时使用 --entrypoint 选项，将覆盖 CMD 指令指定的程序。
优点：执行 docker run 时可以指定 ENTRYPOINT 运行所需参数。
注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。
格式：
ENTRYPOINT ["<executeable>","<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
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"
ARG
构建参数，与 ENV 作用一致。作用域不通。ARG 设置的环境变量仅对 Dockerfile 内有效，只有 docker build 过程中有效，构建好的镜像内不存在此环境变量。
构建命令 docker build 中可以用 --build-arg <参数名>=<值> 覆盖。
格式：
ARG <参数名>[=<默认值>]
VOLUME
定义匿名数据卷。启动容器时忘记挂载数据卷，会自动挂载到匿名卷。
作用：
避免重要的数据，因容器重启而丢失，避免容器不断变大。
格式：
VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>
在启动容器 docker run 的时候，可通过 -v 参数修改挂载点。
EXPOSE
仅仅声明端口。
作用：
帮助镜像使用者理解镜像服务的守护端口，方便配置映射。
在运行时使用随机端口映射时， docker run -P 时，会自动随机映射 EXPOSE 的端口。
格式：
EXPOSE <端口1> [<端口2>...]
WORKDIR
指定工作目录。用 WORKDIR 指定的工作目录，会在构建镜像的每一层中都存在。（WORKDIR 指定的工作目录，必须是提前创建好的）。
docker build 构建镜像过程中的，每一个 RUN 命令都是新建的一层。只有通过 WORKDIR 创建的目录才会一直存在。
格式：
WORKDIR <工作目录路径>
USER
指定执行后续命令的用户和用户组，只是切换后续命令执行的用户（用户和用户组必须提前已经存在）。
格式：
USER <用户名>[:<用户组>]
HEALTHCHECK
指定某个程序或指令来监控 docker 容器服务的运行状态。
格式：
HEALTHCHECK [选项] CMD <命令>：设置检查容器健康状况的命令
HEALTHCHECK NONE：如基础镜像有健康检查指令，可屏蔽其健康检查指令
HEALTHCHECK [选项] CMD <命令> : CMD 后面跟的命令使用，可参考 CMD 用法。
ONBUILD
用于延迟构建命令的执行。Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。当新的 Dockerfile 使用之前构建的镜像 FROM test-build ，执行新镜像的 Dockerfile 构建时，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令。
格式：
ONBUILD <其它指令>
LABEL
用来给镜像添加一些元数据（metadata），以键值对形式，语法格式如下：
LABEL <key>=<value> <key>=<value> <key>=<value> ...
比如添加镜像作者：
LABEL org.opencontainers.image.authors="destin"
Docker Compose
Compose 简介
用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，可使用 YML 文件配置应用程序需要的所有服务。然后，使用一个命令，就可从 YML 文件配置中创建并启动所有服务。
Compose 三个步骤：
使用 Dockerfile 定义应用程序环境。
使用 docker-compose.yml 定义构成应用程序服务，这可以在隔离环境中一起运行。
最后，执行 docker-compose up 启动并运行整个应用程序。
docker-compose.yml 的配置案例（配置参数参考下文）：
# yaml 配置实例
version: '3'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
- logvolume01:/var/log
links:
- redis
redis:
image: redis
volumes:
logvolume01: {}
Compose 安装
Linux 可从 Github 上下载二进制包使用，最新发行的版本地址：https://github.com/docker/compose/releases。
运行命令下载 Docker Compose 的当前稳定版本：
$ sudo curl -L "https://github.com/docker/compose/releases/download/v2.2.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
要安装其他版本的 Compose，请替换 v2.2.3。
将可执行权限应用于二进制文件：
$ sudo chmod +x /usr/local/bin/docker-compose
创建软链：
$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
测试是否安装成功：
$ docker-compose --version
注意： 对于 alpine
需要以下依赖包：
py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。
MacOS
Mac 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Mac 用户不需要单独安装 Compose。
windows PC
Windows 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Windows 用户不需要单独安装 Compose。
使用
1、准备
创建一个测试目录：
$ mkdir composetest
$ cd composetest
在测试目录中创建名为 app.py 的文件，并复制粘贴以下内容：
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、创建 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。
3、创建 docker-compose.yml
测试目录中创建名为 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 映像。
4、使用 Compose 命令构建和运行您的应用
在测试目录中，执行命令启动应用程序：
docker-compose up
如想在后台执行该服务可加上 -d 参数：
docker-compose up -d
yml 配置指令参考
version
指定 yml 依从 compose 哪个版本制定。
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：多层构建，可以指定构建哪一层。
cap_add，cap_drop
添加或删除容器拥有的宿主机的内核功能。
cap_add:
- ALL # 开启全部权限
cap_drop:
- SYS_PTRACE # 关闭 ptrace权限
cgroup_parent
为容器指定父 cgroup 组，将继承该组的资源限制。
cgroup_parent: m-executor-abcd
command
覆盖容器启动的默认命令。
command: ["bundle", "exec", "thin", "-p", "3000"]
container_name
指定自定义容器名称，而不是生成默认名称。
container_name: my-web-container
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 完全启动 之后才启动。
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 及更高版本。
devices
指定设备映射列表。
devices:
- "/dev/ttyUSB0:/dev/ttyUSB0"
dns
自定义 DNS 服务器，可单个值或列表的多个值。
dns: 8.8.8.8
dns:
- 8.8.8.8
- 9.9.9.9
dns_search
自定义 DNS 搜索域。可单个值或列表。
dns_search: example.com
dns_search:
- dc1.example.com
- dc2.example.com
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
env_file
从文件添加环境变量。可单个值或列表的多个值。
env_file: .env
也可是列表格式：
env_file:
- ./common.env
- ./apps/web.env
- /opt/secrets.env
environment
添加环境变量。可使用数组或字典、任何布尔值，布尔值需要用引号引起来，以确保 YML 解析器不会将其转换为 True 或 False。
environment:
RACK_ENV: development
SHOW: 'true'
expose
暴露端口，但不映射到宿主机，只被连接的服务访问。
仅指定内部端口为参数：
expose:
- "3000"
- "8000"
extra_hosts
添加主机名映射。类似 docker client --add-host。
extra_hosts:
- "somehost:162.242.195.82"
- "otherhost:50.31.209.229"
以上会在服务的内部容器中 /etc/hosts 创建具有 ip 地址和主机名的映射关系：
172.16.67.11 somehost
192.168.34.11 otherhost
healthcheck
检测 docker 服务是否健康运行。
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
interval: 1m30s # 设置检测间隔
timeout: 10s # 设置检测超时时间
retries: 3 # 设置重试次数
start_period: 40s # 启动后，多少秒开始启动检测程序
image
指定容器运行的镜像。以下格式都可以：
image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # 镜像id
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://1172.16.67.11"
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 ：同一网络上的其他容器可以使用服务名称或此别名来连接到对应容器的服务。
restart
no：默认的重启策略，任何情况下都不会重启容器。
always：容器总是重新启动。
on-failure：容器非正常退出时（退出状态非0），才会重启容器。
unless-stopped：容器退出时总是重启容器，但不考虑在Docker守护进程启动时就已经停止了的容器
restart: "no"
restart: always
restart: on-failure
restart: unless-stopped
**注：swarm 集群模式，请改用 restart_policy。**
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
security_opt
修改容器默认的 schema 标签。
security-opt：
- label:user:USER # 设置容器的用户标签
- label:role:ROLE # 设置容器的角色标签
- label:type:TYPE # 设置容器的安全策略标签
- label:level:LEVEL # 设置容器的安全等级标签
stop_grace_period
指定在容器无法处理 SIGTERM (或任何 stop_signal 的信号)，等待多久后发送 SIGKILL 信号关闭容器。
stop_grace_period: 1s # 等待 1 秒
stop_grace_period: 1m30s # 等待 1 分 30 秒
默认的等待时间是 10 秒。
stop_signal
设置停止容器的替代信号。默认使用 SIGTERM 。
使用 SIGUSR1 替代信号 SIGTERM 来停止容器。
stop_signal: SIGUSR1
sysctls
设置容器中的内核参数，可使用数组或字典格式。
sysctls:
net.core.somaxconn: 1024
net.ipv4.tcp_syncookies: 0
sysctls:
- net.core.somaxconn=1024
- net.ipv4.tcp_syncookies=0
tmpfs
容器内安装临时文件系统。可单个值或列表的多个值。
tmpfs: /run
tmpfs:
- /run
- /tmp
ulimits
覆盖容器默认的 ulimit。
ulimits:
nproc: 65535
nofile:
soft: 20000
hard: 40000
volumes
将主机的数据卷或文件挂载到容器里。
version: "3.7"
services:
db:
image: postgres:latest
volumes:
- "/localhost/postgres.sock:/var/run/postgres/postgres.sock"
- "/localhost/data:/var/lib/postgresql/data"
YAML 简介
YAML 语法和其他高级语言类似，可以简单表达清单、散列表，标量等数据形态。使用空白符号缩进和大量依赖外观的特色，适合表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲（例如：许多电子邮件标题格式和YAML非常接近）。
YAML 的配置文件后缀为 .yml，如：destin.yml
基本语法
大小写敏感
使用缩进表示层级关系
缩进不允许使用tab，只允许空格
缩进的空格数不重要，只要相同层级的元素左对齐即可
'#'表示注释
数据类型
YAML 支持以下数据类型：
对象：键值对的集合，又称映射（mapping）/ 哈希（hashes） / 字典（dictionary）
数组：一组按次序排列的值，又称序列（sequence） / 列表（list）
纯量（scalars）：单个的、不可再分的值
YAML 对象
对象键值对使用冒号结构表示 `key: value`，冒号后面要加一个空格。
也可使用 `key:{key1: value1, key2: value2, ...}。`
还可使用缩进表示层级关系；
key:
child-key: value
child-key2: value2
较复杂的对象格式，可使用问号加一个空格代表一个复杂的 key，配合一个冒号加一个空格代表一个 value：
?
- complexkey1
- complexkey2
:
- complexvalue1
- complexvalue2
对象的属性是一个数组 [complexkey1,complexkey2]，对应的值也是一个数组 [complexvalue1,complexvalue2]
YAML 数组
以 - 开头的行表示构成一个数组：
- A
- B
- C
YAML 支持多维数组，可以使用行内表示：
key: [value1, value2, ...]
数据结构的子成员是一个数组，则可以在该项下面缩进一个空格。
-
- A
- B
- C
相对复杂的例子：
companies:
-
id: 1
name: company1
price: 200W
-
id: 2
name: company2
price: 500W
companies 属性是一个数组，每一个数组元素又是由 id、name、price 三个属性构成。
数组也可使用流式(flow)方式表示：
companies: [{id: 1,name: company1,price: 200W},{id: 2,name: company2,price: 500W}]
复合结构
数组和对象可以构成复合结构，例：
languages:
- Ruby
- Perl
- Python
websites:
YAML: yaml.org
Ruby: ruby-lang.org
Python: python.org
Perl: use.perl.org
转换 json 为：
{
languages: [ 'Ruby', 'Perl', 'Python'],
websites: {
YAML: 'yaml.org',
Ruby: 'ruby-lang.org',
Python: 'python.org',
Perl: 'use.perl.org'
}
}
纯量
纯量是最基本的，不可再分的值，包括：
**字符串，布尔值，整数，浮点数，Null，时间，日期**
纯量的基本使用：
boolean:
- TRUE #true,True都可以
- FALSE #false，False都可以
float:
- 3.14
- 6.3947536e+5 #可以使用科学计数法
int:
- 123
- 0b1010_0101_01·0_1010_1110 #二进制表示
null:
nodeName: 'node'
parent: ~ #~表示null
string:
- 字符
- 'Hello world' #可使用双引号或单引号包裹特殊字符
- new1
new2 #字符串可拆成多行，每行会被转化成一个空格
date:
- 2022-01-11 #日期必须使用ISO 8601格式，yyyy-MM-dd
datetime:
- 2022-01-11T11:11:11+11:00 #时间使用ISO 8601格式，时间和日期之间使用T连接，最后使用+代表时区
引用
& 锚点和 * 别名，可用来引用:
defaults: &defaults
adapter: postgres
host: localhost
development:
database: myapp_development
<<: *defaults
test:
database: myapp_test
<<: *defaults
相当于:
defaults:
adapter: postgres
host: localhost
development:
database: myapp_development
adapter: postgres
host: localhost
test:
database: myapp_test
adapter: postgres
host: localhost
& 用来建立锚点（defaults），<< 表示合并到当前数据，* 用来引用锚点。
另一个例子:
- &showell Steve
- Clark
- Brian
- Oren
- *showell
-
转为 JavaScript :
[ 'Steve', 'Clark', 'Brian', 'Oren', 'Steve' ]
Docker Machine
简介
一种可在虚拟主机上安装 Docker 的工具，并使用 docker-machine 命令管理主机。
Docker Machine 也可集中管理所有的 docker 主机，比如快速的给 100 台服务器安装上 docker。
Docker Machine 管理的虚拟主机可以是机上的，也可以是云上
使用 docker-machine 命令，可以启动，检查，停止和重新启动托管主机，也可升级 Docker 客户端和守护程序，以及配置 Docker 客户端与主机进行通信。
安装
安装 Docker Machine 之前需先安装 Docker。
Docker Machine 可在多种平台上安装使用，包括 Linux 、MacOS 以及 windows。
Linux 安装命令
$ base=https://github.com/docker/machine/releases/download/v0.16.2 &&
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
macOS 安装命令
$ base=https://github.com/docker/machine/releases/download/v0.16.2 &&
curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/usr/local/bin/docker-machine &&
chmod +x /usr/local/bin/docker-machine
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"
查看是否安装成功：
$ docker-machine version
使用
1、列出可用的机器
$ docker-machine ls
2、创建机器
创建一台名为test的机器
docker-machine create --driver virtualbox test
这里报错，现实没有这个virtualbox路径，需要安装
Error with pre-create check: "VBoxManage not found. Make sure VirtualBox is installed and VBoxManage is in the path"
安装virtualbox
存在virtualbox安装包的linux可使用命令直接安装
apt install virtualbox
不存在virtualbox安装包，使用wget从互联网上进行下载
wget https://download.virtualbox.org/virtualbox/6.0.14/virtualbox-6.0_6.0.14-133895~Ubuntu~bionic_amd64.deb
使用dpkg命令安装下载的virtualbox
dpkg -i virtualbox-6.0_6.0.14-133895~Ubuntu~bionic_amd64.deb
装不成功，废物ubuntu
3、查看机器的 ip
$ docker-machine ip test
4、停止机器
$ docker-machine stop test
5、启动机器
$ docker-machine start test
6、进入机器
$ docker-machine ssh test
**docker-machine 命令参数说明**
docker-machine active：查看当前激活状态的 Docker 主机。
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev - virtualbox Running tcp://IP：端口
defalut * digitalocean Running tcp://IP：端口
$ echo $DOCKER_HOST
tcp://IP：端口
$ docker-machine active
defalut
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： 显示帮助信息
Swarm 集群管理
简介
Docker 的集群管理工具。将 Docker 主机池转变为单个虚拟 Docker 主机。提供标准的 Docker API，所有任何已经与 Docker 守护程序通信的工具都可以使用 Swarm 扩展到多个主机。
支持的工具包括但不限于以下各项：
Dokku
Docker Compose
Docker Machine
Jenkins
原理
如图所示，swarm 集群由管理节点（manager）和工作节点（work node）构成。
swarm mananger：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。
work node：即图中的 available node，主要负责运行相应的服务来执行任务（task）。
使用
1、创建 swarm 集群管理节点（manager）
创建 docker 机器：
docker-machine create -d virtualbox swarm-manager
初始化 swarm 集群，进行初始化的这台机器，就是集群的管理节点。
$ docker-machine ssh swarm-manager
$ docker swarm init --advertise-addr IP #这里的 IP 为创建机器时分配的 ip。
需要复制token，增加工作节点会用到
docker swarm join --token SWMTKN-1-
2、创建 swarm 集群工作节点（worker）
进入机器，指定添加至创建的集群，会用到上一步复制的内容。
docker swarm join --token SWMTKN-1-
3、查看集群信息
进入管理节点，执行：docker info 可以查看当前集群的信息。
$ docker info
4、部署服务到集群中
注意：集群管理有关的任何操作，都在管理节点上操作的。
以下例子，在一个工作节点上创建名为 helloworld 的服务，随机指派给一个工作节点：
$ docker service create --replicas 1 --name helloworld alpine ping docker.com
5、查看服务部署情况
查看 helloworld 服务运行在哪个节点上，可看到在 swarm-worker1 节点：
$ docker service ps helloworld
查看 helloworld 部署信息：
$ docker service inspect --pretty helloworld
6、扩展集群服务
将 helloworld 服务扩展到两个节点。
$ docker service scale helloworld=2
7、删除服务
$ docker service rm helloworld
8、滚动升级服务
redis 版本如何滚动升级至更高版本。
创建一个 redis。
$ docker service create --replicas 1 --name redis --update-delay 10s redis:3.0.6
滚动升级 redis 。
$ docker service update --image redis:3.0.7 redis
9、停止某个节点接收新的任务
查看所有的节点：
$ docker node ls
节点 Active, 可以接收新的任务分配。
停止节点 ：
$ docker node update --availability drain nodename
注意： 状态变为 Drain。不会影响到集群的服务，只是节点不再接收新的任务，集群的负载能力有所下降。
可以通过以下命令重新激活节点：
$ docker node update --availability active nodename
Docker 安装 Ubuntu
1、查看可用的 Ubuntu 版本
访问 Ubuntu 镜像库地址： https://hub.docker.com/_/ubuntu?tab=tags&page=1。
可通过 Sort by 查看其他版本的 Ubuntu。默认是最新版本 。
也可在列表中找到其他版本：
2、拉取最新版的 Ubuntu 镜像
$ docker pull ubuntu
$ docker pull ubuntu:latest
3、查看本地镜像
$ docker images
4、运行容器，并且可以通过 exec 命令进入 ubuntu 容器
$ docker run -itd --name ubuntu-test ubuntu
5、安装成功
通过 docker ps 命令查看容器的运行信息
Docker 安装 CentOS
1、查看可用的 CentOS 版本
访问 CentOS 镜像库地址：https://hub.docker.com/_/centos?tab=tags&page=1。
可以通过 Sort by 查看其他版本的 CentOS 。也可在列表中找到其他版本
2、拉取指定版本的 CentOS 镜像
$ docker pull centos:centos7
3、查看本地镜像
查看是否已安装了 centos7：
$ docker images
4、运行容器，并通过 exec 命令进入 CentOS 容器
$ docker run -itd --name centos-test centos:centos7
5、安装成功
通过 docker ps 命令查看容器的运行信息
Docker 安装 Nginx
1、查看可用的 Nginx 版本
访问 Nginx 镜像库地址： https://hub.docker.com/_/nginx?tab=tags。
可以通过 Sort by 查看其他版本的 Nginx。也可在列表中找到其他版本
还可用 docker search nginx 命令查看可用版本：
$ docker search nginx
2、拉取最新版的 Nginx 镜像
拉取官方的最新版本的镜像：
$ docker pull nginx:latest
3、查看本地镜像
查看是否已安装了 nginx：
$ docker images
4、运行容器
使用以下命令来运行 nginx 容器：
$ docker run --name nginx-test -p 8080:80 -d nginx
参数说明：
--name nginx-test：容器名称。
-p 8080:80： 端口进行映射，将本地 8080 端口映射到容器内部的 80 端口。
-d nginx： 设置容器在在后台一直运行。
5、安装成功
通过浏览器可以直接访问 8080 端口的 nginx 服务
Docker 安装 Node.js
1、查看可用的 Node 版本
访问 Node 镜像库地址： https://hub.docker.com/_/node?tab=tags。
可通过 Sort by 查看其他版本，默认最新版本，也可在列表中找到其他版本：
docker search node 命令来查看可用版本：
$ docker search node
2、取最新版的 node 镜像
这里我们拉取官方的最新版本的镜像：
$ docker pull node:latest
3、查看本地镜像
查看是否已安装了 node
$ docker images
4、运行容器
运行 node 容器
$ docker run -itd --name node-test node
5、安装成功
查看容器运行的 node 版本:
$ docker exec -it node-test /bin/bash
node -v
Docker 安装 PHP
安装 PHP 镜像
方法一、docker pull php
查找 Docker Hub 上的 php 镜像 https://hub.docker.com/_/php?tab=tags:
可以通过 Sort by 查看其他版本的 php，默认是最新版本。还可用 docker search php 查看可用版本：
拉取官方的镜像,标签5.6-fpm
$ docker pull php:5.6-fpm
$ docker images
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/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();
?>
Docker 配置 nginx、php-fpm、mysql
运行环境
创建目录
mkdir -p /Users/sui/docker/nginx/conf.d && mkdir /Users/sui/www && cd /Users/sui/docker/nginx/conf.d && sudo touch default.conf
启动 php-fpm
解释执行 php 需要 php-fpm，先让它运行起来：
docker run --name sui-php -d \
-v /Users/sui/www:/var/www/html:ro \
php:7.1-fpm
--name sui-php 是容器的名字。
/Users/sui/www 是本地 php 文件的存储目录，/var/www/html 是容器内 php 文件的存储目录，ro 表示只读。
编辑 nginx 配置文件
配置文件位置：/Users/sui/docker/nginx/conf.d/default.conf。
server {
listen 80;
server_name localhost;
location / {
root /usr/share/nginx/html;
index index.html index.htm;
}
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 /var/www/html/$fastcgi_script_name;
include fastcgi_params;
}
}
说明：
php:9000 表示 php-fpm 服务的访问路径，下文还会提及。
/var/www/html 是 sui-php 中 php 文件的存储路径，经 docker 映射，变成本地路径 /Users/sui/www（可以再看一眼 php-fpm 启动命令
启动 nginx:
docker run --name sui-nginx -p 80:80 -d \
-v /Users/sui/www:/usr/share/nginx/html:ro \
-v /Users/sui/docker/nginx/conf.d:/etc/nginx/conf.d:ro \
--link sui-php:php \
nginx
-p 80:80 用于添加端口映射，把 sui-nginx 中的 80 端口暴露出来。
/Users/sui/www 是本地 html 文件的存储目录，/usr/share/nginx/html 是容器内 html 文件的存储目录。
/Users/sui/docker/nginx/conf.d 是本地 nginx 配置文件的存储目录，/etc/nginx/conf.d 是容器内 nginx 配置文件的存储目录。
--link sui-php:php 把 sui-php 的网络并入 sui-nginx，并通过修改 sui-nginx 的 /etc/hosts，把域名 php 映射成 127.0.0.1，让 nginx 通过 php:9000 访问 php-fpm。
mysql 和 phpmyadmin
mysql 服务器
sudo mkdir -p /Users/sui/docker/mysql/data /Users/sui/docker/mysql/logs /Users/sui/docker/mysql/conf
data 目录将映射为 mysql 容器配置的数据文件存放路径
logs 目录将映射为 mysql 容器的日志目录
conf 目录里的配置文件将映射为 mysql 容器的配置文件
docker run -p 3307:3306 --name sui-mysql -v /Users/sui/docker/mysql/conf:/etc/mysql -v /Users/sui/docker/mysql/logs:/logs -v /Users/sui/docker/mysql/data:/mysql_data -e MYSQL_ROOT_PASSWORD=123456 -d --link sui-php mysql
进入mysql客户端:
docker run -it --link sui-mysql:mysql --rm mysql sh -c 'exec mysql -h"$MYSQL_PORT_3306_TCP_ADDR" -P"$MYSQL_PORT_3306_TCP_PORT" -uroot -p"$MYSQL_ENV_MYSQL_ROOT_PASSWORD"'
注意：本地 3306 端口有 mysql, 所以用3307端口。
phpmyadmin
docker run --name sui-myadmin -d --link sui-mysql:db -p 8080:80 phpmyadmin/phpmyadmin
Docker 安装 MySQL
1、查看可用的 MySQL 版本
访问 MySQL 镜像库地址：https://hub.docker.com/_/mysql?tab=tags 。
可通过 Sort by 查看其他版本的 MySQL，默认是最新版本也可在列表中找到其他版本：
可用 docker search mysql 查看可用版本
$ docker search mysql
2、拉取 MySQL 镜像
拉取官方的最新版本的镜像
$ docker pull mysql:latest
3、查看本地镜像来
查看是否已安装了 mysql
$ docker images
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 用户的密码。
5、安装成功
通过 docker ps 命令查看是否安装成功：
本机可以通过 root 和密码 123456 访问 MySQL 服务。
MySQL(5.7.19)的docker镜像在创建时映射的配置文件目录不同
官方原文：
The MySQL startup configuration is specified in the file /etc/mysql/my.cnf, and that file in turn includes any files found in the /etc/mysql/conf.d directory that end with .cnf. Settings in files in this directory will augment and/or override settings in /etc/mysql/my.cnf. If you want to use a customized MySQL configuration, you can create your alternative configuration file in a directory on the host machine and then mount that directory location as /etc/mysql/conf.d inside the mysql container.
大概意思是说：
MySQL(5.7.19)的默认配置文件是 /etc/mysql/my.cnf 文件。如果想要自定义配置，建议向 /etc/mysql/conf.d 目录中创建 .cnf 文件。新建的文件可以任意起名，只要保证后缀名是 cnf 即可。新建的文件中的配置项可以覆盖 /etc/mysql/my.cnf 中的配置项。
具体操作：
首先需要创建将要映射到容器中的目录以及.cnf文件，然后再创建容器
# pwd
/opt
# mkdir -p docker_v/mysql/conf
# cd docker_v/mysql/conf
# touch my.cnf
# docker run -p 3306:3306 --name mysql -v /opt/docker_v/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 -d imageID
命令说明：
-p 3306:3306：将容器的3306端口映射到主机的3306端口
-v /opt/docker_v/mysql/conf:/etc/mysql/conf.d：将主机/opt/docker_v/mysql/conf目录挂载到容器的/etc/mysql/conf.d
-e MYSQL_ROOT_PASSWORD=123456：初始化root用户的密码
-d: 后台运行容器，并返回容器ID
imageID: mysql镜像ID
查看容器运行情况
# docker ps
docker 安装 mysql 8 版本
docker 中下载 mysql
docker pull mysql
#启动
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123! -d mysql
#进入容器
docker exec -it mysql bash
#登录mysql
mysql -u root -p
ALTER USER 'root'@'localhost' IDENTIFIED BY '123!';
#添加远程登录用户
CREATE USER 'name'@'%' IDENTIFIED WITH mysql_native_password BY '123!';
GRANT ALL PRIVILEGES ON *.* TO 'name'@'%';
Docker 安装 Tomcat
方法一、docker pull tomcat
查找 Docker Hub 上的 Tomcat 镜像https://hub.docker.com/_/tomcat?tab=tags
可以通过 Sort by 查看其他版本的 tomcat，默认最新版本 可以使用 docker search tomcat 命令查看可用版本：
docker search tomcat
拉取官方的镜像：
$ docker pull tomcat
下载完成，可以在本地镜像列表里查到 REPOSITORY 为 tomcat 的镜像。
$ docker images|grep tomcat
方法二、通过 Dockerfile 构建
创建Dockerfile
创建目录tomcat,用于存放后面的相关东西。
$ 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 创建一个镜像，替换名字：
$ docker build -t tomcat
创建完成后，我们可以在本地的镜像列表里查找到刚刚创建的镜像：
$ docker images|grep tomcat
使用 tomcat 镜像，运行容器
$ docker run --name tomcat-test -p 8081:8080 -v $PWD/test:/usr/local/tomcat/webapps/test -d tomcat
命令说明：
-p 8080:8080：将主机的 8080 端口映射到容器的 8080 端口。
-v $PWD/test:/usr/local/tomcat/webapps/test：将主机中当前目录下的 test 挂载到容器的 /test。
查看容器启动情况
$ docker ps
通过浏览器访问
Docker 安装 Python
方法一、docker pull python:3.5
查找 Docker Hub 上的 Python 镜像https://hub.docker.com/_/python?tab=tags
可以通过 Sort by 查看其他版本的 python，默认是最新版本，可以用 docker search python 查看可用版本：
$ docker search python
$ docker pull python
下载完成，在本地镜像列表里查到 REPOSITORY 为python
$ docker images python
方法二、通过 Dockerfile 构建
创建 Dockerfile
创建目录 python，用于存放后面的相关东西。
$ mkdir -p ~/python ~/python/apps
apps 目录将映射为 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 创建一个镜像，替换名字：
docker build -t python
创建完成后，在本地的镜像列表里查找到刚刚创建的镜像：
$ docker images python
使用 python 镜像，在 ~/python/apps 目录下创建一个 helloworld.py 文件，代码如下：
#!/usr/bin/python
print("Hello, World!");
运行容器
$ docker run -v $PWD/apps:/usr/src/apps -w /usr/src/apps python 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 文件。
Docker 安装 Redis
1、查看可用的 Redis 版本
访问 Redis 镜像库地址： https://hub.docker.com/_/redis?tab=tags。
可以通过 Sort by 查看其他版本的 Redis，默认最新版本，也可在列表中找到其他版本：
可用 docker search redis 命令查看可用版本：
$ docker search redis
2、取最新版的 Redis 镜像
拉取官方的最新版本的镜像：
$ docker pull redis
3、查看本地镜像
查看是否已安装了 redis：
$ docker images
4、运行容器
安装完成后，运行 redis 容器：
$ docker run -itd --name redis-test -p 6379:6379 redis
参数说明：
-p 6379:6379：映射容器服务的 6379 端口到宿主机的 6379 端口。外部可以直接通过宿主机ip:6379 访问到 Redis 的服务。
5、安装成功
docker ps 查看容器的运行信息
redis-cli 连接测试使用 redis 服务。
$ docker exec -it redis-test /bin/bash
Docker 安装 MongoDB
1、查看可用的 MongoDB 版本
访问 MongoDB 镜像库地址： https://hub.docker.com/_/mongo?tab=tags&page=1。
可以通过 Sort by 查看其他版本的 MongoDB，默认是最新版本，可以在下拉列表中找到其他版本：
docker search mongo 查看可用版本：
$ docker search mongo
2、取最新版的 MongoDB 镜像
拉取官方的最新版本的镜像
$ docker pull mongo
3、查看本地镜像
查看是否已安装了 mongo：
$ docker images
4、运行容器
使用以下命令来运行 mongo 容器：
$ docker run -itd --name mongo -p 27017:27017 mongo --auth
参数说明：
-p 27017:27017 ：映射容器服务的 27017 端口到宿主机的 27017 端口。外部可以直接通过 宿主机 ip:27017 访问到 mongo 的服务。
--auth：需要密码才能访问容器服务。
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')
Docker 安装 Apache
方法一、docker pull httpd
查找 Docker Hub 上的 httpd 镜像https://hub.docker.com/_/httpd?tab=tags:
可以通过 Sort by 查看其他版本的 httpd，默认是最新版本，可用 docker search httpd 查看可用版本：
$ docker search httpd
拉取官方的镜像
$ docker pull httpd
下载完成后，可在本地镜像列表里查到REPOSITORY为httpd的镜像。
$ docker images httpd
```
## 方法二、通过 Dockerfile 构建
创建 Dockerfile
创建目录apache,用于存放后面的相关东西。
```bash
$ 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 文件可执行权限。
$ chmod +x httpd-foreground
通过 Dockerfile 创建一个镜像，替换名字。
$ docker build -t httpd
创建完成后，我们可以在本地的镜像列表里查找到刚刚创建的镜像。
$ docker images httpd
使用 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 端口映射到主机的 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/。
查看容器启动情况：
$ docker ps
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（注册后使用）
扫一扫
459
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
