如果您想了解Docker三剑客之DockerMachine和docker三剑客介绍的知识，那么本篇文章将是您的不二之选。我们将深入剖析Docker三剑客之DockerMachine的各个方面，并为您解
如果您想了解Docker三剑客之Docker Machine和docker三剑客介绍的知识，那么本篇文章将是您的不二之选。我们将深入剖析Docker三剑客之Docker Machine的各个方面，并为您解答docker三剑客介绍的疑在这篇文章中，我们将为您介绍Docker三剑客之Docker Machine的相关知识，同时也会详细的解释docker三剑客介绍的运用方法，并给出实际的案例分析，希望能帮助到您！
本文目录一览：- Docker三剑客之Docker Machine（docker三剑客介绍）
- CentOS 下 Docker 与.netcore (三）之 三剑客之一 Docker-Compose
- CentOS 下 Docker 与.netcore (五）之 三剑客之一 Docker-swarm 集群
- Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock
- docker 三剑客 docker-compose、docker-machine、swarm
Docker三剑客之Docker Machine（docker三剑客介绍）
一、什么是Docker Machine
Docker Machine 是Docker官方编排项目之一，使用go语言编写的，使用不同引擎在多种平台上快速的安装Docker环境，开源地址:https://github.com/docker/machine。
Docker Machine 是一个工具，它允许你在虚拟宿主机上安装Docker，并使用docker-machine命令管理这个宿主机，可以使用Docker Machine在本地的MAC或者windows box、公司网络，数据中心或者AWS这样的云提供商上创建docker。
使用docker-machine命令，可以启动、审查、停止、重启托管的docker 也可以升级Docker客户端和守护程序并配置docker客户端和宿主机通信。
Docker Machine 也可以集中管理所以得docker主机。
二、为什么要使用Docker Machine
Docker Machine 使你能够在各种 Linux 上配置多个远程 Docker 宿主机。
此外，Machine 允许你在较早的 Mac 或 Windows 系统上运行 Docker，如上一主题所述。
Docker Machine 有这两个广泛的用例。
- 我有一个较旧的桌面系统，并希望在 Mac 或 Windows 上运行 Docker
如果你主要在不符合新的 Docker for Mac 和 Docker for Windows 应用程序的旧 Mac 或 Windows 笔记本电脑或台式机上工作，则需要 Docker Machine 来在本地“运行Docker”（即Docker Engine）。在 Mac 或 Windows box 中使用 Docker Toolbox 安装程序安装 Docker Machine 将为 Docker Engine 配置一个本地的虚拟机，使你能够连接它、并运行 docker 命令。
- 我想在远程系统上配置 Docker 宿主机
Docker Engine Linux 系统上原生地运行。如果你有一个 Linux 作为你的主系统，并且想要运行 docker 命令，所有你需要做的就是下载并安装 Docker Engine 。然而，如果你想要在网络上、云中甚至本地配置多个 Docker 宿主机有一个有效的方式，你需要 Docker Machine。
无论你的主系统是 Mac、Windows 还是 Linux，你都可以在其上安装 Docker Machine，并使用 docker-machine 命令来配置和管理大量的 Docker 宿主机。它会自动创建宿主机、在其上安装 Docker Engine 、然后配置 docker 客户端。每个被管理的宿主机（“machine”）是 Docker 宿主机和配置好的客户端的结合。
三、Docker和Docker Machine之间的区别
当人们说“Docker”时，他们通常是指 Docker Engine，它是一个客户端 - 服务器应用程序，由 Docker 守护进程、一个REST API指定与守护进程交互的接口、和一个命令行接口（CLI）与守护进程通信（通过封装REST API）。Docker Engine 从 CLI 中接受docker 命令，例如 docker run <image>、docker ps 来列出正在运行的容器、docker images 来列出镜像，等等。
Docker Machine 是一个用于配置和管理你的宿主机（上面具有 Docker Engine 的主机）的工具。通常，你在你的本地系统上安装 Docker Machine。Docker Machine有自己的命令行客户端 docker-machine 和 Docker Engine 客户端 docker。你可以使用 Machine 在一个或多个虚拟系统上安装 Docker Engine。
这些虚拟系统可以是本地的（就像你在 Mac 或 Windows 上使用 Machine 在 VirtualBox 中安装和运行 Docker Engine 一样）或远程的（就像你使用 Machine 在云提供商上 provision Dockerized 宿主机一样）。Dockerized 宿主机本身可以认为是，且有时就称为，被管理的“machines”。
四、安装
Docker Mechine 可以在多种平台上安装使用，包括Linux 、MacOS已经windows
Docker Mechine 安装非常的简单：GitHub地址:https://github.com/docker/machine/releases/ 里面有安装教程(在写这篇文章的时候最新版本是v0.15.0)
安装 Docker Mechine
[root@operation ~]# curl -L https://github.com/docker/machine/releases/download/v0.15.0/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 617 0 617 0 0 462 0 --:--:-- 0:00:01 --:--:-- 463
100 26.8M 100 26.8M 0 0 1000k 0 0:00:27 0:00:27 --:--:-- 1373k
[root@operation ~]# chmod +x /tmp/docker-machine
[root@operation ~]# cp /tmp/docker-machine /usr/local/bin/docker-machine
# 查看版本确认是否安装成功
[root@operation ~]# docker-machine -v
docker-machine version 0.15.0, build b48dc28d
# 安装自动补全功能
[root@operation ~]# yum -y install bash-completion
[root@operation ~]# scripts=( docker-machine-prompt.bash docker-machine-wrapper.bash docker-machine.bash ); for i in "${scripts[@]}"; do wget https://raw.githubusercontent.com/docker/machine/v0.15.0/contrib/completion/bash/${i} -P /etc/bash_completion.d; done
# 添加以下
[root@operation ~]# cat ~/.bashrc
# .bashrc
# User specific aliases and functions
alias rm=''rm -i''
alias cp=''cp -i''
alias mv=''mv -i''
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
source /etc/bash_completion.d/docker-machine-wrapper.bash
source /etc/bash_completion.d/docker-machine-prompt.bash
source /etc/bash_completion.d/docker-machine.bash
PS1=''[\u@\h \W$(__docker_machine_ps1)]\$ ''
# 使之生效
[root@operation ~]# source ~/.bashrc到此位置docker-machine就安装完成了！
五、参数
支持命令
支持的平台及驱动引擎
# 平台
1.常规Linux操作系统；
2.虚拟化平台-VirtualBox，VMware，Hyper-V
3.Openstack
4.公有云-Amazon Web Services，Microsoft Azure，Google Compute Engine，Digital Ocean等
Docker Machine为这些环境起了一个统一的名字：provider
对于特定的某个provider，Docker Machine使用相应的driver安装配置docker host
# 驱动引擎
amazonec2
azure
digitalocean
exoscale
generic
google
hyperv
none
openstack
rackspace
softlayer
virtualbox
vmwarevcloudair
vmwarefusion
vmwarevsphere
# 指定方式
使用参数 -d 或者 --driver 驱动引擎名称说白了都是虚拟化平台和云平台的驱动文件
六、使用
通过Docker Machine 创建docker(我用了两台机器)
- 192.168.31.43 安装docker machine的机器 主机名：operation
- 192.168.31.188 被管理的机器 主机名：client1
创建步骤：
1. 配置主机间的SSH免密(在192.168.31.43上面创建)
# 生成keys并配置可以免密登录主机(这个是必须要做的)
[root@operation ~]# ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Created directory ''/root/.ssh''.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:0Fq7VlowSsDqSStOn4veIoTxFbW2RB059qXMSzLblKg root@operation
The key''s randomart image is:
+---[RSA 2048]----+
| ...o..o |
| oo o= . |
| . .*.=* + |
|. o .+ *++O |
|.= + +.SBo. |
|oo= E .=o |
|+.. . + |
|.ooo . |
|oo.o. |
+----[SHA256]-----+
# 将keys拷贝到client1上去
[root@operation ~]# ssh-copy-id root@192.168.31.188
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
The authenticity of host ''192.168.31.188 (192.168.31.188)'' can''t be established.
ECDSA key fingerprint is SHA256:6MKhx743bCMD3Ay+ELNpKnq1+3/wltcrPhbuyEclZj8.
ECDSA key fingerprint is MD5:e8:6d:14:7e:41:da:96:4b:2c:92:f8:61:cc:f4:7b:14.
Are you sure you want to continue connecting (yes/no)? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
root@192.168.31.188''s password:
Number of key(s) added: 1
Now try logging into the machine, with: "ssh ''root@192.168.31.188''"
and check to make sure that only the key(s) you wanted were added.
# 测试是否可以免密登录
[root@operation ~]# ssh root@192.168.31.188
Last login: Fri Oct 12 15:27:45 2018 from 192.168.31.104
[root@client1 ~]# exit2. 使用docker machine创建docker host
# 使用docker machine 创建
# 对于docker machine来将，术语Machine就是运行docker daemon的主机，创建machine就是在host上安装docker
# 执行docker-macine ls查看当前的machine
[root@operation ~]# docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
# 当前还没有一个machine，接下来我们创建第一个machine：docker188-192.168.31.188
[root@operation ~]# docker-machine create --driver generic --generic-ip-address=192.168.31.188 docker188
Running pre-create checks...
Creating machine...
(docker188) No SSH key specified. Assuming an existing key at the default location.
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with centos...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env docker188
注意：这里会出现Error creating machine: Error running provisioning: error installing docker: 这样的错误 原因就是因为网络的原因，没有安装docker
# 创建成功执行ls查看
[root@operation ~]# docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
docker188 - generic Running tcp://192.168.31.188:2376 v18.06.1-ce
# 登录到client查看配置项
[root@operation ~]# ssh root@192.168.31.188
Last login: Fri Oct 12 16:19:10 2018 from 192.168.31.43
[root@docker188 ~]# cat /etc/systemd/system/docker.service.d/10-machine.conf
[Service]
ExecStart=
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2376 -H unix:///var/run/docker.sock --storage-driver devicemapper --tlsverify --tlscacert /etc/docker/ca.pem --tlscert /etc/docker/server.pem --tlskey /etc/docker/server-key.pem --label provider=generic
Environment=
注：-H tcp://0.0.0.0:2376 使docker daemon接受远程连接
--tls*对远程连接启用安全认证和加密
注：大家可能会发现这里的主机名变成了docker188 原因就是docker-machine创建的时候会把主机名也一起修改
# 查看docker188的环境变量
[root@operation ~]# docker-machine env docker188
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.31.188:2376"
export DOCKER_CERT_PATH="/root/.docker/machine/machines/docker188"
export DOCKER_MACHINE_NAME="docker188"
# Run this command to configure your shell:
# eval $(docker-machine env docker188)
# 根据提示执行
[root@operation ~]# eval $(docker-machine env docker188)
[root@operation ~ [docker188]]#
可以看到，命令提示符变成了docker188，其原因是我们之前在/root/.bashrc里面配置了 PS1=''[\u@\h \W$(__docker_machine_ps1)]\$ ''，用于显示当前的docker host
注：如果我们输入eval $(docker-machine env docker1)没有显示出docker188的命令提示符，我们可以重新输入一遍 PS1=''[\u@\h \W$(__docker_machine_ps1)]\$ ''
在此状态下执行的docker命令其效果都相当于在docker188上执行
[root@operation ~ [docker188]]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@operation ~ [docker188]]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE3. 其他命令操作
# 其他命令
# create 命令
选项包括：
·--driver，-d"none" 指定驱动类型；
·--engine-install-url"https://get.docker.com" 配置Dokcer主机时候的安装URL；
·--engine-opt option 以键值对格式指定所创建Docker引擎的参数；
·--engine-insecure-registry option 以键值对格式指定所创建Docker引擎允许访问的不支持认证的注册仓库服务；
·--engine-registry-mirror option 指定使用注册仓库镜像；
·--engine-label option 为所创建的Docker引擎添加标签；
·--engine-storage-driver 存储后端驱动类型；
·--engine-env option 指定环境变量；
·--swarm 指定使用Swarm；
·--swarm-image"swarm：latest" 使用Swarm时候采用的镜像；
·--swarm-master 配置机器作为Swarm集群的master节点；
·--swarm-discovery Swarm集群的服务发现机制参数；
·--swarm-strategy"spread" Swarm默认调度策略；
·--swarm-opt option 任意传递给Swarm的参数；
·--swarm-host"tcp://0.0.0.0：3376" 指定地址将监听 Swarm master节点请求；
·--swarm-addr 从指定地址发送广播加入Swarm集群服务。
实例：
docker-machine create -d virtualbox \
--engine-storage-driver overlay \
--engine-label name=testmachine \
--engine-label year=2018 \
--engine-opt dns=8.8.8.8 \
--engine-env HTTP_PROXY=http://proxy.com:3128 \
--engine-insecure-registry registry.private.com \
mydockermachine
# active命令
[root@operation ~]# docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
docker188 - generic Running tcp://192.168.31.188:2376 v18.06.1-ce
# 这里的状态是没有被激活
[root@operation ~]# docker-machine env docker188
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.31.188:2376" # 激活主机
export DOCKER_CERT_PATH="/root/.docker/machine/machines/docker188"
export DOCKER_MACHINE_NAME="docker188"
# Run this command to configure your shell:
# eval $(docker-machine env docker188)
[root@operation ~]# export DOCKER_HOST="tcp://192.168.31.188:2376"
[root@operation ~]# docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
docker188 * generic Running tcp://192.168.31.188:2376 v18.06.1-ce
[root@operation ~]# docker-machine active
docker188
# config命令
[root@operation ~]# docker-machine config docker188
--tlsverify
--tlscacert="/root/.docker/machine/machines/docker188/ca.pem"
--tlscert="/root/.docker/machine/machines/docker188/cert.pem"
--tlskey="/root/.docker/machine/machines/docker188/key.pem"
-H=tcp://192.168.31.188:2376
# inspect命令
[root@operation ~]# docker-machine inspect docker188
{
"ConfigVersion": 3,
"Driver": {
"IPAddress": "192.168.31.188",
"MachineName": "docker188",
"SSHUser": "root",
"SSHPort": 22,
"SSHKeyPath": "",
"StorePath": "/root/.docker/machine",
"SwarmMaster": false,
"SwarmHost": "",
"SwarmDiscovery": "",
"EnginePort": 2376,
"SSHKey": ""
},
"DriverName": "generic",
"HostOptions": {
"Driver": "",
"Memory": 0,
"Disk": 0,
"EngineOptions": {
"ArbitraryFlags": [],
"Dns": null,
"GraphDir": "",
"Env": [],
"Ipv6": false,
"InsecureRegistry": [],
"Labels": [],
"LogLevel": "",
"StorageDriver": "",
"SelinuxEnabled": false,
"TlsVerify": true,
"RegistryMirror": [],
"InstallURL": "https://get.docker.com"
},
"SwarmOptions": {
"IsSwarm": false,
"Address": "",
"Discovery": "",
"Agent": false,
"Master": false,
"Host": "tcp://0.0.0.0:3376",
"Image": "swarm:latest",
"Strategy": "spread",
"Heartbeat": 0,
"Overcommit": 0,
"ArbitraryFlags": [],
"ArbitraryJoinFlags": [],
"Env": null,
"IsExperimental": false
},
"AuthOptions": {
"CertDir": "/root/.docker/machine/certs",
"CaCertPath": "/root/.docker/machine/certs/ca.pem",
"CaPrivateKeyPath": "/root/.docker/machine/certs/ca-key.pem",
"CaCertRemotePath": "",
"ServerCertPath": "/root/.docker/machine/machines/docker188/server.pem",
"ServerKeyPath": "/root/.docker/machine/machines/docker188/server-key.pem",
"ClientKeyPath": "/root/.docker/machine/certs/key.pem",
"ServerCertRemotePath": "",
"ServerKeyRemotePath": "",
"ClientCertPath": "/root/.docker/machine/certs/cert.pem",
"ServerCertSANs": [],
"StorePath": "/root/.docker/machine/machines/docker188"
}
},
"Name": "docker188"
}
# ssh命令
[root@operation ~]# docker-machine ssh docker188 docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
alpine latest 196d12cf6ab1 4 weeks ago 4.41MB
[root@operation ~]# docker-machine ssh docker188
Last login: Fri Oct 12 16:36:49 2018 from 192.168.31.43
[root@docker188 ~]#
# url命令
[root@operation ~]# docker-machine url docker188
tcp://192.168.31.188:2376
# status命令
[root@operation ~]# docker-machine status docker188
Running
# version命令
[root@operation ~]# docker-machine version docker188
18.06.1-ce注：还有一些命令就不一一列出了，可以查看上面的参数命令表，具体命令的使用方法可以通过--help查看
注：Machine安装docker环境中会因网络或其他情况造成安装失败，使用中发现，这种安装失败频率很高，感觉没有使用的价值，说白了，一个公司操作系统一般不会超过两个发行版，写个脚本一键安装也许会更方便！
七、总结
Docker Machine 最主要有两个作用：
- 使用 Docker Machine 方便在不同的环境中使用 Docker ，比如：Win/Mac
- 使用 Docker Machine 方便在云环境下批量部署 Docker环境，比如：私有云，公有云批量安装Docker环境
八、参考链接
官方地址：https://docs.docker.com/machine/
官方驱动详细使用方法：https://docs.docker.com/machine/drivers/
参考文档：https://www.cnblogs.com/lkun/p/7781157.html
CentOS 下 Docker 与.netcore (三）之 三剑客之一 Docker-Compose
CentOS 下 Docker 与.netcore (一) 之 安装
CentOS 下 Docker 与.netcore (二) 之 Dockerfile
CentOS 下 Docker 与.netcore (三）之 三剑客之一 Docker-Compose
CentOS 下 Docker 与.netcore (四）之 三剑客之一 Docker-machine+jenkins 简单自动化部署
CentOS 下 Docker 与.netcore (五）之 三剑客之一 Docker-swarm 集群
1. 什么是 Docker-Compose
上一章我们讲了通过 Dockerfile 创建镜像，这在一个小项目中是没问题的，但如果在一个包含多个项目的情况下，我们每次部署都需要执行多次创建镜像与运行容器的命令，这样就比较麻烦，为了解决这种情况，Docker-Compose 出现了。Docker-Compose 主要就是为了解决在一台服务器创建镜像与运行容器复杂的问题，有了 Docker-Compose 我们就可以通过一条命令，生成多镜像与运行容器。
2.Docker-Compose 安装
sudo curl -L "https://github.com/docker/compose/releases/download/1.23.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose查看安装是否成功
3. 创建两个.netcore 项目，不启用 https
ServerProvider 项目
新增 Dockerfile
FROM microsoft/dotnet:2.1-aspnetcore-runtime
MAINTAINER yishi.chen
LABEL description="this is a serverprovider website"
LABEL version="1.0"
ARG serverport
WORKDIR /app
COPY bin/Release/netcoreapp2.1/publish/ .
EXPOSE $serverport
ENTRYPOINT ["dotnet","ServerProvider.dll"]Program.cs 改动
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseUrls($"http://*:{Environment.GetEnvironmentVariable("serverport")}")
.UseStartup<Startup>();ValuesController.cs 改动
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
namespace ServerProvider.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
// GET api/values
[HttpGet]
public ActionResult<IEnumerable<string>> Get()
{
return new string[] { "this is serverprovider''s result" };
}
}
}ServerConsumer 项目
新增 Dockerfile
FROM microsoft/dotnet:2.1-aspnetcore-runtime
MAINTAINER yishi.chen
LABEL description="this is a serverconsumer website"
LABEL version="1.0"
ARG consumerport
WORKDIR /app
COPY bin/Release/netcoreapp2.1/publish/ .
EXPOSE $consumerport
ENTRYPOINT ["dotnet","ServerComsumer.dll"]Program.cs 改动
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseUrls($"http://*:{Environment.GetEnvironmentVariable("consumerport")}")
.UseStartup<Startup>();ValueController.cs 改动
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
namespace ServerComsumer.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
// GET api/values
[HttpGet]
public ActionResult<IEnumerable<string>> Get()
{
return new string[] { "value1", "value2" };
}
// GET api/values/5
[HttpGet("{id}")]
public async Task<ActionResult<string>> Get(int id)
{
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
return await httpClient.GetAsync(Environment.GetEnvironmentVariable("serverurl")).Result.Content.ReadAsStringAsync();
}
}
}新建 docker-compose.yml 编排文件
内容如下（docker-compose 的配置请见 https://www.cnblogs.com/chenyishi/p/9965479.html）：
version: ''3''
services:
s_provider:
build:
context: ./ServerProvider/
dockerfile: Dockerfile
args:
serverport: 1000
ports:
- "1000:1000"
environment:
serverport: 1000
container_name: c_provider
s_consumer:
build:
context: ./ServerComsumer/
dockerfile: Dockerfile
args:
consumerport: 2000
ports:
- "2000:2000"
links:
- s_provider:s_provider
environment:
consumerport: 2000
serverurl: http://s_provider:1000/api/values/
container_name: c_consumer4. 定位到 docker-compose 文件所在目录，运行 docker-compose
[root@cys-test-centos WebDocker]# docker-compose up运行成功，状态如下：
5. 另起一个命令窗口，测试接口
[root@cys-test-centos ~]# curl http://localhost:1000/api/values
["this is serverprovider''s result"]root@cys-test-centos ~]# curl http://localhost:2000/api/values
["value1","value2"][root@cys-test-centos ~]# curl http://localhost:2000/api/values/1
["this is serverprovider''s result"]以上是通过 docker-compose 新建镜像，并运行容器，如果镜像已存在，则可以去掉构建的过程，我们稍微对 docker-compose 文件做一下调整
6. 在上面步骤的前提下，先 CtrlC 停止容器，然后 docker-compsoe down 删除容器
[root@cys-test-centos WebDocker]# docker-compose down
Removing c_consumer ... done
Removing c_provider ... done
Removing network webdocker_default7. 查看生成的镜像
[root@cys-test-centos WebDocker]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
webdocker_s_consumer latest cc95654856e1 17 minutes ago 253MB
webdocker_s_provider latest 5b744758b56b 17 minutes ago 253MB
microsoft/dotnet 2.1-aspnetcore-runtime db366d73508b 4 days ago 253MB镜像名为：webdocker_s_provider 与 webdocker_s_consumer
8. 修改 docker-compose.yml 文件
version: ''3''
services:
s_provider:
image: webdocker_s_provider
ports:
- "1000:1000"
environment:
serverport: 1000
container_name: c_provider
s_consumer:
image: webdocker_s_consumer
ports:
- "2000:2000"
links:
- s_provider:s_provider
environment:
consumerport: 2000
serverurl: http://s_provider:1000/api/values/
container_name: c_consumer9. 验证接口
[root@cys-test-centos ~]# curl http://localhost:2000/api/values/1
["this is serverprovider''s result"]
到此 Docker-Compose 介绍完毕，下一章讲 Docker 三剑客之 Docker-machine
CentOS 下 Docker 与.netcore (五）之 三剑客之一 Docker-swarm 集群
CentOS 下 Docker 与.netcore (一) 之 安装
CentOS 下 Docker 与.netcore (二) 之 Dockerfile
CentOS 下 Docker 与.netcore (三）之 三剑客之一 Docker-Compose
CentOS 下 Docker 与.netcore (四）之 三剑客之一 Docker-machine+jenkins 简单自动化部署
CentOS 下 Docker 与.netcore (五）之 三剑客之一 Docker-swarm 集群
1. 什么是 docker-swarm
在公司网站流量爆发式增长的时候，一台服务器往往不能满足需求，之前我的解决办法是通过 nginx 来实现负载均衡，有了 docker-machine 之后，解决方案会更加简单。当流量增加时，我们按照需要往 docker-swarm 集群中添加主机就可以了。
2. 原理
我们把一组 docker-swarm 集群中的所有 docker 容器统称作一个 service，其中的每一个 docker 容器称做一个 task，如下图
3. 开始搭建环境
上一章我们讲了 docker-machine，在这里我们需要用到。我在我本地 Hyper-v 创建 4 个虚拟机
其中：
CentOS 设置静态 IP： 192.168.8.200，并在这个虚机上搭建好 docker-machine
CentOS2 设置静态 IP：192.168.8.201
CentOS3 设置静态 IP：192.168.8.202
CentOS3 设置静态 IP：192.168.8.203
然后通过 200 节点，分别在 201，202，203 上搭建好 docker
4. 创建集群（swarm 命令）
1）docker-mashine ssh 到 host1 上创建 leader
[root@localhost ~]# docker-machine ssh host1[root@host1 ~]# docker swarm init --advertise-addr 192.168.8.2012）docker-mashine ssh 到 host2 加入集群
[root@localhost ~]# docker-machine ssh host23）docker-mashine ssh 到 host1 上查看集群列表
到此，集群构建完毕，是一个最简单的集群
5. 新建.netcore 项目
1）修改 ValueController.cs
// GET api/values
[HttpGet]
public ActionResult<IEnumerable<string>> Get()
{
var ip = HttpContext.Connection.LocalIpAddress;
var port = HttpContext.Connection.LocalPort;
return new string[] { ip.ToString(), port.ToString() }; }2）修改 Program.cs
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args).UseUrls("http://*:5000")
.UseStartup<Startup>();3）新建 dockerfile，并经属性设置为：始终复制到输出目录
FROM microsoft/dotnet:2.1-aspnetcore-runtime
MAINTAINER yishi.chen
LABEL description="DockerSwarmTest"
LABEL version="1.0"
WORKDIR /app
COPY . .
EXPOSE 5000
ENTRYPOINT ["dotnet","DockerSwarmTest.dll"]
4）构建 image 并上传到 docker-hub
5）创建 service
我们先只创建一个容器
测试接口
6）添加一个容器
[root@host1 ~]# docker service update --replicas 2 cys_web查看运行状态
两个都已经启动
6. 模拟并发请求接口
新建一个控制台程序
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
namespace Client { class Program { static HttpClient httpClient = new HttpClient(); static void Main(string[] args) { Parallel.For(1, 10000, i => { HttpResponseMessage response = httpClient.SendAsync(new HttpRequestMessage { Method = new HttpMethod("GET"), RequestUri = new Uri("http://192.168.8.202:5000/api/values") }).Result; var result = response.Content.ReadAsStringAsync().Result; Console.WriteLine(result); }); } } }运行测试，结果如下：
我们发现，请求 http://192.168.8.202:5000/api/values 时，是对 service 中的两个容器实现轮询调用的，因此，docker swarm 很简单的实现了负载，我们可以再把 host3 加进集群里，再测试一下有三个容器的情况的结果。
[root@host1 ~]# docker node ls
ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS ENGINE VERSION
b6qt1dnbj4hnf2jks0rnxjm8y * host1 Ready Active Leader 18.09.0
p9vfq9qt6dtv929an5hzmirn9 host2 Ready Active 18.09.0
uy37l58v2ooux2tju89ex1o7q host3 Ready Active 18.09.0运行控制台测试
三台机器完成负载！！
至此三剑客分享完毕
Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock
在 Docker 容器里面使用 docker run/docker build？
Docker 容器技术目前是微服务/持续集成/持续交付领域的第一选择。而在 DevOps 中，我们需要将各种后端/前端的测试/构建环境打包成 Docker 镜像，然后在需要的时候，Jenkins 会使用这些镜像启动容器以执行 Jenkins 任务。
为了方便维护，我们的 CI 系统如 Jenkins，也会使用 Docker 方式部署。 Jenkins 任务中有些任务需要将微服务构建成 Docker 镜像，然后推送到 Harbor 私有仓库中。 或者我们所有的 Jenkins Master 镜像和 Jenkins Slave 镜像本身都不包含任何额外的构建环境，执行任务时都需要启动包含对应环境的镜像来执行任务。
我们的 Jenkins Master、Jenkins Slaves 都是跑在容器里面的，该如何在这些容器里面调用 docker run 命令启动包含 CI 环境的镜像呢？ 在这些 CI 镜像里面，我们从源码编译完成后，又如何通过 docker build 将编译结果打包成 Docker 镜像，然后推送到内网仓库呢？
答案下面揭晓。
一、原理说明：/var/run/docker.sock
Docker 采取的是 Client/Server 架构，我们常用的 docker xxx 命令工具，只是 docker 的 client，我们通过该命令行执行命令时，实际上是在通过 client 与 docker engine 通信。
我们通过 apt/yum 安装 docker-ce 时，会自动生成一个 systemd 的 service，所以安装完成后，需要通过 sudo systemctl enable docker.service 来启用该服务。 这个 Docker 服务启动的，就是 docker engine，查看 /usr/lib/systemd/system/docker.service，能看到有这样一条语句：
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
默认情况下，Docker守护进程会生成一个 socket（/var/run/docker.sock）文件来进行本地进程通信，因此只能在本地使用 docker 客户端或者使用 Docker API 进行操作。 sock 文件是 UNIX 域套接字，它可以通过文件系统（而非网络地址）进行寻址和访问。
因此只要以数据卷的形式将 docker 客户端和上述 socket 套接字挂载到容器内部，就能实现 "Docker in Docker"，在容器内使用 docker 命令了。具体的命令见后面的「示例」部分。
要记住的是，真正执行我们的 docker 命令的是 docker engine，而这个 engine 跑在宿主机上。所以这并不是真正的 "Docker in Docker".
二、示例
在容器内部使用宿主机的 docker，方法有二：
- 命令行方式：将
/usr/bin/docker映射进容器内部，然后直接在容器内部使用这个命令行工具docker- 需要的时候，也可以将
/etc/docker文件夹映射到容器内，这样容器内的docker命令行工具也会使用与宿主机同样的配置。
- 需要的时候，也可以将
- 编程方式：在容器内部以编程的方式使用 docker
- 通过 python 使用 docker: 在 Dockerfile 中通过
pip install docker将 docker client 安装到镜像中来使用
- 通过 python 使用 docker: 在 Dockerfile 中通过
容器的启动方式也有两种，如下：
1. 直接通过 docker 命令启动
示例命令如下：
docker run --name <name> \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /usr/bin/docker:/usr/bin/docker \
--user root \
<image-name>:<tag>
**必须以 root 用户启动！（或者其他有权限读写 /var/run/docker.sock 的用户）**然后，在容器内就能正常使用 docker 命令，或者访问宿主机的 docker api 了。
2. 使用 docker-compose 启动
docker-compose.yml 文件内容如下：
version: ''3.3''
services:
jenkins-master:
image: jenkinsci/blueocean:latest
container_name: jenkins-master
environment:
- TZ=Asia/Shanghai # 时区
ports:
- "8080:8080"
- "50000:50000"
volumes:
- ./jenkins_home:/var/jenkins_home # 将容器中的数据映射到宿主机
- /usr/bin/docker:/usr/bin/docker # 为容器内部提供 docker 命令行工具（这个随意）
- /var/run/docker.sock:/var/run/docker.sock # 容器内部通过 unix socket 使用宿主机 docker engine
user: root # 必须确保容器以 root 用户启动！（这样它才有权限读写 docker.socket）
restart: always
然后通过 docker-compose up -d 即可后台启动容器。
Docker 中的 uid 与 gid
通过上面的操作，我们在容器内执行 docker ps 时，还是很可能会遇到一个问题：权限问题。
如果你容器的默认用户是 root，那么你不会遇到这个问题，因为 /var/run/docker.sock 的 onwer 就是 root.
但是一般来说，为了限制用户的权限，容器的默认用户一般都是 uid 和 gid 都是 1000 的普通用户。这样我们就没有权限访问 /var/run/docker.sock 了。
解决办法：
方法一（不一定有效）：在构建镜像时，最后一层添加如下内容：
# docker 用户组的 id，通常都是 999
RUN groupadd -g 999 docker \
&& usermod -aG docker <your_user_name>
这样我们的默认用户，就能使用 docker 命令了。
P.S.
999不一定是 docker 用户组，所以上述方法某些情况下可能失效。这时还是老老实实通过docker run -u root启动容器吧。（或者在docker-compose.yml中添加user: root属性）
参考
- Docker in Docker - 王柏元
docker 三剑客 docker-compose、docker-machine、swarm
Docker 三大编排工具：
Docker Compose：是用来组装多容器应用的工具，可以在 Swarm 集群中部署分布式应用。
Docker Machine：是支持多平台安装 Docker 的工具，使用 Docker Machine，可以很方便地在笔记本、云平台及数据中心里安装 Docker。
Docker Swarm：是 Docker 社区原生提供的容器集群管理工具。
Docker Compose
Github 地址： https://github.com/docker/compose
简单来讲，Compose 是用来定义和运行一个或多个容器应用的工具。使用 compaose 可以简化容器镜像的建立及容器的运行。
Compose 使用 python 语言开发，非常适合在单机环境里部署一个或多个容器，并自动把多个容器互相关联起来。
Compose 中有两个重要的概念：
服务 (service)：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。
项目 (project)：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。
Compose 是使用 YML 文件来定义多容器应用的，它还会用 docker-compose up 命令把完整的应用运行起来。docker-compose up 命令为应用的运行做了所有的准备工作。从本质上讲，Compose 把 YML 文件解析成 docker 命令的参数，然后调用相应的 docker 命令行接口，从而把应用以容器化的方式管理起来。它通过解析容器间的依赖关系来顺序启动容器。而容器间的依赖关系则可以通过在 docker-compose.yml 文件中使用 links 标记指定。
安装 Docker compose:
官方文档
pip 安装：
pip install docker-compose
从 github 安装：
curl -L --fail https://github.com/docker/compose/releases/download/1.17.0/run.sh -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
1
2
3
4
5
6
7
卸载：
rm /usr/local/bin/docker-compose # 使用 curl 安装的
pip uninstall docker-compose # 使用 pip 卸载
1
2
3
命令说明
docker-compose --help
1
Docker Machine
Github 地址： https://github.com/docker/machine/
Docker Machine 是 Docker 官方编排（Orchestration）项目之一，负责在多种平台上快速安装 Docker 环境。
Docker Machine 项目基于 Go 语言实现，目前在 Github 上进行维护。
安装：
curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` > /usr/local/bin/docker-machine
chmod +x /usr/local/bin/docker-machine
1
2
3
完成后，查看版本信息：
# docker-machine -v
docker-machine version 0.13.0, build 9ba6da9
1
2
3
为了得到更好的体验，我们可以安装 bash completion script，这样在 bash 能够通过 tab 键补全 docker-mahine 的子命令和参数。
下载方法：
base=https://raw.githubusercontent.com/docker/machine/v0.13.0
for i in docker-machine-prompt.bash docker-machine-wrapper.bash docker-machine.bash
do
sudo wget "$base/contrib/completion/bash/${i}" -P /etc/bash_completion.d
done
1
2
3
4
5
确认版本将其放置到 /etc/bash_completion.d 目录下。
然后在你的 bash 终端中运行如下命令，告诉你的设置在哪里可以找到 docker-machine-prompt.bash 你以前下载的文件 。
source /etc/bash_completion.d/docker-machine-prompt.bash
1
要启用 docker-machine shell 提示符，请添加 $(__docker_machine_ps1) 到您的 PS1 设置中～/.bashrc。
PS1=''[\u@\h \W$(__docker_machine_ps1)]\$ ''
1
使用：
Docker Machine 支持多种后端驱动，包括虚拟机、本地主机和云平台等
创建本地主机实例：
使用 virtualbox 类型的驱动，创建一台 Docker 主机，命名为 test
安装 VirtualBox：
配置源：
# cat /etc/yum.repos.d/virtualbox.repo
[virtualbox]
name=Oracle Linux / RHEL / CentOS-$releasever / $basearch - VirtualBox
baseurl=http://download.virtualbox.org/virtualbox/rpm/el/$releasever/$basearch
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://www.virtualbox.org/download/oracle_vbox.asc
#安装 VirtualBox：
yum search VirtualBox
yum install -y VirtualBox-5.2
/sbin/vboxconfig # 重新加载 VirtualBox 服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
创建主机：
# docker-machine create -d virtualbox test
Running pre-create checks...
Creating machine...
(test) Copying /root/.docker/machine/cache/boot2docker.iso to /root/.docker/machine/machines/test/boot2docker.iso...
(test) Creating VirtualBox VM...
(test) Creating SSH key...
(test) Starting the VM...
(test) Check network to re-create if needed...
(test) Found a new host-only adapter: "vboxnet0"
(test) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
也可以在创建时加上如下参数，来配置主机或者主机上的 Docker。
--engine-opt dns=114.114.114.114 #配置 Docker 的默认 DNS
--engine-registry-mirror https://registry.docker-cn.com #配置 Docker 的仓库镜像
--virtualbox-memory 2048 #配置主机内存
--virtualbox-cpu-count 2 #配置主机 CPU
1
2
3
4
更多参数请使用 docker-machine create --driver virtualbox --help 命令查看。
查看主机：
# docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
test - virtualbox Running tcp://192.168.99.100:2376 v18.05.0-ce
1
2
3
创建主机成功后，可以通过 env 命令来让后续操作目标主机：
docker-machine env test
1
可以通过 SSH 登录到主机：
docker-machine ssh test
1
官方支持驱动：
# 通过 -d 选项可以选择支持的驱动类型。
amazonec2
azure
digitalocean
exoscale
generic
google
hyperv
none
openstack
rackspace
softlayer
virtualbox
vmwarevcloudair
vmwarefusion
vmwarevsphere
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
第三方驱动请到 第三方驱动列表 查看
常用操作命令：
active 查看活跃的 Docker 主机
config 输出连接的配置信息
create 创建一个 Docker 主机
env 显示连接到某个主机需要的环境变量
inspect 输出主机更多信息
ip 获取主机地址
kill 停止某个主机
ls 列出所有管理的主机
provision 重新设置一个已存在的主机
regenerate-certs 为某个主机重新生成 TLS 认证信息
restart 重启主机
rm 删除某台主机
ssh SSH 到主机上执行命令
scp 在主机之间复制文件
mount 挂载主机目录到本地
start 启动一个主机
status 查看主机状态
stop 停止一个主机
upgrade 更新主机 Docker 版本为最新
url 获取主机的 URL
version 输出 docker-machine 版本信息
help 输出帮助信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
每个命令，又带有不同的参数，可以通过 docker-machine COMMAND --help 查看。
Docker Swarm
Docker Swarm 是 Docker 官方三剑客项目之一，提供 Docker 容器集群服务，是 Docker 官方对容器云生态进行支持的核心方案。使用它，用户可以将多个 Docker 主机封装为单个大型的虚拟 Docker 主机，快速打造一套容器云平台。
Docker 1.12 Swarm mode 已经内嵌入 Docker 引擎，成为了 docker 子命令 docker swarm。请注意与旧的 Docker Swarm 区分开来。
Swarm mode 内置 kv 存储功能，提供了众多的新特性，比如：具有容错能力的去中心化设计、内置服务发现、负载均衡、路由网格、动态伸缩、滚动更新、安全传输等。使得 Docker 原生的 Swarm 集群具备与 Mesos、Kubernetes 竞争的实力。
基本概念
Swarm 是使用 SwarmKit 构建的 Docker 引擎内置（原生）的集群管理和编排工具。
节点：
运行 Docker 的主机可以主动初始化一个 Swarm 集群或者加入一个已存在的 Swarm 集群，这样这个运行 Docker 的主机就成为一个 Swarm 集群的节点 (node)
节点分为管理 (manager) 节点和工作 (worker) 节点
管理节点：用于 Swarm 集群的管理，docker swarm 命令基本只能在管理节点执行（节点退出集群命令 docker swarm leave 可以在工作节点执行）。一个 Swarm 集群可以有多个管理节点，但只有一个管理节点可以成为 leader，leader 通过 raft 协议实现。
工作节点：是任务执行节点，管理节点将服务 (service) 下发至工作节点执行。管理节点默认也作为工作节点。也可以通过配置让服务只运行在管理节点。
集群中管理节点与工作节点的关系如下所示：
服务和任务：
任务 （Task）是 Swarm 中的最小的调度单位，目前来说就是一个单一的容器。
服务 （Services） 是指一组任务的集合，服务定义了任务的属性。服务有两种模式：
replicated services 按照一定规则在各个工作节点上运行指定个数的任务。
global services 每个工作节点上运行一个任务。
两种模式通过 docker service create 的 --mode 参数指定。
容器、任务、服务的关系如下所示：
swarm：
从 v1.12 开始，集群管理和编排功能已经集成进 Docker Engine。当 Docker Engine 初始化了一个 swarm 或者加入到一个存在的 swarm 时，它就启动了 swarm mode。没启动 swarm mode 时，Docker 执行的是容器命令；运行 swarm mode 后，Docker 增加了编排 service 的能力。
Docker 允许在同一个 Docker 主机上既运行 swarm service，又运行单独的容器。
node：
swarm 中的每个 Docker Engine 都是一个 node，有两种类型的 node：manager 和 worker。
为了向 swarm 中部署应用，我们需要在 manager node 上执行部署命令，manager node 会将部署任务拆解并分配给一个或多个 worker node 完成部署。manager node 负责执行编排和集群管理工作，保持并维护 swarm 处于期望的状态。swarm 中如果有多个 manager node，它们会自动协商并选举出一个 leader 执行编排任务。woker node 接受并执行由 manager node 派发的任务。默认配置下 manager node 同时也是一个 worker node，不过可以将其配置成 manager-only node，让其专职负责编排和集群管理工作。work node 会定期向 manager node 报告自己的状态和它正在执行的任务的状态，这样 manager 就可以维护整个集群的状态。
service：
service 定义了 worker node 上要执行的任务。swarm 的主要编排任务就是保证 service 处于期望的状态下。
举一个 service 的例子：在 swarm 中启动一个 http 服务，使用的镜像是 httpd:latest，副本数为 3。manager node 负责创建这个 service，经过分析知道需要启动 3 个 httpd 容器，根据当前各 worker node 的状态将运行容器的任务分配下去，比如 worker1 上运行两个容器，worker2 上运行一个容器。运行了一段时间，worker2 突然宕机了，manager 监控到这个故障，于是立即在 worker3 上启动了一个新的 httpd 容器。这样就保证了 service 处于期望的三个副本状态。
默认配置下 manager node 也是 worker node，所以 swarm-manager 上也运行了副本。如果不希望在 manager 上运行 service，可以执行如下命令：
docker node update --availability drain master
1
创建 swarm 集群
Swarm 集群由管理节点和工作节点组成。现在我们来创建一个包含一个管理节点和两个工作节点的最小 Swarm 集群。
初始化集群：
使用 Docker Machine 创建三个 Docker 主机，并加入到集群中
首先创建一个 Docker 主机作为管理节点：
docker-machine create -d virtualbox manger
1
使用 docker swarm init 在管理节点初始化一个 Swarm 集群
docker-machine ssh manger
docker@manger:~$ docker swarm init --advertise-addr 192.168.99.101
Swarm initialized: current node (fwh0yy8m8bygdxnsl7x1peioj) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-2acj2brip56iee9p4hc7klx3i6ljnpykh5lx6ea3t9xlhounnv-70knqo263hphhse02gxuvja12 192.168.99.101:2377
To add a manager to this swarm, run ''docker swarm join-token manager'' and follow the instructions.
docker@manger:~$
1
2
3
4
5
6
7
8
9
10
11
12
13
注意：如果你的 Docker 主机有多个网卡，拥有多个 IP，必须使用 --advertise-addr 指定 IP。
执行 docker swarm init 命令的节点自动成为管理节点。
增加工作节点：
在 docker swarm init 完了之后，会提示如何加入新机器到集群，如果当时没有注意到，也可以通过下面的命令来获知 如何加入新机器到集群。
# docker swarm join-token worker [--quiet]
# docker swarm join-token manager [--quiet]
1
2
根据 token 的不同，我们来区分加入集群的是 manager 节点还是普通的节点。通过加入–quiet 参数可以只输出 token，在需要保存 token 的时候还是十分有用的。
上一步初始化了一个 Swarm 集群，拥有了一个管理节点，下面继续创建两个 Docker 主机作为工作节点，并加入到集群中。
# docker-machine create -d virtualbox worker1
# docker-machine ssh worker1
docker@worker1:~$ docker swarm join --token SWMTKN-1-2acj2brip56iee9p4hc7klx3i6ljnpykh5lx6ea3t9xlhounnv-70knqo263hphhse02gxuvja12 192.168.99.101:2377
This node joined a swarm as a worker.
docker@worker1:~$
# docker-machine create -d virtualbox worker2
# docker-machine ssh worker2
docker@worker2:~$ docker swarm join --token SWMTKN-1-2acj2brip56iee9p4hc7klx3i6ljnpykh5lx6ea3t9xlhounnv-70knqo263hphhse02gxuvja12 192.168.99.101:2377
This node joined a swarm as a worker.
docker@worker2:~$
1
2
3
4
5
6
7
8
9
10
11
12
13
查看集群：
在 manager machine 上执行 docker node ls 查看有哪些节点加入到 swarm 集群。
# docker-machine ssh manger
docker@manger:~$ docker node ls
ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS ENGINE VERSION
fwh0yy8m8bygdxnsl7x1peioj * manger Ready Active Leader 18.05.0-ce
0v6te4mspwu1d1b4250fp5rph worker1 Ready Active 18.05.0-ce
mld8rm9z07tveu1iknvws0lr1 worker2 Ready Active 18.05.0-ce
1
2
3
4
5
6
7
部署服务
使用 docker service 命令来管理 Swarm 集群中的服务，该命令只能在管理节点运行。
新建服务：
在上一节创建的 Swarm 集群中运行一个名为 nginx 服务：
docker@manger:~$ docker service create --replicas 3 -p 80:80 --name nginx nginx
khw3av021hlxs3koanq85301j
overall progress: 3 out of 3 tasks
1/3: running [==================================================>]
2/3: running [==================================================>]
3/3: running [==================================================>]
verify: Service converged
docker@manger:~$
1
2
3
4
5
6
7
8
9
使用浏览器，输入任意节点 IP , 即可看到 nginx 默认页面。
查看服务：
使用 docker service ls 来查看当前 Swarm 集群运行的服务。
docker@manger:~$ docker service ls
ID NAME MODE REPLICAS IMAGE PORTS
khw3av021hlx nginx replicated 3/3 nginx:latest *:80->80/tcp
docker@manger:~$
1
2
3
4
5
使用 docker service ps 来查看某个服务的详情。
docker@manger:~$ docker service ps nginx
ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
6b900c649xyp nginx.1 nginx:latest worker1 Running Running 5 minutes
n55uhpjdurxs nginx.2 nginx:latest worker2 Running Running 5 minutes ago
l2uiyggbegsf nginx.3 nginx:latest manger Running Running 5 minutes ago
docker@manger:~$
1
2
3
4
5
6
7
使用 docker service logs 来查看某个服务的日志：
docker@manger:~$ docker service logs nginx
1
服务伸缩：
可以使用 docker service scale 对一个服务运行的容器数量进行伸缩
当业务处于高峰期时，我们需要扩展服务运行的容器数量
$ docker service scale nginx=5
1
当业务平稳时，我们需要减少服务运行的容器数量
$ docker service scale nginx=2
1
删除服务:
使用 docker service rm 来从 Swarm 集群移除某个服务。
$ docker service rm nginx
1
使用 compose 文件
管理敏感数据
管理配置信息
更多 swarm 的资料可以参考：《每天 5 分钟玩转 Docker 容器技术》Docker Swarm 部分
参考链接：
https://blog.csdn.net/wh211212/article/details/78686241
https://yeasy.gitbooks.io/docker_practice/content/swarm/
docker-compose
安装 compose
curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
测试安装
$ docker-compose --version
docker-compose version 1.21.2, build 1719ceb
常用命令
命令:
build Build or rebuild services
bundle Generate a Docker bundle from the Compose file
config Validate and view the Compose file
create Create services
down Stop and remove containers, networks, images, and volumes
events Receive real time events from containers
exec Execute a command in a running container
help Get help on a command
images List images
kill Kill containers
logs View output from containers
pause Pause services
port Print the public port for a port binding
ps List containers
pull Pull service images
push Push service images
restart Restart services
rm Remove stopped containers
run Run a one-off command
scale Set number of containers for a service
start Start services
stop Stop services
top Display the running processes
unpause Unpause services
up Create and start containers
version Show the Docker-Compose version information
https://docs.docker.com/compose/overview/
https://blog.csdn.net/Dante_003/article/details/70160493
docker-machine
简介
docker-machine 是安装 docker 环境的一个工具，可以在一台机器上通过命令控制几台机器安装 docker 环境，运行 docker 命令，创建 docker swarm 集群的工具。
安装
docker-machine 和 compose 有点类似，都是一个可运行的 linux 二进制文件 (下面都是基于 linux 版本做的)，下载下来这个文件后放到 /usr/local/bin 里面设置文件权限就可以直接使用了，docker-machine 的 github 地址
https://github.com/docker/machine
curl -L https://github.com/docker/machine/releases/download/v0.10.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine &&
chmod +x /tmp/docker-machine &&
sudo cp /tmp/docker-machine /usr/local/bin/docker-machine
使用
按照 docker-machine github 上的介绍，它是一个简化 Docker 安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装 Docker，比如 VirtualBox、 Digital Ocean、Microsoft Azure。根据他的描述和 github 上的例子可以看出他可以直接在指定平台上创建机器。
我们这里只测试已经创建好有 ip 的实体机或者虚拟机。
docker-machine 操作各个机器实际上用 ssh 无密码访问的，如果是在已经配置好 ip 的实体机或虚拟机上用就要手动或者使用脚本设置无密码访问了。
无密码访问
ssh-keygen #一直回车
ssh-copy-id root@192.168.1.28 #ip 为 docker-machine 要操作的机器，输入密码
## 上面结束之后，每台机器上还得安装 net-tools,docker-machine 会用到 netstat 命令来检测端口使用情况，如果机器上没有安装会报错。如果你确定那台机器上的端口没问题，即使报错也没问题，最终那台机器还是会加入到 docker-machine 的管理中。
yum install net-tools
连接机器
docker-machine create -d generic --generic-ip-address=192.168.1.28 node28
node28 为给机器的别名
-d generic 驱动类型
–generic-ip-address 要控制机器的 ip，必须
–generic-engine-port docker-engine 的远程访问端口，默认为 2376
–generic-ssh-key 远程访问机器的私钥，默认使用.ssh/ 下面的私钥
–generic-ssh-user 远程访问机器的用户名，默认为 root
–generic-ssh-port 远程 ssh 访问的端口，默认为 22
–engine-insecure-registry docker-engine 的 insecure-registry
–engine-install-url 安装 docker-engine 的地址，默认为”https://get.docker.com”
–engine-registry-mirror docker-engine 镜像的代理地址
上面的命令根据国内环境可以换为下面
docker-machine create \
-d generic \
--generic-ip-address=192.168.1.28 \
--engine-install-url=https://get.daocloud.io/docker/ \
--engine-registry-mirror=http://91c0cc1e.m.daocloud.io \
node28
通过 docker-machine 连接了各个机器后，就可以通过 docker-machine 来操作各个机器了，更多命令查看 docker-machine –help
https://docs.docker.com/machine/install-machine/
https://blog.csdn.net/vchy_zhao/article/details/70238472
swarm
简介
swarm 从 docker1.9 版本开始就有了，但功能不完善、性能不稳定，一直不能登入生产环境，从 1.12 版本内置到了 docker-engine 中，可以直接使用 docker swarm 命令来操作 swarm。
swarm 是 docker 集群的资源管理工具。简单点理解，在很多台机器上部署 docker，组成一个 docker 集群，并把整个集群的资源抽象成资源池，使用者部署 docker 应用的时候，只需要将应用交给 swarm，swarm 会根据整个集群资源的使用情况来分配资源给部署的 docker 应用，可以将这个集群的资源利用率达到最大。
类似的服务框架还有 mesos+marathon，kubernetes。
编者是从很早接触 docker 的，swarm 还没有出来，kubernetes 还不成熟没有人在生产环境使用。
①最早使用的是 mesos+marathon 那一套，优点是基于成熟的资源调度管理框架 mesos，缺点是部署起来还是很麻烦的，像服务发现、负载均衡等概念在里面也都有，但都是碎片化以插件的形式存在，整个体系感觉不是很完善、不像一个整体。
②kubernetes 从发布 1.0 版本以后在生产得到了很多实践，开始步入主流压过 swarm 和 mesos+marathon，kubernetes 针对 docker 应用集群的特点，概括出几个对象，pod、service、replication controller，pod 为运行的基本单元，service 则是专门来服务发现和服务代理的，replication controller 应用的副本做负载均衡。kubernetes 就是一个很专业很全面完善的 docker 集群管理工具。
③swarm 在很多方面很像 kubernetes，不知道是不是偷偷抄袭的。swarm 通过命令就可以很简单的在 docker 集群中创建应用设置副本数量，内置服务发现代理。swarm+compose≈kubernetes。swarm 由于现在内置于 docker 中，使用部署更简单，功能上和 kubernetes 很相似，轻量级。
常用命令
swarm init
swarm join
service create
service inspect
service ls
service rm
service scale
service ps
service update
https://docs.docker.com/engine/swarm/#feature-highlights
https://blog.csdn.net/Dante_003/article/details/70171804
---------------------
前言
你是否曾经和我一样，想了解一个新的中间件，如 redis、kafka、zookeeper 等，发现无论是单点还是集群搭建过程都异常繁琐，甚至占用了一半以上的学习时间？很多中间件都是基于 linux 系统的，但是你却要在 windows 上做文章？作为一个后端程序员，我只想学习一下中间件怎么使用，却被这种繁琐的过程限制住了手脚，抑或是半途而废？
正所谓，工欲善其事，必先利其器。Docker 可以完美的解决我们以上的痛点，而且安装过程简单。
本文参照 Docker 官方文档 https://docs.docker.com/，基于 windows 系统，Linux 和 Mac 系统除了安装过程不同之外其余过程均相同。
一、安装 Docker
步骤一
下载安装 DockerToolBox： https://docs.docker.com/toolbox/overview/
image.png
步骤二
安装成功之后会有三个图标出现，Docker Quickstart 基本上不用，常用的是另两个，打开 VM 更新到最新版本（因为旧版本打开 Kitematic 的时候容易卡死）
image.png
步骤三
打开 Kitematic 软件，点击 hello-world-nginx 的 CREATE 按钮，创建一个容器，如果能正常跑起来就证明安装成功了。
image.png
二、Docker Machine
经过上面过程我们已经在 Windows 里面成功安装了 docker 环境，但本质上 Kitematic 软件底层利用的是 VirtualBox 虚拟机和 DockerMachine，那么什么是 Docker Machine？
1、Docker Machine 概念
Docker Machine 就是创建 Docker 环境的机器，简单说就是有了 Docker Machine 就可以在任何系统任何平台上快速的搭建 Docker 环境了。
2、利用 Docker Machine 快速创建 Docker 环境
创建 Docker 虚拟机
打开 cmd 窗口，执行命令 docker-machine create --driver=virtualbox machine1
该命令以 virtualbox 为介质快速创建一个包含有 docker 环境的虚拟机。命令执行完成之后打开 virtualbox 界面如下：
可以看到 machine1 正在运行，双击进入该虚拟机可以执行 docker 的所有命令。
你可以利用上面的命令继续创建多个含有 Docker Engine 的多个虚拟机
image.png
进入 Docker 虚拟机
打开 cmd 窗口，执行命令 docker-machine ssh machine1
该命令可以通过 cmd 窗口进入到 machine1 环境，因为 virtualbox 的复制粘贴操作没有 cmd 窗口那么便捷，所以我一般复制命令的时候都使用 cmd 窗口 ssh 进入
其他 Docker machine 命令
docker-machine start/stop 可以删除容器关闭和不删除容器关闭虚拟机
更多命令请参考 https://docs.docker.com/machine/reference/
三、Docker Compose
1、Dcoker Compose 概念
Docker Compose 可以有组织的启动同属于一个服务的多个容器
换句话说 当一个服务包含多个容器的时候，docker compose 可以通过 yaml 文件预先配置，然后统一启动
2、Docker Compose 安装
三步走：进入 machine1、切换 root 用户、安装及更改 compose 权限
1.21.1 为版本，可以到 https://github.com/docker/compose/releases 去查看可更换的 compose 版本
sudo -i
curl -L https://github.com/docker/compose/releases/download/1.21.1/docker-compose-uname -s-uname -m-o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
3、Compose 的使用
以三节点的 zookeeper 伪集群为例，最重要的就是 yaml 文件，这个是构建服务的蓝图
首先：随便在哪个目录下创建一个 docker-compose.yml 文件（注意名称必须为 docker-compose），内容如下
然后：进入 docker-compose.yml 目录，执行 docker-compose up -d （-d 表示后台运行）结果如图
version: ''3.1''
services:
zoo1:
image: zookeeper
restart: always
hostname: zoo1
ports:
- 2181:2181
environment:
ZOO_MY_ID: 1
ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
zoo2:
image: zookeeper
restart: always
hostname: zoo2
ports:
- 2182:2181
environment:
ZOO_MY_ID: 2
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888
zoo3:
image: zookeeper
restart: always
hostname: zoo3
ports:
- 2183:2181
environment:
ZOO_MY_ID: 3
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888
image.png
再次：检查 zookeeper 伪集群是否安装成功，使用 docker ps 查看正在运行的容器，记下 ID
然后：通过 docker exec -it id /bin/bash 进入 zookeeper 下，进入 bin 目录，执行 zkCli.sh 就可以执行 zookeeper 命令了！
image.png
就这样伪集群瞬间搭建好，跟谁说理去？
4、yml 模板说明：
-
version 对应 compose 和 Engine 版本
image.png
- services 对应多个容器
- zoo1/2/3 为容器名称
- image 表示基于的镜像为 zookeeper
- environment 表示环境变量
- ports 前面的端口号表示容器宿主机的端口号，后面的端口号表示容器的端口号
- 其他顾名思义
4、Compose yml 其他语法
https://docs.docker.com/compose/compose-file/
四、Docker Swarm
上面两位剑客完成了 Docker 环境搭建和容器的编排工作，swarm 则用来完成多台机器（可物理可虚拟）之间容器集群的管理，Swarm 是 docker 自带的一种模式，内嵌到 docker 里，不用额外安装。
1、Swarm 中的重要概念
- 节点：NODE，一个节点本质上是一个包含 Docker Engine 环境的机器，可以是物理机也可以是虚拟机，我们这里可以是自己构建的 docker machine。Node 分为两种，一种为 leader，一种为 worker，前者负责分派工作，后者负责执行工作，同一个 NODE 可以同时有两种角色。
- 服务：Service，运行在节点上包含一个或者多个 task 的综合体，每个 task 都由一个容器和容器内部运行的一些命令共同代表。
- 负载均衡：使用内部负载均衡，访问任何节点端口都会通过负载均衡找到服务，即便当前 node 没有服务
image.png
2、快速搭建一个 Swarm 集群
步骤一：
打开 cmd 窗口，使用 docker-machine create xxx 创建一个 manager 环境和两个 worker 环境，创建完成可以打开 virtualbox 查看
image.png
步骤二：
在 manager 节点即图中的 machine1 节点内，执行命令
docker swarm init --advertise-addr 192.168.99.101 注意后边的 IP 为当前机器的 IP 可以通过 cmd 窗口的 docker-machine ip machine1 查看。--advertise-addr 表示设置 mannager
$ docker swarm init --advertise-addr 192.168.99.101
Swarm initialized: current node (bvz81updecsj6wjz393c09vti) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-1awxwuwd3z9j1z3puu7rcgdbx \
172.17.0.2:2377
To add a manager to this swarm, run ''docker swarm join-token manager'' and follow the instructions.
步骤三：
上一步中其实已经给出了加入 swarm 的命令了，如果没记住可以在 mananger 节点执行 docker swarm join-token worker 命令查看
docker swarm join --token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-7p73s1dx5in4tatdymyhg9hu2 192.168.99.101:2377
执行完上述命令后会有成功的提示
在 Manager 节点执行 docker node ls 可以查看当前节点
image.png
步骤四：
至此 Docker swarm 集群搭建完成，该集群包含三个节点，一个 Manager 和两个 worker，Manager 本质上也是一个 worker，都可以执行任务。
3、在 Swarm 上操作服务
- 发布：
随便在哪个节点上执行命令
docker service create
--replicas 3
--name redis
--update-delay 10s
redis:3.0.6
就可以发布一个 3.0.6 版本的 Redis 了，replicas 表示有三个副本，update-delay 表示当升级的时候，一个节点升级成功之后的 10 秒后才升级另一个节点 - 升级：
docker service update --image redis:3.0.7 redis
这个过程是滚动的，即一个接一个升级 - 查看：
docker service inspect --pretty redis
或者 docker service ps redis - 删除：
docker service rm redis - 停止 / 重启节点：
docker node update --availability drain worker1
该命令停止了节点 worker1，停止之后不接受新的请求，不接受 manager 分派
docker node update --availability active worker1
该命令重启了节点，使其恢复 active 状态 - 指定端口：
docker service create
--name my-web
--publish published=8080,target=80
--replicas 2
nginx
该命令指定了访问端口为 8080，映射 docker80 端口，可以通过任何节点访问到如 192.168.99.101:8080
4、Swarm && Compose
上面 Swarm 发布的 Service 都是单个容器的，多个容器如何操作呢？首先我们会联想到 Compose，但是 Comopse 旧版本只支持在单个 Host 上发布，在集群里就需要 Compose 新版本了！先保证 Compose 是 v3 以上吧！
去这个网址 https://github.com/docker/compose/releases/ 查看 compose 版本和 compose yml 版本的对应关系
image.png
Swarm 发布 Compose 编排的 Service 过程：
步骤一：
编排 docker-compose.yml 模板文件，此处命名可以随便起，与 Compose 不同
下面的 yml 文件来自官方 https://github.com/docker/labs/blob/master/beginner/chapters/votingapp.md
- version 必须是 3 及以上
- 该服务包含 redis、db、vote 服务（投票功能）、result 服务（统计结果）等等
version: "3"
services:
redis:
image: redis:alpine
ports:
- "6379"
networks:
- frontend
deploy:
replicas: 2
update_config:
parallelism: 2
delay: 10s
restart_policy:
condition: on-failure
db:
image: postgres:9.4
volumes:
- db-data:/var/lib/postgresql/data
networks:
- backend
deploy:
placement:
constraints: [node.role == manager]
vote:
image: dockersamples/examplevotingapp_vote:before
ports:
- 5000:80
networks:
- frontend
depends_on:
- redis
deploy:
replicas: 2
update_config:
parallelism: 2
restart_policy:
condition: on-failure
result:
image: dockersamples/examplevotingapp_result:before
ports:
- 5001:80
networks:
- backend
depends_on:
- db
deploy:
replicas: 1
update_config:
parallelism: 2
delay: 10s
restart_policy:
condition: on-failure
worker:
image: dockersamples/examplevotingapp_worker
networks:
- frontend
- backend
deploy:
mode: replicated
replicas: 1
labels: [APP=VOTING]
restart_policy:
condition: on-failure
delay: 10s
max_attempts: 3
window: 120s
placement:
constraints: [node.role == manager]
visualizer:
image: dockersamples/visualizer
ports:
- "8080:8080"
stop_grace_period: 1m30s
volumes:
- /var/run/docker.sock:/var/run/docker.sock
deploy:
placement:
constraints: [node.role == manager]
networks:
frontend:
backend:
volumes:
db-data:
步骤二：
执行命令 docker stack deploy --compose-file docker-compose.yml vote 启动基于 yml 文件的名称为 vote 的服务
注意 docker stack 不支持 build，需要事先指定镜像
image.png
步骤三：
这样多个容器就以服务的形式发布到集群里面了！通过 192.168.99.101:5000 访问即可看到页面！
docker stack services vote：可以查看服务状态
docker stack rm vote：可以删除服务
image.png
Docker-Compose 所有命令参数可以参考：https://docs.docker.com/compose/compose-file/
五、Docker 基础
docker 主要由仓库、镜像、容器三个概念组成！下图中显示了三者之间的关系
- 把镜像理解为软件安装包
- 把容器理解为使用的软件
- 把仓库理解为安装包下载网站
image.png
一：对于镜像：
1: 增加镜像：
A：从仓库下载：docker pull NAME:TAG
A1: 例子：docker pull ubuntu:latest
A2: 例子：docker pull ubuntu 同上
A3: 例子：docker pull ubuntu:14.04
B：创建镜像：
B1: 基于已有镜像的容器创建：docker commit 已经修改过的容器，如 docker 容器里创建了文件的镜像
B11:docker commit -m “消息” -a “作者信息” a925948cb23d（容器 ID） test：0.1（标签）
B2: 基于本地模板导入
B3: 基于 Dockerfile 创建
C：存出镜像：docker save -o xxx.tar xxx:latest 即可保存成 tar 文件
D：载入镜像：docker load < xxx.tar 即可载入 tar 文件
2: 删除镜像：
A：删除镜像：docker rmi image image 可以为标签也可以为 id
A1:-f 强行删除
3: 修改镜像：
A：给镜像打标签：docker tag ubuntu:latest myubuntu:latest
4: 查看镜像：
A：列出镜像：docker images
A1:-a 列出所有的镜像文件
A2:-q 仅输出 ID 信息
B：详细信息：docker inspect ubuntu：latest
C：查看历史：docker history ubuntu：latest
5: 搜索镜像：
A：搜索镜像：docker search -s 3 —automated ubuntu 搜索 3 星以上自动创建的 ubutnu 镜像
6: 上传镜像：
A：先加标签：docker tag xxx：14.04 user／test：latest
再往上推：docker push user／test：latest
B：上传到 docker hub 里面，跟 git 很类似
7:Dockerfile 详解：
构建：
Kind1：在 dockerfile 所在目录执行：docker build -t nginx：v3 .
Kind2: 直接用 gitRepo 构建：docker build git 路径：版本
解释：BS 架构，dockerfile 所在目录应该为空目录，所有需要复制或者添加的文件都应该复制到该目录下，这个路径是一个上下文 Context，构建过程中会把上下文发送给 Docker 引擎
A：FROM 命令：以什么为基础，可以是已经存在的镜像，也可以是虚拟镜像 scratch
B：RUN 命令：与直接在容器内命令行中输入的命令一样的效果，为了减少层数，可以使用 \ 和 && 结合的方式，换行并继续的意思
C：COPY 命令：COPY package.json ／usr／src／app，前者为上下文中的路径，后者可以为绝对路径，也可以为 WORKDIR 目录的相对路径
D：ADD 命令：与 COPY 一至，源路径可以为 url，可以为 tar 文件，只在自动解压缩的场合使用 ADD，其余一律用 RUN
E：CMD 命令：制定容器启动时所要执行的命令，只能执行一次，多次会覆盖，CMD 【“可执行程序”，“param1”，“parma2”】
F：ENTRYPOINT 命令：格式与 RUN 相同，给容器配置一个可执行程序格式与 CMD 相同，docker run 指令不会覆盖 ENTRYPOINT 命令而会覆盖 CMD 命令，比如 - i
G：ENV 命令：设 dockerfile 的环境变量 ENV key value，之后的命令可以使用 ENV 定义的环境变量，容器内也可以使用
H：VOLUME 命令：VOLUME ／data，匿名卷容器内的／data 映射入主机了
I：EXPOSE 命令：声明端口 EXPOSE 80 8080
J：WORKDIR：指定工作目录，或者成为当前目录，如果目录不存在 WORKDIR 会帮你创建
K：USER 命令：制定当前用户
二：对于容器：
1: 创建容器：
A：创建容器：docker create -it ubuntu：latest
保持标准输入打开：-i
后台运行容器：-d
分配一个伪终端：-t
B：创建并启动容器：docker run ubuntu ／bin/bash
2: 删除容器：
A：docker rm 命令删除：
B：删除所有：sudo docker rm $(docker ps -a -q)
3: 停止容器：
A：优雅的停止：docker stop dockerID
B：直接杀死：docker kill id
4: 查看容器：docker ps
A：获取容器输出信息：docker logs id
5: 进入容器：
A：exec 命令：docker exec -it dockerID ／bin／bash
B：nsenter 工具：可以去查
6: 容器互联：
A：docker run -d -P —name dockerName1 --link dockerName2:dockerName2Alias ubuntu：14.04
B：
7: 启动容器：
A：docker start af（容器 ID）
B：重启：docker restart id
C：启动容器会自动在镜像层外挂载一层可读写层
D：直接从镜像启动容器：docker run -i -t -d -p 8080:8080 --name myname ubuntu:latest
8: 导入导出容器：
A：导出容器：docker export -o xxx.tar dockerID
B：导入容器：docker import xxx.tar - dockerName
三：对于仓库：
1: 创建私有仓库：
A：创建本地／tmp／registry 位置的仓库 docker run -d -p 5000:5000 registry
B：创建制定路径仓库 docker run -d -p 5000:5000 -v ／opt／data／registry：／tmp／registry registry
2: 从国内镜像下载镜像：
A：从时速云下载镜像：docker pull index.tenxcloud.com/docker_library/ 镜像：标签
四：对于数据：
1: 数据卷：
A：容器内数据直接映射到本地主机环境
B：数据卷可以被多个容器共享和重用
C：对数据卷修改立马生效，并且更新数据卷不影响镜像
D：数据卷会一直存在，直到没有容器使用才可以安全卸载
E：挂载数据卷到容器内目录的两种方法：
E1：docker run -d -P --name web -v /webapp ubuntu:14.04 把容器的 webapp 目录映射到主机上
E2：挂载指定目录到容器：docker run -d -P --name web -v /src/webapp（主机目录）:/opt/webapp（容器内目录）:ro ubuntu：14.04 加上：ro 后容器对锁挂在的数据卷内数据就无法修改了
E3：可以挂载单个文件到容器内目录作为数据卷，不推荐
F：删除数据卷：docker rm -v
2: 数据卷容器：
A：使用特定容器维护数据卷
B：操作流程：
B1: 创建数据卷容器：docker run -v ／dbdata —name dbdata ubuntu
B2: 在其他容器使用 —volumes-from dbdata 即可挂载改容器，可以寄连挂在，也可以挂载多个数据卷容器
总结：
本篇博客涵盖了 Docker 自家的所有内容，从 Docker 基础到 Docker 三剑客都有解析，可以作为入门指导。
有了 docker 之后我们就可以随便的安装那些安装过程复杂的软件了，如果你看懂了，请给我一点鼓励哦！
三剑客简介
docker-machine
docker 技术是基于 Linux 内核的 cgroup 技术实现的，那么问题来了，在非 Linux 平台上是否就不能使用 docker 技术了呢？答案是可以的，不过显然需要借助虚拟机去模拟出 Linux 环境来。
docker-machine 就是 docker 公司官方提出的，用于在各种平台上快速创建具有 docker 服务的虚拟机的技术，甚至可以通过指定 driver 来定制虚拟机的实现原理（一般是 virtualbox）。
docker-compose
docker 镜像在创建之后，往往需要自己手动 pull 来获取镜像，然后执行 run 命令来运行。当服务需要用到多种容器，容器之间又产生了各种依赖和连接的时候，部署一个服务的手动操作是令人感到十分厌烦的。
dcoker-compose 技术，就是通过一个.yml 配置文件，将所有的容器的部署方法、文件映射、容器连接等等一系列的配置写在一个配置文件里，最后只需要执行 docker-compose up 命令就会像执行脚本一样的去一个个安装容器并自动部署他们，极大的便利了复杂服务的部署。
docker-swarm
swarm 是基于 docker 平台实现的集群技术，他可以通过几条简单的指令快速的创建一个 docker 集群，接着在集群的共享网络上部署应用，最终实现分布式的服务。
docker-compose 的工作流程
使用 Compose 仅需要三步：
1、用一个定义你的应用程序的环境，Dockerfile 这样它就可以在任何地方再现。
2、定义组成您的应用程序的服务，docker-compose.yml 以便它们可以在隔离的环境中一起运行。
3、运行 docker-compose up 和撰写启动并运行您的整个应用程序。
参考文章：https://docs.docker.com/compose/overview/
docker-compose 安装布署
[root@docker ~]# curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 617 0 617 0 0 396 0 --:--:-- 0:00:01 --:--:-- 397
100 10.3M 100 10.3M 0 0 678k 0 0:00:15 0:00:15 --:--:-- 1876k
[root@docker ~]# chmod +x /usr/local/bin/docker-compose
[root@docker ~]# docker-compose --version
docker-compose version 1.21.2, build a133471docker-compose 管理命令介绍
Compose 具有管理应用程序整个生命周期的命令：
- 启动，停止和重建服务
- 查看正在运行的服务的状态
- 流式传输运行服务的日志输出
- 在服务上运行一次性命令
[root@docker ~]# docker-compose --help
Define and run multi-container applications with Docker.
Usage:
docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
docker-compose -h|--help
Options:
-f, --file FILE Specify an alternate compose file
(default: docker-compose.yml)
-p, --project-name NAME Specify an alternate project name
(default: directory name)
--verbose Show more output
--log-level LEVEL Set log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
--no-ansi Do not print ANSI control characters
-v, --version Print version and exit
-H, --host HOST Daemon socket to connect to
--tls Use TLS; implied by --tlsverify
--tlscacert CA_PATH Trust certs signed only by this CA
--tlscert CLIENT_CERT_PATH Path to TLS certificate file
--tlskey TLS_KEY_PATH Path to TLS key file
--tlsverify Use TLS and verify the remote
--skip-hostname-check Don''t check the daemon''s hostname against the
name specified in the client certificate
--project-directory PATH Specify an alternate working directory
(default: the path of the Compose file)
--compatibility If set, Compose will attempt to convert deploy
keys in v3 files to their non-Swarm equivalent
Commands:
build Build or rebuild services
bundle Generate a Docker bundle from the Compose file
config Validate and view the Compose file
create Create services
down Stop and remove containers, networks, images, and volumes
events Receive real time events from containers
exec Execute a command in a running container
help Get help on a command
images List images
kill Kill containers
logs View output from containers
pause Pause services
port Print the public port for a port binding
ps List containers
pull Pull service images
push Push service images
restart Restart services
rm Remove stopped containers
run Run a one-off command
scale Set number of containers for a service
start Start services
stop Stop services
top Display the running processes
unpause Unpause services
up Create and start containers
version Show the Docker-Compose version informationdocker-compose 运行时是需要指定 service 名称，可以同时指定多个，也可以不指定。不指定时默认就是对配置文件中所有的 service 执行命令。
-f #用于指定配置文件
-p #用于指定项目名称
docker-compose build
用来创建或重新创建服务使用的镜像
docker-compose build service_a
创建一个镜像名叫 service_a
docker-compose kill
用于通过容器发送 SIGKILL 信号强行停止服务
docker-compose logs
显示 service 的日志信息
docker-compose pause/unpause
docker-compose pause #暂停服务
docker-compose unpause #恢复被暂停的服务
docker-compose port
用于查看服务中的端口与物理机的映射关系
docker-compose port nginx_web 80
查看服务中 80 端口映射到物理机上的那个端口
dokcer-compose ps
用于显示当前项目下的容器
注意，此命令与 docker ps 不同作用，此命令会显示停止后的容器（状态为 Exited），只征对某个项目。
docker-compose pull
用于拉取服务依赖的镜像
docker-compose restart
用于重启某个服务中的所有容器
docker-compose restart service_name
只有正在运行的服务可以使用重启命令，停止的服务是不可以重启
docker-compose rm
删除停止的服务（服务里的容器）
-f #强制删除
-v #删除与容器相关的卷（volumes）
docker-compose run
用于在服务中运行一个一次性的命令。这个命令会新建一个容器，它的配置和 srvice 的配置相同。
但两者之间还是有两点不同之处
1、run 指定的命令会直接覆盖掉 service 配置中指定的命令
2、run 命令启动的容器不会创建在 service 配置中指定的端口，如果需要指定使用 --service-ports 指定
docker-compose start/stop
docker-compose start 启动运行某个服务的所有容器
docker-compose stop 停止运行某个服务的所有容器
docker-compose scale
指定某个服务启动的容器个数
[root@docker ~]# docker-compose scale --help
Numbers are specified in the form `service=num` as arguments.
For example:
$ docker-compose scale web=2 worker=3
This command is deprecated. Use the up command with the `--scale` flag
instead.
Usage: scale [options] [SERVICE=NUM...]
Options:
-t, --timeout TIMEOUT Specify a shutdown timeout in seconds.
(default: 10)docker-compose 配置文件实例
一个 docker-compose.yml 的实例文件如下
version: "3"
services:
nginx:
container_name: web-nginx
image: nginx:latest
restart: always
ports:
- 80:80
volumes:
- ./webserver:/webserver
- ./nginx/nginx.conf:/etc/nginx/nginx.conf下面将配置文件做个简单的解释说明
docker-compose的配置文件是一个.yml格式的文件
第一部分
version: "3" #指定语法的版本
第二部分
services: #定义服务
nginx: #服务的名称，-p参数后接服务名称
container_name: web-nginx #容器的名称
image: nginx:latest #镜像
restart: always
ports: #端口映射
- 80:80
第三部分
volumes: #物理机与容器的磁盘映射关系
- ./webserver:/webserver
- ./nginx/nginx.conf:/etc/nginx/nginx.conf整体的目录结构如下
[root@docker docker]# tree ./
./
├── docker-compose.yml
├── nginx
│?? └── nginx.conf
└── webserver
└── index.html
2 directories, 3 files配置文件如下
[root@docker docker]# cat webserver/index.html
welcome to nginx server!!!!!!!!!
[root@docker docker]# cat nginx/nginx.conf
#user nginx;
worker_processes 1;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main ''$remote_addr - $remote_user [$time_local] "$request" ''
''$status $body_bytes_sent "$http_referer" ''
''"$http_user_agent" "$http_x_forwarded_for"'';
access_log /var/log/nginx/access.log main;
client_max_body_size 10m;
sendfile on;
#tcp_nopush on;
keepalive_timeout 65;
#gzip on;
server {
listen 80;
server_name localhost;
location / {
root /webserver;
index index.html index.htm;
}
}
include /etc/nginx/conf.d/*.conf;
}使用命令启动容器
[root@docker docker]# docker-compose up -d
Pulling nginx (nginx:1.14)...
Trying to pull repository docker.io/library/nginx ...
1.14: Pulling from docker.io/library/nginx
f2aa67a397c4: Already exists
6160d1ac49e9: Pull complete
046b67408776: Pull complete
Digest: sha256:85ab7c44474df01422fe8fdbf9c28e497df427e8a67ce6d47ba027c49be4bdc6
Status: Downloaded newer image for docker.io/nginx:1.14
Creating nginx-server ... done
[root@docker docker]# lsof -i :80
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
docker-pr 891 root 4u IPv6 1187080 0t0 TCP *:http (LISTEN)
[root@docker docker]# docker ps |grep nginx
07ca899cc44b nginx:1.14 "nginx -g ''daemon ..." 29 seconds ago Up 28 seconds 0.0.0.0:80->80/tcp nginx-server
#如果启动时不指定里面的服务名称，就是直接启动配置文件里所有的服务浏览器测试是否正常访问
然后我们修改相应的首页文件如下
[root@docker docker]# cat webserver/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>welcome to nginx web stie</title>
</head>
<body>
<h2>欢迎来nginx站点</h2>
</body>
</html>再次打开浏览器查看效果
#是不是非常的方便
使用 Docker-Compose 部署 nginx 代理 Tomcat 集群，实现负载均衡
大体步骤分为以下四步
1、下载所需的文件 tomcat,jdk
2、编写 dockerfile 来布署 tomcat 与 java 环境，生成镜像文件
3、编写 docker-compose.yml 配置文件，启动所有容器服务
4、测试负载均衡
具体配置文件如下
#整个目录结构
[root@master java]# tree ./
./
├── docker-compose.yml
├── etc
│ └── localtime
├── nginx
│ └── nginx.conf
├── tomcat
│ ├── apache-tomcat-8.5.31.tar.gz
│ ├── Dockerfile
│ └── jdk-8u144-linux-x64.tar.gz
└── webserver
├── tomcatA
│ └── index.jsp
└── tomcatB
└── index.jsp
6 directories, 8 files两个测试首页文件
[root@master java]# cat webserver/tomcatA/index.jsp
welcome to tomcat-A server
[root@master java]# cat webserver/tomcatB/index.jsp
welcome to tomcat-B server配置文件
[root@master java]# cat docker-compose.yml
version: "3"
services:
nginx:
image: nginx:1.14
restart: always
ports:
- 80:80
links:
- tomcat1:tomcat1
- tomcat2:tomcat2
volumes:
- ./webserver:/webserver
- ./nginx/nginx.conf:/etc/nginx/nginx.conf
- ./etc/localtime:/etc/localtime
depends_on:
- tomcat1
- tomcat2
tomcat1:
hostname: tomcat1
build: ./tomcat
volumes:
- ./webserver/tomcatA:/usr/local/apache-tomcat-8.5.31/webapps/ROOT
- ./etc/localtime:/etc/localtime
tomcat2:
hostname: tomcat2
build: ./tomcat
volumes:
- ./webserver/tomcatB:/usr/local/apache-tomcat-8.5.31/webapps/ROOT
- ./etc/localtime:/etc/localtime安装 JAVA 环境
[root@master java]# cat tomcat/Dockerfile
FROM centos
ADD jdk-8u144-linux-x64.tar.gz /usr/local
ENV JAVA_HOME /usr/local/jdk1.8.0_144
ADD apache-tomcat-8.5.31.tar.gz /usr/local
EXPOSE 8080
ENTRYPOINT ["/usr/local/apache-tomcat-8.5.31/bin/catalina.sh", "run"]启动所有容器服务
[root@master java]# docker-compose up
Building tomcat1
Step 1/6 : FROM centos
Trying to pull repository docker.io/library/centos ...
latest: Pulling from docker.io/library/centos
7dc0dca2b151: Pull complete
Digest: sha256:b67d21dfe609ddacf404589e04631d90a342921e81c40aeaf3391f6717fa5322
Status: Downloaded newer image for docker.io/centos:latest
---> 49f7960eb7e4
Step 2/6 : ADD jdk-8u144-linux-x64.tar.gz /usr/local
---> 8c9e14062a24
Removing intermediate container a499940235ac
Step 3/6 : ENV JAVA_HOME /usr/local/jdk1.8.0_144
---> Running in cefedfd97f61
---> 12528cd5a517
Removing intermediate container cefedfd97f61
Step 4/6 : ADD apache-tomcat-8.5.31.tar.gz /usr/local
---> 246fa08bea1c
Removing intermediate container a1aaaa2bf0b8
Step 5/6 : EXPOSE 8080
---> Running in 87c4b41f3c1e
---> fd207f27b830
Removing intermediate container 87c4b41f3c1e
Step 6/6 : ENTRYPOINT /usr/local/apache-tomcat-8.5.31/bin/catalina.sh run
---> Running in 9adaed8e3ab9
---> b6fc6d3925f7
Removing intermediate container 9adaed8e3ab9
Successfully built b6fc6d3925f7
WARNING: Image for service tomcat1 was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Building tomcat2
Step 1/6 : FROM centos
---> 49f7960eb7e4
Step 2/6 : ADD jdk-8u144-linux-x64.tar.gz /usr/local
---> Using cache
---> 8c9e14062a24
Step 3/6 : ENV JAVA_HOME /usr/local/jdk1.8.0_144
---> Using cache
---> 12528cd5a517
Step 4/6 : ADD apache-tomcat-8.5.31.tar.gz /usr/local
---> Using cache
---> 246fa08bea1c
Step 5/6 : EXPOSE 8080
---> Using cache
---> fd207f27b830
Step 6/6 : ENTRYPOINT /usr/local/apache-tomcat-8.5.31/bin/catalina.sh run
---> Using cache
---> b6fc6d3925f7
Successfully built b6fc6d3925f7
WARNING: Image for service tomcat2 was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Pulling nginx (nginx:1.14)...
Trying to pull repository docker.io/library/nginx ...
1.14: Pulling from docker.io/library/nginx
f2aa67a397c4: Already exists
6160d1ac49e9: Pull complete
046b67408776: Pull complete
Digest: sha256:85ab7c44474df01422fe8fdbf9c28e497df427e8a67ce6d47ba027c49be4bdc6
Status: Downloaded newer image for docker.io/nginx:1.14
Creating java_tomcat2_1 ... done
Creating java_tomcat1_1 ... done
Creating java_nginx_1 ... done查看启动情况
[root@master java]# docker-compose ps
Name Command State Ports
----------------------------------------------------------------------------
java_nginx_1 nginx -g daemon off; Up 0.0.0.0:80->80/tcp
java_tomcat1_1 /usr/local/apache-tomcat-8 ... Up 8080/tcp
java_tomcat2_1 /usr/local/apache-tomcat-8 ... Up 8080/tcp 检测负载均衡
[root@master java]# curl http://localhost
welcome to tomcat-A server
[root@master java]# curl http://localhost
welcome to tomcat-B server
[root@master java]# curl http://localhost
welcome to tomcat-A server
[root@master java]# curl http://localhost
welcome to tomcat-B server浏览器访问测试负载均衡
查看日志输出信息
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:33 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:34 +0000] "GET / HTTP/1.1" 499 0 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:34 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:36 +0000] "GET / HTTP/1.1" 499 0 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:36 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:36 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:37 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:38 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:14:39 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:30 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:31 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:32 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 172.19.0.1 - - [08/Jun/2018:02:18:33 +0000] "GET / HTTP/1.1" 200 27 "-" "curl/7.29.0" "-"
nginx_1 | 192.168.22.170 - - [08/Jun/2018:02:19:32 +0000] "GET / HTTP/1.1" 200 27 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36" "-"
CentOS7 安装最新版 Docker、compose、swarm、machine
最新版 Docker 安装
1.卸载 Docker
sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-selinux docker-engine-selinux docker-engine
2.安装所需的包
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
3.设置稳定的存储库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
4.可选：启用边缘和测试存储库
sudo yum-config-manager --enable docker-ce-edge
sudo yum-config-manager --enable docker-ce-test
禁用边缘存储库
sudo yum-config-manager --disable docker-ce-edge
5.安装最新版本的 Docker CE
sudo yum install docker-ce
6.启动 Docker
sudo systemctl start docker
7.通过运行 hello-world 映像验证是否已正确安装
sudo docker run hello-world
docker-compose 安装
1.下载最新版本的 Docker Compose (第一次执行提示失败，就多执行几次这个命令试试)
sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
2.对二进制文件应用可执行权限
sudo chmod +x /usr/local/bin/docker-compose
3.测试安装
docker-compose --version
docker-machine 安装
1.下载 Docker Machine 二进制文件并将其解压缩到 PATH (第一次执行提示失败，就多执行几次这个命令试试)
base=https://github.com/docker/machine/releases/download/v0.14.0 && curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine && sudo install /tmp/docker-machine /usr/local/bin/docker-machine
2.通过显示机器版本来检查安装
docker-machine version
搭建 swarm 集群
1.新版 docker 已集成 swarm，无需单独安装
2.使用 docker swarm init 在管理节点初始化一个 Swarm 集群
docker swarm init --advertise-addr 192.168.153.150
# 如果你的 Docker 主机有多个网卡，拥有多个 IP，必须使用 --advertise-addr 指定 IP
# 执行 docker swarm init 命令的节点自动成为管理节点
3.将其他主机作为 管理节点 或 工作节点 加入 swarm 集群（以下命令在待加入节点执行）
docker swarm join --token [MANAGER-TOKEN||WORKER-TOKEN] [MANAGER-IP]:2377
# 示例：docker swarm join --token SWMTKN-1-3pu6hszjas19xyp7ghgosyx9k8atbfcr8p2is99znpy26u2lkl-1awxwuwd3z9j1z3puu7rcgdbx 192.168.153.150:2377
--------------
注意：各机器之间要开启以下通信端口 或 关闭防火墙
# TCP端口2377集群管理端口
# TCP与 UDP端口7946节点之间通讯端口
# TCP与 UDP端口4789 overlay 网络通讯端口
firewall-cmd --zone=public --add-port=2377/tcp --permanent
firewall-cmd --zone=public --add-port=7946/tcp --permanent
firewall-cmd --zone=public --add-port=7946/udp --permanent
firewall-cmd --zone=public --add-port=4789/tcp --permanent
firewall-cmd --zone=public --add-port=4789/udp --permanent
firewall-cmd --reload
关闭防火墙：
sudo systemctl stop firewalld.service
sudo systemctl disable firewalld.service
--------------
4.在管理节点使用 docker node ls 查看集群
docker node ls
5.向集群中添加工作节点，通过以下命令获取加入集群的 WORKER-TOKEN
docker swarm join-token worker
向集群中添加管理节点，通过以下命令获取加入集群的 MANAGER-TOKEN
docker swarm join-token manager
6.退出集群
(1)如果是 manager 先降级为 worker
docker node demote [HOSTNAME || ID] # ID前几位即可
(2)退出集群
docker swarm leave
(3)移除节点
docker node rm [HOSTNAME || ID] # ID前几位即可
# leave后该节点仍将出现在节点列表中，并将 STATUS标记为 down，已不影响 swarm操作；
# 要从列表中删除非活动节点，使用 node rm 命令即可。
使用 swarm+compose 部署集群服务
1.使用 swarm+compose 部署服务
docker stack deploy -c docker-compose.yml [JIQUN-NAME]
2.查看服务
docker stack ls
3.移除服务
docker stack down [JIQUN-NAME]
# 该命令不会移除服务所使用的 数据卷，如果你想移除数据卷请使用 docker volume rm
其他 Docker 常用命令
查看 swarm 集群中的服务：docker service ls
查看 swarm 集群中某个服务的运行状态信息：docker service ps mwp_db
查看 swarm 集群中某个服务的基础详细信息：docker service inspect mwp_db
查看 swarm 集群中某个服务的日志：docker service logs mwp_db
从 swarm 集群中移除某个服务：docker service rm mwp_db
搜索仓库镜像：docker search nginx
查找本地镜像：docker images nginx
查看本地镜像列表：docker images 或 docker image ls
删除本地镜像：docker rmi [IMAGE ID]
强制删除本地镜像：docker rmi -f [IMAGE ID] # 一般先停止相关容器，再 docker rmi [IMAGE ID] 正常删除镜像
列出本机容器 container：docker ps -a 或 docker container ls
删除 container：docker rm [CONTAINER ID] 或 docker container rm [CONTAINER ID]
清理所有处于终止状态的容器：docker container prune
进入后台运行的容器 container：docker exec -it [CONTAINER_NAME || CONTAINER_ID] /bin/sh
# docker exec 进入容器后 exit 不会导致容器停止
创建一个新的容器并运行：docker run --name web2 -d -p 81:80 nginx:v2
停止一个运行中的容器：docker stop [CONTAINER ID || NAMES]
查看所有数据卷：docker volume ls
删除指定数据卷：docker volume rm [VOLUME NAME]
清理所有无主数据卷：docker volume prune
查看 Image 或 Container 的信息：docker inspect [IMAGE || IMAGE ID || CONTAINER ID]
查看 CentOS 系统内核版本：uname -r
使用 Dockerfile 定制镜像：docker build -t nginx:v3 [DOCKERFILE PATH || URL]
# 其中 [DOCKERFILE PATH || URL] 为 Dockerfile 文件所在目录，例：docker build -t nginx:v3 .
更多命令可参考：http://www.runoob.com/docker/docker-command-manual.html
配置 Docker 加速器
参考：https://yeasy.gitbooks.io/docker_practice/install/mirror.html
对于使用 systemd 的系统，在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在则新建该文件）
{
"registry-mirrors": [
"https://registry.docker-cn.com"
]
}
之后重新启动服务。
$ sudo systemctl daemon-reload
$ sudo systemctl restart docker
检查加速器是否生效：docker info
Registry Mirrors:
https://registry.docker-cn.com/
Docker hub 地址：https://hub.docker.com/
Docker 官方文档地址：https://docs.docker.com/
ubuntu16.04 安装最新版 docker、docker-compose、docker-machine
安装前说明:
本文将介绍在 ubuntu16.04 系统下安装和升级 docker、docker-compose、docker-machine。
docker：有两个版本:docker-ce (社区版) 和 docker-ee (企业版)。
笔者这里介绍安装或升级的是最新版 docker-ce(社区版)。
参考官网地址：https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/#os-requirements
docker-compse：可运行和管理多个 docker 容器。
docker-machine：docker 官方提供的 docker 管理工具。可管理多个 docker 主机，可搭建 swarm 集群。
一、docker 安装
1，卸载旧版本 docker
全新安装时，无需执行该步骤
$ sudo apt-get remove docker docker-engine docker.io
2，更新系统软件
$ sudo apt-get update
3，安装依赖包
$ sudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ software-properties-common
4，添加官方密钥
执行该命令时，如遇到长时间没有响应说明网络连接不到 docker 网站，需要使用代 - 理进行。
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
显示 OK, 表示添加成功.
5，添加仓库
$ sudo add-apt-repository \ "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) \ stable"
6，再次更新软件
经实践，这一步不能够省略，我们需要再次把软件更新到最新，否则下一步有可能会报错。
$ sudo apt-get update
7，安装 docker
如果想指定安装某一版本，可使用 sudo apt-get install docker-ce=<VERSION> 命令，把 < VERSION > 替换为具体版本即可。
以下命令没有指定版本，默认就会安装最新版
$ sudo apt-get install docker-ce
8，查看 docker 版本
$ docker -v
显示 “Docker version 17.09.0-ce, build afdb6d4” 字样，表示安装成功。
二、docker-compose 安装
1，下载 docker-compose
$ sudo curl -L https://github.com/docker/compose/releases/download/1.17.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
2，授权
$ sudo chmod +x /usr/local/bin/docker-compose
3，查看版本信息
$ docker-compose --version
显示出版本信息，即安装成功。
三、docker-machine安装
说明：docker-machine 的使用是要基于 virtualBox 的。如果没有安装安装过，请先安装 virtualBox。
1，安装 virtualBox
登录 virtualBox 官网：https://www.virtualbox.org/wiki/Linux_Downloads
找到 "Ubuntu 16.04 ("Xenial") i386 | AMD64" 字样，点击 “AMD64” 进行下载。
下载后，执行以下命令进行安装：
$ sudo dpkg -i virtualbox-5.2_5.2.0-118431_Ubuntu_xenial_amd64.deb
2，下载并安装 docker-machine
$ curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine && chmod +x /tmp/docker-machine && sudo cp /tmp/docker-machine /usr/local/bin/docker-machine
3，查看版本信息
$ docker-machine version
在 VirtualBox 中使用 Docker Machine 管理主机
大家好，今天我们学习在 VirtualBox 中使用 Docker Machine 来创建和管理 Docker 主机。Docker Machine 是一个可以帮助我们在电脑上、在云端、在数据中心内创建 Docker 主机的应用。它为根据用户的配置和需求创建服务器并在其上安装 Docker 和客户端提供了一个轻松的解决方案。这个 API 可以用于在本地主机、或数据中心的虚拟机、或云端的实例提供 Docker 服务。Docker Machine 支持 Windows、OSX 和 Linux，并且是以一个独立的二进制文件包形式安装的。仍然使用（与现有 Docker 工具）相同的接口，我们就可以充分利用已经提供 Docker 基础框架的生态系统。只要一个命令，用户就能快速部署 Docker 容器。
本文列出一些简单的步骤用 Docker Machine 来部署 docker 容器。
1. 安装 Docker Machine
Docker Machine 完美支持所有 Linux 操作系统。首先我们需要从 github 下载最新版本的 Docker Machine，本文使用 curl 作为下载工具，Docker Machine 版本为 0.2.0。
64 位操作系统
# curl -L https://github.com/docker/machine/releases/download/v0.2.0/docker-machine_linux-amd64 > /usr/local/bin/docker-machine32 位操作系统
# curl -L https://github.com/docker/machine/releases/download/v0.2.0/docker-machine_linux-i386 > /usr/local/bin/docker-machine下载完成后，找到 /usr/local/bin 目录下的 docker-machine 文件，让其可以执行：
# chmod +x /usr/local/bin/docker-machine确认是否成功安装了 docker-machine，可以运行下面的命令，它会打印 Docker Machine 的版本信息：
# docker-machine -v运行下面的命令，安装 Docker 客户端，以便于在我们自己的电脑止运行 Docker 命令：
# curl -L https://get.docker.com/builds/linux/x86_64/docker-latest > /usr/local/bin/docker# chmod +x /usr/local/bin/docker
2. 创建 VirtualBox 虚拟机
在 Linux 系统上安装完 Docker Machine 后，接下来我们可以安装 VirtualBox 虚拟机，运行下面的就可以了。--driver virtualbox 选项表示我们要在 VirtualBox 的虚拟机里面部署 docker，最后的参数 “linux” 是虚拟机的名称。这个命令会下载 boot2dockeriso，它是个基于 Tiny Core Linux 的轻量级发行版，自带 Docker 程序，然后 docker-machine 命令会创建一个 VirtualBox 虚拟机（LCTT 译注：当然，我们也可以选择其他的虚拟机软件）来运行这个 boot2docker 系统。
# docker-machine create --driver virtualbox linux测试下有没有成功运行 VirtualBox 和 Docker，运行命令：
# docker-machine ls如果执行成功，我们可以看到在 ACTIVE 那列下面会出现一个星号 “*”。
3. 设置环境变量
现在我们需要让 docker 与 docker-machine 通信，运行 docker-machine env <虚拟机名称> 来实现这个目的。
# eval "$(docker-machine env linux)"# docker ps这个命令会设置 TLS 认证的环境变量，每次重启机器或者重新打开一个会话都需要执行一下这个命令，我们可以看到它的输出内容：
# docker-machine env linuxexport DOCKER_TLS_VERIFY=1export DOCKER_CERT_PATH=/Users/<your username>/.docker/machine/machines/devexport DOCKER_HOST=tcp://192.168.99.100:2376
4. 运行 Docker 容器
完成配置后我们就可以在 VirtualBox 上运行 docker 容器了。测试一下，我们可以运行虚拟机 docker run busybox，并在里面里执行 echo hello world 命令，我们可以看到容器的输出信息。
# docker run busybox echo hello world
5. 拿到 Docker 主机的 IP
我们可以执行下面的命令获取运行 Docker 的主机的 IP 地址。我们可以看到在 Docker 主机的 IP 地址上的任何暴露出来的端口。
# docker-machine ip
6. 管理主机
现在我们可以随心所欲地使用上述的 docker-machine 命令来不断创建主机了。
当你使用完 docker 时，可以运行 docker-machine stop 来停止所有主机，如果想开启所有主机，运行 docker-machine start。
# docker-machine stop# docker-machine start你也可以只停止或开启一台主机：
$ docker-machine stop linux$ docker-machine start linux
总结
最后，我们使用 Docker Machine 成功在 VirtualBox 上创建并管理一台 Docker 主机。Docker Machine 确实能让用户快速地在不同的平台上部署 Docker 主机，就像我们这里部署在 VirtualBox 上一样。这个 virtualbox 驱动可以在本地机器上使用，也可以在数据中心的虚拟机上使用。Docker Machine 驱动除了支持本地的 VirtualBox 之外，还支持远端的 Digital Ocean、AWS、Azure、VMware 以及其它基础设施。
如果你有任何疑问，或者建议，请在评论栏中写出来，我们会不断改进我们的内容。谢谢，祝愉快。
Docker Engine
当人们提到 Docker，一般而言，大家说的是 Docker Engine，如下图：
它是一个 client-server application。
Docker Engine 由三个部分组成：
Docker 进程（Docker Daemon）
REST API：指定了和进程交互的接口
CLI (command line interface)：通过 REST API 和 daemon 通信，诸如：docker run <image>, docker ps...
Docker Machine
Docker Machine 是一种提供管理主机的 工具。常规，你会安装 Docker Machine 在你的本地机器上。
Docker Machine 有自己的命令 client：docker-machine
Docker Engine 则有 client：docker
我们可以使用 Docker Machine 来安装 Docker Engine 在一个或者多个虚拟系统上，这些虚拟系统可以是本地的（比如 Virtualbox 里），也可以是远程的（云）。
privileged 参数
-
$ docker help run -
... -
--privileged=false Give extended privileges to this container -
...
大约在 0.6 版，privileged 被引入 docker。
使用该参数，container 内的 root 拥有真正的 root 权限。
否则，container 内的 root 只是外部的一个普通用户权限。
privileged 启动的容器，可以看到很多 host 上的设备，并且可以执行 mount。
甚至允许你在 docker 容器中启动 docker 容器。
介绍：
docker compose 是 docker 官方推出的一款单机容器编排工具,
和 docker swarm, docker machine 并称为 docker 容器编排三剑客, 虽然其被 k8s 吊打,
但是由于其简单易学在中小规模的集群中还是占有相当的一部分地位的
使用Compose的步骤：
1、定义您的应用程序环境，Dockerfile以便可以在任何地方进行复制
2、定义构成应用程序的服务，docker-compose.yml 以便它们可以在隔离环境中一起运行
3、运行 docker-compose up 和 Compose starts 运行整个应用程序
compose 的特性：
1、单个主机上的多个环境隔离
2、创建容器时保留卷数据
3、仅重新创建已更改的容器
4、变量和在环境之间移动合成
安装：
docker compose 依赖所有的工作依赖于 docker, 在安装 compose 前请确保已在本地或远程主机中安装 docker
二进制安装：
curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
pip安装：
pip install docker-compose
一个简单的例子：
mkdir composetest && cd composetest ＃创建一个专用目录,用于编写和保存 compose 文件
cat app.py #编写一个 flask web 应用作为测试
import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host=''redis'', port=6379) #连接 redis
# 定义函数
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()
# 每访问一次返回的 count 加 1
return ''Hello World! I have been seen {} times.\n''.format(count)
if __name__ == "__main__":
#运行 web 应用
app.run(host="0.0.0.0", debug=True)
cat Dockerfile #编写docker file 文件以便 compose 可以根据 docker file 动态构建镜像
FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install flask redis
CMD ["python", "app.py"]
cat docker-compose.yml #编写 compose 文件定义容器间的关系
version: ''3''
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
redis:
image: "redis:alpine"
docker-compose up #启动 docker compose 定义的 docker 集群
curl http://127.0.0.1:5000/ #访问 Web APP
# 示例来源
# https://docs.docker.com/compose/gettingstarted/#step-5-edit-the-compose-file-to-add-a-bind-mount
docker-compose 命令：
介绍：
1、docker-compose 命令的执行都必须指定或者在当前目录下存在 compose 文件, 且输出的内容都是这个 compose.yml 文件定义的集群内的信息
2、每个集群中可以拥有多个 services, services 由 compose.yml 的 services 定义
选项：
-f 指定 compose 文件路径(可以指定多个)
子命令：
create 创建 compose 集群, 但不启动(已废弃, 使用 up --no-start 代替)
down 停止或删除容器, 网络, 镜像和数据卷
exec 运行容器中的命令或者连接容器
help 查看帮助信息
images 列出 compose 集群所用的镜像
kill kill 掉 compose 集群
logs 获取 compose 集群日志
pause 暂停 compose 集群
ps 列出正在运行的容器
pull 拉取 compose.yml 文件中定义的所有 docker 镜像
push 上传 compose.yml 文件中定义的所有 docker 镜像
restart 重启 compose 集群
rm 删除一个停止的容器或者 compose 集群
run 和 exec 相同
scale 更改 compose 集群内指定的 services 的副本数量
start 启动 compose 集群
stop 停止 compose 集群
top 显示 compose 集群中运行的进程及其状态
unpause 恢复被暂停的 compose 集群
up 创建并启动一个 compose 集群
version 输出 compose 版本使用 Docker Machine、Swarm 和 Compose 进行 Docker 规划
机器 (Machine) 用一个命令就把你从 “零带到 Docker”。它可以让你轻松地部署 Docker 引擎到您的计算机上，云提供商上，以及自己的数据中心。Machine’s blog post 上有更多的信息并提供软件下载。
集群 (Swarm) 是 Docker 容器的本地集群。它将多个 Docker 引擎汇聚到一起组成一个虚拟主机。将 Docker 客户端或第三方工具（例如，Compose，Dokku，Shipyard，Jenkins，the Docker client，等）指向 Swarm, 并将会透明地扩展到多个主机。一个测试版本的 Swarm 已经可用，我们正在努力将其与亚马逊 Web 服务，IBM Bluemix，Joyent，Kubernetes，Mesos 和微软的 Azure。Machine’s blog post 上有更多的信息。
组合 (Compose) 是一种定义和运行包含 Docker 的多容器分布式应用程序。早在十二月，我们就向社区公开了它的设计。基于社区反馈，Compose 是基于 Fig。Fig 是一种在开发环境运行 Docker 的一个工具。 Compose’s blog post 上有更多的信息并提供软件下载。
现在在一起
Docker 引擎对单一容器的应用程序表现良好，使得它们在构建，部署和转移应用程序方面更加的容易。但是我们无时不知道你需要的是能够定义和部署复杂的由多个服务组成的应用程序。如果你现在希望用 Docker 来完成这件事，Docker 引擎还不清楚要做什么。你可能不得不拼凑一些 shell 脚本的东西使它工作。
这不是理想的方案。我们想与你分享一些我们的一些想法， 这些想法是有关如何在分布式的应用中使用 Docker，我们今天发布的工具都要帮助实现这些想法。
我们听说，你想要你的分布式应用程序是：
-
在不同的环境中便携的使用：你可以定义你的应用程序将如何在开发环境运行，那么它们也应该无缝地在测试，准生产环境和生产环境运行。
-
在不同的供应商中便携的使用：你可以在不同的云供应商和自己的服务器之间移动你的应用程序，或跨几个供应商运行它们。
-
可组合的：你可以将你的应用分拆到多个服务。
我们今天发布的工具是一个平台的开始，这个平台将使这一切成为可能。
首先，你使用 Machine 创建已经安装了 Docker 引擎的主机。Machine 可以在您的计算机上，云服务提供商，和 / 或在您自己的数据中心上创建这些主机。
接下来，你将这些 Docker 引擎用 Swarm 汇集到一起。Swarm 将 Docker 引擎连接成一个单一的，虚拟引擎。这有点像运行了很多 Docker 容器的一个非常大的计算机。你不再担心管理服务器–它们都汇集在一起并由一个集群系统为你管理这些资源。
Swarm 带有一个内置的集群系统，但如果你想和现有的正在运行的系统整合，Swarm 将来也会运行在 Mesos 或 Kubernetes 之上。
另外，如果你想把 Swarm 部署到云上，而不是建立自己的 Swarm，为此，我们正和亚马逊 EC2 Container Service，IBM Bluemix Container Service, Joyent Smart Data Center 和微软的 Azure 合作，将他们的产品与 Swarm 整合。
一旦你有了一个 Swarm，你就可以在它上面运行你的应用程序。你用 Compose 来定义你的多容器应用程序（例如，一个 Web 服务器容器连接到一个数据库容器）。Compose 可以在任何可以调用 Docker API 的机器上运行这个应用。在开发阶段，你可以将 Compose 直接运行在你电脑上的的 Docker 主机上。当你需要把你的应用程序放到准生产和生产环境，你可以将 Compose 指向 Swarm 集群。
所以，如果你用 Compose 来定义你的应用程序，你可以在任何环境或供应方上运行它：在你的电脑上，在云上的一个 Swarm，在你自己的数据中心的一个 Swarm，一个运行在 Mesos 或 Kubernetes 之上运行的 Swarm 上。
参与
这种设计仍在完善当中，我们真的希望听到你们的意见。当我们在 Docker 上做了很大开发的时候，我们会把这些变化开放出来以供人们使用。这让我们看到用户如何使用它，这样我们可以快速地迭代开发。并且，因为它是开源的，你可以直接参与它的开发。
Machine, Swarm and Compose 的安装说明以及下载。它们可以作为独立的工具，但如果你敢于冒险的话，你可以将他们安装到一起（尽管这还是处在一个非常实验状态）。请参考有关 Machine+Swarm 以及 Compose+Swarm 的文档。
如果你对软件高层设计有任何的评论，可以发送你的评论到 docker-dev mailing list。项目会把每天完成的开发都更新到 Machine, Swarm 和 Compose 的 GitHub 仓库里去。
如果你就已经使用了一个 Docker1.0 之前的版本，那么你非常适合在这个时候参与这个项目。
了解更多关于 Machine, Swarm and Compose 的信息：
-
beta 版 Machine 公告 和安装指导
-
Swarm beta 版公告 和安装指导
-
Compose 公告和安装指导
-
参与 GitHub 上的项目 Machine, Swarm and Compose
-
在 #docker on Freenode 或 the Docker mailing list 上提问
-
有关 Machine + Swarm + Compose 的 Demo 视频
-
注册参加 关于 Machine, Swarm and Compose 的在线会议
了解更多有关 Docker
-
刚接触 Docker? 试试我们的 10 分钟在线入门培训
-
用一个免费的 Docker Hub 账号，分享 images,automate builds 和更多
-
阅读 Docker Engine 1.5 发布说明
-
订阅 Docker 每周新闻
-
参加即将开始的 Docker 会议
-
报名参加 DockerCon 2015
-
开始给 Docker 做贡献
本文地址：https://www.oschina.net/translate/orchestrating-docker-with-machine-swarm-and-compose
原文地址：https://blog.docker.com/2015/02/orchestrating-docker-with-machine-swarm-and-compose/
关于Docker三剑客之Docker Machine和docker三剑客介绍的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于CentOS 下 Docker 与.netcore (三）之 三剑客之一 Docker-Compose、CentOS 下 Docker 与.netcore (五）之 三剑客之一 Docker-swarm 集群、Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock、docker 三剑客 docker-compose、docker-machine、swarm等相关内容，可以在本站寻找。
本文标签：
