docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into no-toolbox

This commit is contained in:
Usha Mandya 2021-09-27 13:40:52 +01:00 committed by GitHub
parent 969da45317 0502029ad0
commit 7842c95d0c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
72 changed files with 71 additions and 6795 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
_data/toc.yaml
View File

@ -1458,110 +1458,8 @@ manuals:
title: Release notes
- sectiontitle: Superseded products and tools
section:
- sectiontitle: Docker Machine
section:
- path: /machine/
title: Machine overview
- path: /machine/install-machine/
title: Install Machine
- path: /machine/release-notes/
title: Release notes
- path: /machine/get-started/
title: Get started with a local VM
- path: /machine/get-started-cloud/
title: Provision hosts in the cloud
- sectiontitle: Learn by example
section:
- path: /machine/examples/ocean/
title: Provision Digital Ocean Droplets
- path: /machine/examples/aws/
title: Provision AWS EC2 instances
- path: /machine/concepts/
title: Machine concepts and help
- sectiontitle: Machine (docker-machine) CLI
section:
- path: /machine/reference/
title: Machine CLI overview
- path: /machine/completion/
title: Machine command-line completion
- path: /machine/reference/active/
title: active
- path: /machine/reference/config/
title: config
- path: /machine/reference/create/
title: create
- path: /machine/reference/env/
title: env
- path: /machine/reference/help/
title: help
- path: /machine/reference/inspect/
title: inspect
- path: /machine/reference/ip/
title: ip
- path: /machine/reference/kill/
title: kill
- path: /machine/reference/ls/
title: ls
- path: /machine/reference/mount/
title: mount
- path: /machine/reference/provision/
title: provision
- path: /machine/reference/regenerate-certs/
title: regenerate-certs
- path: /machine/reference/restart/
title: restart
- path: /machine/reference/rm/
title: rm
- path: /machine/reference/scp/
title: scp
- path: /machine/reference/ssh/
title: ssh
- path: /machine/reference/start/
title: start
- path: /machine/reference/status/
title: status
- path: /machine/reference/stop/
title: stop
- path: /machine/reference/upgrade/
title: upgrade
- path: /machine/reference/url/
title: url
- sectiontitle: Machine drivers
section:
- path: /machine/drivers/
title: Drivers overview
- path: /machine/drivers/os-base/
title: Driver options and operating system defaults
- path: /machine/drivers/aws/
title: Amazon Web Services
- path: /machine/drivers/digital-ocean/
title: Digital Ocean
- path: /machine/drivers/exoscale/
title: Exoscale
- path: /machine/drivers/generic/
title: Generic
- path: /machine/drivers/gce/
title: Google Compute Engine
- path: /machine/drivers/soft-layer/
title: IBM Softlayer
- path: /machine/drivers/azure/
title: Microsoft Azure
- path: /machine/drivers/hyper-v/
title: Microsoft Hyper-V
- path: /machine/drivers/openstack/
title: OpenStack
- path: /machine/drivers/virtualbox/
title: Oracle VirtualBox
- path: /machine/drivers/rackspace/
title: Rackspace
- path: /machine/drivers/vm-fusion/
title: VMware Fusion
- path: /machine/drivers/vm-cloud/
title: VMware vCloud Air
- path: /machine/drivers/vsphere/
title: VMware vSphere
- path: /machine/migrate-to-machine/
title: Migrate from Boot2Docker to Machine
- path: /machine/
title: Docker Machine (deprecated)
- path: /toolbox/
title: Docker Toolbox (deprecated)
- path: /kitematic/

3
desktop/mac/troubleshoot.md
View File

@ -253,8 +253,7 @@ in the Apple documentation, and Docker Desktop [Mac system requirements](install
* Run the uninstall commands from the menu.
* If `docker` commands aren't working properly or as expected, you may need to
unset some environment variables, to make sure you are not using the legacy
Docker Machine environment in your shell or command window. Unset the
unset some environment variables, to make sure you are not using the deprecated Docker Machine environment in your shell or command window. Unset the
`DOCKER_HOST` environment variable and related variables. If you use bash, use the following command: `unset ${!DOCKER_*}`
* For the `hello-world-nginx` example, Docker Desktop must be running to get to

10
engine/swarm/swarm-tutorial/index.md
View File

@ -33,8 +33,7 @@ To run this tutorial, you need the following:
This tutorial requires three Linux hosts which have Docker installed and can
communicate over a network. These can be physical machines, virtual machines,
Amazon EC2 instances, or hosted in some other way. You can even use Docker Machine
from a Linux, Mac, or Windows host. Check out
Amazon EC2 instances, or hosted in some other way. Check out
[Getting started - Swarms](../../../get-started/swarm-deploy.md#prerequisites)
for one possible set-up for the hosts.
@ -58,8 +57,7 @@ single-node and multi-node swarm scenarios on Linux machines.
Alternatively, install the latest [Docker Desktop for Mac](../../../desktop/mac/index.md) or
[Docker Desktop for Windows](../../../desktop/windows/index.md) application on one
computer. You can test both single-node and multi-node swarm from this computer,
but you need to use Docker Machine to test the multi-node scenarios.
computer. You can test both single-node and multi-node swarm from this computer.
* You can use Docker Desktop for Mac or Windows to test _single-node_ features
of swarm mode, including initializing a swarm with a single node, creating
@ -80,10 +78,6 @@ fixed IP address.
You can run `ifconfig` on Linux or macOS to see a list of the
available network interfaces.
If you are using Docker Machine, you can get the manager IP with either
`docker-machine ls` or `docker-machine ip <MACHINE-NAME>` &#8212; for example,
`docker-machine ip manager1`.
The tutorial uses `manager1` : `192.168.99.100`.
### Open protocols and ports between the hosts

468
machine/AVAILABLE_DRIVER_PLUGINS.md
View File

@ -1,468 +0,0 @@
---
published: false
title: "Machine plugins"
description: "Machine plugins"
keywords: ["Docker, documentation, manual, guide, reference, api"]
---
# Available driver plugins
This document is intended to act as a reference for the available 3rd-party
driver plugins available in the ecosystem beyond the core Machine drivers. If
you have created a Docker Machine driver, we highly encourage you to submit a
pull request adding the relevant information to the list. Submitting your
driver here allows others to discover it and the core Machine team to keep
you informed of upstream changes.
**NOTE**: The linked repositories are not maintained by or formally associated
with Docker Inc. Use 3rd party plugins at your own risk.
<table>
<thead>
<tr>
<th>Name</th>
<th>Repository</th>
<th>Maintainer GitHub Handle</th>
<th>Maintainer Email</th>
</tr>
</thead>
<tbody>
<tr>
<td>1&amp;1 Cloud Server</td>
<td>
<a href=
"https://github.com/1and1/docker-machine-driver-oneandone">https://github.com/1and1/docker-machine-driver-oneandone</a>
</td>
<td>
<a href="https://github.com/stackpointcloud">StackPointCloud, Inc.</a>
</td>
<td>
<a href="mailto:sdk@1and1.com">sdk@1and1.com</a>
</td>
</tr>
<tr>
<td>Aliyun ECS</td>
<td>
<a href=
"https://github.com/denverdino/docker-machine-driver-aliyunecs">https://github.com/denverdino/docker-machine-driver-aliyunecs</a>
</td>
<td>
<a href="https://github.com/denverdino">denverdino</a><br>
<a href="https://github.com/menglingwei">menglingwei</a>
</td>
<td>
<a href="mailto:denverdino@gmail.com">denverdino@gmail.com</a><br>
<a href="mailto:v.con@qq.com">v.con@qq.com</a>
</td>
</tr>
<tr>
<td>Amazon Cloud Formation</td>
<td>
<a href=
"https://github.com/jeffellin/machine-cloudformation">https://github.com/jeffellin/machine-cloudformation</a>
</td>
<td>
<a href="https://github.com/jeffellin">Jeff Ellin</a>
</td>
<td>
<a href="mailto:acf@ellin.com">acf@ellin.com</a>
</td>
</tr>
<tr>
<td>Aruba Cloud</td>
<td>
<a href=
"https://github.com/Arubacloud/docker-machine-driver-arubacloud">https://github.com/Arubacloud/docker-machine-driver-arubacloud</a>
</td>
<td>
<a href="https://github.com/nicolaeusebi">Nicola Eusebi</a>
<a href="https://github.com/Arubacloud">Aruba Cloud</a>
</td>
<td>
<a href="mailto:cloudsdk@staff.aruba.it">cloudsdk@staff.aruba.it</a>
</td>
</tr>
<tr>
<td>BrightBox</td>
<td>
<a href=
"https://github.com/brightbox/docker-machine-driver-brightbox">https://github.com/brightbox/docker-machine-driver-brightbox</a>
</td>
<td>
<a href="https://github.com/NeilW">NeilW</a>
</td>
<td>
<a href="mailto:neil@aldur.co.uk">neil@aldur.co.uk</a>
</td>
</tr>
<tr>
<td>CenturyLink Cloud</td>
<td>
<a href=
"https://github.com/CenturyLinkCloud/docker-machine-driver-clc">https://github.com/CenturyLinkCloud/docker-machine-driver-clc</a>
</td>
<td>
<a href="https://github.com/ack">ack</a>
</td>
<td>
<a href="mailto:albert.choi@ctl.io">albert.choi@ctl.io</a>
</td>
</tr>
<tr>
<td>Citrix XenServer</td>
<td>
<a href=
"https://github.com/xenserver/docker-machine-driver-xenserver">https://github.com/xenserver/docker-machine-driver-xenserver</a>
</td>
<td>
<a href="https://github.com/robertbreker">robertbreker</a><br>
<a href="https://github.com/phusl">phusl</a>
</td>
<td>
<a href=
"mailto:robert.breker@citrix.com">robert.breker@citrix.com</a><br>
<a href="mailto:phus.lu@citrix.com">phus.lu@citrix.com</a>
</td>
</tr>
<tr>
<td>cloud.ca</td>
<td>
<a href=
"https://github.com/cloud-ca/docker-machine-driver-cloudca">https://github.com/cloud-ca/docker-machine-driver-cloudca</a>
</td>
<td>
<a href="https://github.com/cloud-ca">cloud.ca</a>
</td>
<td>
<a href="mailto:cloudmc@cloudops.com">cloudmc@cloudops.com</a>
</td>
</tr>
<tr>
<td>CloudSigma</td>
<td>
<a href=
"https://github.com/cloudsigma/docker-machine-driver-cloudsigma">https://github.com/cloudsigma/docker-machine-driver-cloudsigma</a>
</td>
<td>
<a href="https://github.com/cloudsigma">CloudSigma</a>
</td>
<td>
<a href="mailto:bogdan.despotov@cloudsigma.com">bogdan.despotov@cloudsigma.com</a>
</td>
</tr>
<tr>
<td>Docker-In-Docker</td>
<td>
<a href=
"https://github.com/nathanleclaire/docker-machine-driver-dind">https://github.com/nathanleclaire/docker-machine-driver-dind</a>
</td>
<td>
<a href="https://github.com/nathanleclaire">nathanleclaire</a>
</td>
<td>
<a href=
"mailto:nathan.leclaire@gmail.com">nathan.leclaire@gmail.com</a>
</td>
</tr>
<tr>
<td>GleSYS Internet Services</td>
<td>
<a href="https://github.com/glesys/docker-machine-driver-glesys">
https://github.com/glesys/docker-machine-driver-glesys
</a>
</td>
<td>
<a href="https://github.com/glesys">GleSYS</a>
</td>
<td>
<a href="mailto:support@glesys.com">support@glesys.com</a>
</td>
</tr>
<tr>
<td>GoDaddy Cloud Servers</td>
<td>
<a href=
"https://github.com/godaddy/docker-machine-godaddy">https://github.com/godaddy/docker-machine-godaddy</a>
</td>
<td>
<a href="https://github.com/aka-bo">aka-bo</a>
</td>
<td>
<a href="mailto:bo.thompson@gmail.com">bo.thompson@gmail.com</a>
</td>
</tr>
<tr>
<td>Hetzner Cloud</td>
<td>
<a href=
"https://github.com/JonasProgrammer/docker-machine-driver-hetzner">https://github.com/JonasProgrammer/docker-machine-driver-hetzner</a>
</td>
<td>
<a href="https://github.com/JonasProgrammer">JonasProgrammer</a><br>
<a href="https://github.com/monochromata">monochromata</a><br>
<a href="https://github.com/mxschmitt">mxschmitt</a>
</td>
<td>
<a href="mailto:jonass@dev.jsje.de">jonass@dev.jsje.de</a><br>
<a href="mailto:sl@monochromata.de">sl@monochromata.de</a><br>
<a href="mailto:max@schmitt.mx">max@schmitt.mx</a>
</td>
</tr>
<tr>
<td>HPE OneView</td>
<td>
<a href=
"https://github.com/HewlettPackard/docker-machine-oneview">https://github.com/HewlettPackard/docker-machine-oneview</a>
</td>
<td>
<a href="https://github.com/wenlock">wenlock</a><br>
<a href="https://github.com/miqui">miqui</a>
</td>
<td>
<a href="mailto:wenlock@hpe.com">wenlock@hpe.com</a><br>
<a href="mailto:miqui@hpe.com">miqui@hpe.com</a>
</td>
</tr>
<tr>
<td>Kamatera</td>
<td>
<a href=
"https://github.com/OriHoch/docker-machine-driver-kamatera">https://github.com/OriHoch/docker-machine-driver-kamatera</a>
</td>
<td>
<a href="https://github.com/OriHoch">OriHoch</a>
</td>
<td>
<a href=
"mailto:support@kamatera.com">support@kamatera.com</a>
</td>
</tr>
<tr>
<td>KVM</td>
<td>
<a href=
"https://github.com/dhiltgen/docker-machine-kvm">https://github.com/dhiltgen/docker-machine-kvm</a>
</td>
<td>
<a href="https://github.com/dhiltgen">dhiltgen</a>
</td>
<td>
<a href=
"mailto:daniel.hiltgen@docker.com">daniel.hiltgen@docker.com</a>
</td>
</tr>
<tr>
<td>Linode</td>
<td>
<a href="https://github.com/linode/docker-machine-driver-linode">https://github.com/linode/docker-machine-driver-linode</a>
</td>
<td>
<a href="https://github.com/linode">Linode</a>
</td>
<td>
<a href="mailto:developers@linode.com">developers@linode.com</a>
</td>
</tr>
<tr>
<td>NTT Communications Enterprise Cloud</td>
<td>
<a href="https://github.com/mittz/docker-machine-driver-ecl">
https://github.com/mittz/docker-machine-driver-ecl
</a>
</td>
<td>
<a href="https://github.com/mittz">Hayahito Kawamitsu</a>
</td>
<td>
<a href="mailto:halation3@gmail.com">halation3@gmail.com</a>
</td>
</tr>
<tr>
<td>OpenNebula</td>
<td>
<a href=
"https://github.com/OpenNebula/docker-machine-opennebula">https://github.com/OpenNebula/docker-machine-opennebula</a>
</td>
<td>
<a href="https://github.com/jmelis">jmelis</a>
</td>
<td>
<a href="mailto:jmelis@opennebula.org">jmelis@opennebula.org</a>
</td>
</tr>
<tr>
<td>OVH Cloud</td>
<td>
<a href=
"https://github.com/yadutaf/docker-machine-driver-ovh">https://github.com/yadutaf/docker-machine-driver-ovh</a>
</td>
<td>
<a href="https://github.com/yadutaf">yadutaf</a>
</td>
<td>
<a href="mailto:jt@yadutaf.fr">jt@yadutaf.fr</a>
</td>
</tr>
<tr>
<td>Packet</td>
<td>
<a href=
"https://github.com/packethost/docker-machine-driver-packet">https://github.com/packethost/docker-machine-driver-packet</a>
</td>
<td>
<a href="https://github.com/crunchywelch">crunchywelch</a>
</td>
<td>
<a href="mailto:welch@packet.net">welch@packet.net</a>
</td>
</tr>
<tr>
<td>ProfitBricks</td>
<td>
<a href=
"https://github.com/profitbricks/docker-machine-driver-profitbricks">https://github.com/profitbricks/docker-machine-driver-profitbricks</a>
</td>
<td>
<a href="https://github.com/stackpointcloud">StackPointCloud, Inc.</a>
</td>
<td>
<a href="mailto:sdk@profitbricks.com">sdk@profitbricks.com</a>
</td>
</tr>
<tr>
<td>Parallels Desktop for Mac</td>
<td>
<a href=
"https://github.com/Parallels/docker-machine-parallels">https://github.com/Parallels/docker-machine-parallels</a>
</td>
<td>
<a href="https://github.com/legal90">legal90</a>
</td>
<td>
<a href="mailto:legal90@gmail.com">legal90@gmail.com</a>
</td>
</tr>
<tr>
<td>RackHD</td>
<td>
<a href=
"https://github.com/emccode/docker-machine-rackhd">https://github.com/emccode/docker-machine-rackhd</a>
</td>
<td>
<a href="https://github.com/kacole2">kacole2</a>
</td>
<td>
<a href="mailto:kendrick.coleman@emc.com">kendrick.coleman@emc.com</a>
</td>
</tr>
<tr>
<td>SAKURA CLOUD</td>
<td>
<a href=
"https://github.com/yamamoto-febc/docker-machine-sakuracloud">https://github.com/yamamoto-febc/docker-machine-sakuracloud</a>
</td>
<td>
<a href="https://github.com/yamamoto-febc">yamamoto-febc</a>
</td>
<td>
<a href="mailto:yamamoto.febc@gmail.com">yamamoto.febc@gmail.com</a>
</td>
</tr>
<tr>
<td>Scaleway</td>
<td>
<a href=
"https://github.com/scaleway/docker-machine-driver-scaleway">https://github.com/scaleway/docker-machine-driver-scaleway</a>
</td>
<td>
<a href="https://github.com/scaleway">scaleway</a>
</td>
<td>
<a href="mailto:opensource@scaleway.com">opensource@scaleway.com</a>
</td>
</tr>
<tr>
<td>Skytap</td>
<td>
<a href=
"https://github.com/skytap/docker-machine-driver-skytap">https://github.com/skytap/docker-machine-driver-skytap</a>
</td>
<td>
<a href="https://github.com/dantjones">dantjones</a>
</td>
<td>
<a href="mailto:djones@skytap.com">djones@skytap.com</a>
</td>
</tr>
<tr>
<td>Ubiquity Hosting</td>
<td>
<a href=
"https://github.com/ubiquityhosting/docker-machine-driver-ubiquity">https://github.com/ubiquityhosting/docker-machine-driver-ubiquity</a>
</td>
<td>
<a href="https://github.com/justacan">Justin Canington</a><br>
<a href="https://github.com/andrew-ayers">Andrew Ayers</a>
</td>
<td>
<a href=
"mailto:justin.canington@nobistech.net">justin.canington@nobistech.net</a><br>
<a href=
"mailto:andrew.ayers@nobistech.net">andrew.ayers@nobistech.net</a>
</td>
</tr>
<tr>
<td>UCloud</td>
<td>
<a href=
"https://github.com/ucloud/docker-machine-ucloud">https://github.com/ucloud/docker-machine-ucloud</a>
</td>
<td>
<a href="https://github.com/xiaohui">xiaohui</a>
</td>
<td>
<a href="mailto:xiaohui.zju@gmail.com">xiaohui.zju@gmail.com</a>
</td>
</tr>
<tr>
<td>VMWare Workstation</td>
<td>
<a href=
"https://github.com/pecigonzalo/docker-machine-vmwareworkstation">https://github.com/pecigonzalo/docker-machine-vmwareworkstation</a>
</td>
<td>
<a href="https://github.com/pecigonzalo">pecigonzalo</a>
</td>
<td>
<a href="mailto:pecigonzalo@outlook.com">pecigonzalo@outlook.com</a>
</td>
</tr>
<tr>
<td>VULTR</td>
<td>
<a href=
"https://github.com/janeczku/docker-machine-vultr">https://github.com/janeczku/docker-machine-vultr</a>
</td>
<td>
<a href="https://github.com/janeczku">janeczku</a>
</td>
<td>
<a href="mailto:jb@festplatte.eu.org">jb@festplatte.eu.org</a>
</td>
</tr>
<tr>
<td>xhyve</td>
<td>
<a href=
"https://github.com/zchee/docker-machine-driver-xhyve">https://github.com/zchee/docker-machine-driver-xhyve</a>
</td>
<td>
<a href="https://github.com/zchee">zchee</a>
</td>
<td>
<a href="mailto:zchee.io@gmail.com">zchee.io@gmail.com</a>
</td>
</tr>
</tbody>
</table>

142
machine/DRIVER_SPEC.md
View File

@ -1,142 +0,0 @@
---
description: machine
keywords: machine, orchestration, install, installation, docker, documentation
published: false
title: Machine driver specification v1
---
This is the standard configuration and specification for version 1 drivers.
Along with defining how a driver should provision instances, the standard
also discusses behavior and operations Machine expects.
# Requirements
The following are required for a driver to be included as a supported driver
for Docker Machine.
## Base Operating System
The provider must offer a base operating system supported by the Docker Engine.
Currently Machine requires Ubuntu for non-Boot2Docker machines.
## API Access
We prefer accessing the provider service via HTTP APIs and strongly recommend
using those over external executables. For example, using the Amazon EC2 API
instead of the EC2 command line tools. If in doubt, contact a project
maintainer.
## SSH
The provider must offer SSH access to control the instance. This does not
have to be public, but must offer it as Machine relies on SSH for system
level maintenance.
# Provider Operations
The following instance operations should be supported by the provider.
## Create
`Create` launches a new instance and make sure it is ready for provisioning.
This includes setting up the instance with the proper SSH keys and making
sure SSH is available including any access control (firewall). This should
return an error on failure.
## Remove
`Remove` removes the instance from the provider. This should remove the
instance and any associated services or artifacts that were created as part
of the instance including keys and access groups. This should return an
error on failure.
## Start
`Start` starts a stopped instance. This should ensure the instance is
ready for operations such as SSH and Docker. This should return an error on
failure.
## Stop
`Stop` stops a running instance. This should ensure the instance is
stopped and return an error on failure.
## Kill
`Kill` forcibly stops a running instance. This should ensure the instance
is stopped and return an error on failure.
## Restart
`Restart` restarts a running instance. This should ensure the instance
is ready for operations such as SSH and Docker. This should return an error
on failure.
## Status
`Status` returns the state of the instance. This should return the
current state of the instance (running, stopped, error, etc). This should
return an error on failure.
# Testing
Testing is strongly recommended for drivers. Unit tests are preferred as well
as inclusion into the [integration tests](https://github.com/docker/machine#integration-tests).
# Maintaining
Driver plugin maintainers are encouraged to host their own repo and distribute
the driver plugins as executables.
# Implementation
The following describes what is needed to create a Machine Driver. The driver
interface has methods that must be implemented for all drivers. These include
operations such as `Create`, `Remove`, `Start`, `Stop` etc.
For details see the [Driver Interface](https://github.com/docker/machine/blob/master/drivers/drivers.go#L24).
To provide this functionality, you should embed the `drivers.BaseDriver` struct, similar to the following:
type Driver struct {
*drivers.BaseDriver
DriverSpecificField string
}
Each driver must then use an `init` func to "register" the driver:
func init() {
drivers.Register("drivername", &drivers.RegisteredDriver{
New: NewDriver,
GetCreateFlags: GetCreateFlags,
})
}
## Flags
Driver flags are used for provider specific customizations. To add flags, use
a `GetCreateFlags` func. For example:
func GetCreateFlags() []cli.Flag {
return []cli.Flag{
cli.StringFlag{
EnvVar: "DRIVERNAME_TOKEN",
Name: "drivername-token",
Usage: "Provider access token",
},
cli.StringFlag{
EnvVar: "DRIVERNAME_IMAGE",
Name: "drivername-image",
Usage: "Provider Image",
Value: "ubuntu-14-04-x64",
},
}
}
## Examples
You can reference the existing [Drivers](https://github.com/docker/machine/tree/master/drivers)
as well.

43
machine/RELEASE.md
View File

@ -1,43 +0,0 @@
---
published: false
---
# Docker Machine Release Process
The Docker Machine release process is fairly straightforward and as many steps
have been taken as possible to make it automated, but there is a procedure and
several "checklist items" which should be documented. This document is intended
to cover the current Docker Machine release process. It is written for Docker
Machine core maintainers who might find themselves performing a release.
0. The new version of `azure` driver released in 0.7.0 is not backwards compatible
and therefore errors out with a message saying the new driver is unsupported with
the new version. The commit 7b961604 should be undone prior to 0.8.0 release and
this notice must be removed from `docs/RELEASE.md`.
1. **Get a GITHUB_TOKEN** Check that you have a proper `GITHUB_TOKEN`. This
token needs only to have the `repo` scope. The token can be created on github
in the settings > Personal Access Token menu.
2. **Run the release script** At the root of the project, run the following
command `GITHUB_TOKEN=XXXX script/release.sh X.Y.Z` where `XXXX` is the
value of the GITHUB_TOKEN generated, `X.Y.Z` the version to release
( Explicitly excluding the 'v' prefix, the script takes care of it.). As of
now, this version number must match the content of `version/version.go`. The
script has been built to be as resilient as possible, cleaning everything
it does along its way if necessary. You can run it many times in a row,
fixing the various bits along the way.
3. **Update the changelog on github** -- The script generated a list of all
commits since last release. You need to edit this manually, getting rid of
non critical details, and putting emphasis to what need our users attention.
4. **Update the CHANGELOG.md** -- Add the same notes from the previous step to
the `CHANGELOG.md` file in the repository.
5. **Update the Documentation** -- Ensure that the `docs` branch on GitHub
(which the Docker docs team uses to deploy from) is up to date with the
changes to be deployed from the release branch / master. Make sure to
update `docs/install-machine.md` to have the correct version as well.
6. **Verify the Installation** -- Copy and paste the suggested commands in the
installation notes to ensure that they work properly. Best of all, grab an
(uninvolved) buddy and have them try it. `docker-machine -v` should give
them the released version once they have run the install commands.
7. (Optional) **Drink a Glass of Wine** -- You've worked hard on this release.
You deserve it. For wine suggestions, please consult your friendly
neighborhood sommelier.

79
machine/completion.md
View File

@ -1,79 +0,0 @@
---
description: Install Machine command-line completion
keywords: machine, docker, orchestration, cli, reference
title: Command-line completion
---
Docker Machine comes with [command completion](https://en.wikipedia.org/wiki/Command-line_completion)
for the bash and zsh shell.
## Installing Command Completion
### Bash
Make sure bash completion is installed. If you are using a current version of
Linux in a non-minimal installation, bash completion should be available.
On a Mac, install with `brew install bash-completion`.
Place the completion script in `/etc/bash_completion.d/` as follows:
* On a Mac:
```console
$ sudo curl -L https://raw.githubusercontent.com/docker/machine/v{{site.machine_version}}/contrib/completion/bash/docker-machine.bash -o `brew --prefix`/etc/bash_completion.d/docker-machine
```
* On a standard Linux installation:
```console
$ sudo curl -L https://raw.githubusercontent.com/docker/machine/v{{site.machine_version}}/contrib/completion/bash/docker-machine.bash -o /etc/bash_completion.d/docker-machine
```
Completion is available upon next login.
### Zsh
Place the completion script in a `completion` directory within the ZSH
configuration directory, such as `~/.zsh/completion/`.
```console
$ mkdir -p ~/.zsh/completion
$ curl -L https://raw.githubusercontent.com/docker/machine/v{{site.machine_version}}/contrib/completion/zsh/_docker-machine > ~/.zsh/completion/_docker-machine
```
Include the directory in your `$fpath`, by adding a line like the following to the
`~/.zshrc` configuration file.
```shell
fpath=(~/.zsh/completion $fpath)
```
Make sure `compinit` is loaded or do it by adding in `~/.zshrc`:
```shell
autoload -Uz compinit && compinit -i
```
Then reload your shell:
```shell
exec $SHELL -l
```
## Available completions
Depending on what you typed on the command line so far, it completes:
- commands and their options
- container IDs and names
- image repositories and image tags
- file paths
## Where to go next
* [Get started with a local VM](get-started.md)
* [Machine command-line reference](reference/index.md)
* [Machine drivers](drivers/index.md)
* [Machine concepts and help](concepts.md)

105
machine/concepts.md
View File

@ -1,105 +0,0 @@
---
description: Understand concepts for Docker Machine, including drivers, base OS, IP addresses, environment variables
keywords: docker, machine, amazonec2, azure, digitalocean, google, openstack, rackspace, softlayer, virtualbox, vmwarefusion, vmwarevcloudair, vmwarevsphere, exoscale
title: Machine concepts and getting help
---
Docker Machine allows you to provision Docker machines in a variety of environments, including virtual machines that reside on your local system, on cloud providers, or on bare metal servers (physical computers). Docker Machine creates a Docker host, and you use the Docker Engine client as needed to build images and create containers on the host.
## Drivers for creating machines
To create a virtual machine, you supply Docker Machine with the name of the driver you want to use. The driver determines where the virtual machine is created. For example, on a local Mac or Windows system, the driver is typically Oracle VirtualBox. For provisioning physical machines, a generic driver is provided. For cloud providers, Docker Machine supports drivers such as AWS, Microsoft Azure, DigitalOcean, and many more. The Docker Machine reference includes a complete [list of supported drivers](drivers/index.md).
## Default base operating systems for local and cloud hosts
Since Docker runs on Linux, each VM that Docker Machine provisions relies on a
base operating system. For convenience, there are default base operating
systems. For the Oracle Virtual Box driver, this base operating system
is [boot2docker](https://github.com/boot2docker/boot2docker). For drivers used
to connect to cloud providers, the base operating system is Ubuntu 12.04+. You
can change this default when you create a machine. The Docker Machine reference
includes a complete [list of supported operating systems](drivers/os-base.md).
## IP addresses for Docker hosts
For each machine you create, the Docker host address is the IP address of the
Linux VM. This address is assigned by the `docker-machine create` subcommand.
You use the `docker-machine ls` command to list the machines you have created.
The `docker-machine ip <machine-name>` command returns a specific host's IP
address.
## Configuring CLI environment variables for a Docker host
Before you can run a `docker` command on a machine, you need to configure your
command-line to point to that machine. The `docker-machine env <machine-name>`
subcommand outputs the configuration command you should use.
For a complete list of `docker-machine` subcommands, see the
[Docker Machine subcommand reference](reference/help.md).
## Custom root Certificate Authority for Registry
if your registry is signed by a custom root Certificate Authority and it is
not registered with Docker Engine, you may see the following error message:
```none
x509: certificate signed by unknown authority
```
As discussed in the
[Docker Engine documentation](../engine/security/certificates.md#understand-the-configuration)
place the certificates in `/etc/docker/certs.d/hostname/ca.crt`
where `hostname` is your Registry server's hostname.
```console
docker-machine scp certfile default:ca.crt
docker-machine ssh default
sudo mv ~/ca.crt /etc/docker/certs.d/hostname/ca.crt
exit
docker-machine restart
```
## Crash reporting
Provisioning a host is a complex matter that can fail for a lot of reasons. Your
workstation may have a wide variety of shell, network configuration, VPN, proxy
or firewall issues. There are also reasons from the other end of the chain:
your cloud provider or the network in between.
To help `docker-machine` be as stable as possible, we added a monitoring of
crashes whenever you try to `create` or `upgrade` a host. This sends, over
HTTPS, to Bugsnag some information about your `docker-machine` version, build,
OS, ARCH, the path to your current shell and, the history of the last command as
you could see it with a `--debug` option. This data is sent to help us pinpoint
recurring issues with `docker-machine` and is only transmitted in the case
of a crash of `docker-machine`.
To opt out of error reporting, create a `no-error-report`
file in your `$HOME/.docker/machine` directory:
$ mkdir -p ~/.docker/machine && touch ~/.docker/machine/no-error-report
The file doesn't need to have any contents.
## Getting help
Docker Machine is still in its infancy and under active development. If you need
help, would like to contribute, or simply want to talk about the project with
like-minded individuals, we have a number of open channels for communication.
- To report bugs or file feature requests, use the
[issue tracker on Github](https://github.com/docker/machine/issues).
- To talk about the project with people in real time, join the
`#docker-machine` channel on IRC.
- To contribute code or documentation changes,
[submit a pull request on Github](https://github.com/docker/machine/pulls).
For more information and resources, visit
[our help page](../opensource/ways.md).
## Where to go next
- Create and run a Docker host on your [local system using VirtualBox](get-started.md)
- Provision multiple Docker hosts [on your cloud provider](get-started-cloud.md)
- [Docker Machine driver reference](drivers/index.md){: target="_blank" rel="noopener" class="_"}
- [Docker Machine subcommand reference](reference/help.md){: target="_blank" rel="noopener" class="_"}

180
machine/drivers/aws.md
View File

@ -1,180 +0,0 @@
---
description: Amazon Web Services driver for machine
keywords: machine, Amazon Web Services, driver
title: Amazon Web Services
---
Create machines on [Amazon Web Services](https://aws.amazon.com).
To create machines on [Amazon Web Services](https://aws.amazon.com), you must supply two parameters: the AWS Access Key ID and the AWS Secret Access Key.
## Configuring credentials
Before using the amazonec2 driver, ensure that you've configured credentials.
### AWS credential file
One way to configure credentials is to use the standard credential file for Amazon AWS `~/.aws/credentials` file, which might look like:
[default]
aws_access_key_id = AKID1234567890
aws_secret_access_key = MY-SECRET-KEY
On Mac OS or various flavors of Linux you can install the [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) (`aws cli`) in the terminal and use the `aws configure` command which guides you through the creation of the credentials file.
This is the simplest method, you can then create a new machine with:
$ docker-machine create --driver amazonec2 aws01
### Command line flags
Alternatively, you can use the flags `--amazonec2-access-key` and `--amazonec2-secret-key` on the command line:
$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******* aws01
### Environment variables
You can use environment variables:
$ export AWS_ACCESS_KEY_ID=AKID1234567890
$ export AWS_SECRET_ACCESS_KEY=MY-SECRET-KEY
$ docker-machine create --driver amazonec2 aws01
## Options
- `--amazonec2-access-key`: Your access key ID for the Amazon Web Services API.
- `--amazonec2-ami`: The AMI ID of the instance to use.
- `--amazonec2-block-duration-minutes`: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360).
- `--amazonec2-device-name`: The root device name of the instance.
- `--amazonec2-endpoint`: Optional endpoint URL (hostname only or a fully qualified URI).
- `--amazonec2-iam-instance-profile`: The AWS IAM role name to be used as the instance profile.
- `--amazonec2-insecure-transport`: Disable SSL when sending requests.
- `--amazonec2-instance-type`: The instance type to run.
- `--amazonec2-keypair-name`: AWS keypair to use; requires `--amazonec2-ssh-keypath`.
- `--amazonec2-monitoring`: Enable CloudWatch Monitoring.
- `--amazonec2-open-port`: Make the specified port number accessible from the Internet.
- `--amazonec2-private-address-only`: Use the private IP address only.
- `--amazonec2-region`: The region to use when launching the instance.
- `--amazonec2-request-spot-instance`: Use spot instances.
- `--amazonec2-retries`: Set retry count for recoverable failures (use `-1` to disable).
- `--amazonec2-root-size`: The root disk size of the instance (in GB).
- `--amazonec2-secret-key`: Your secret access key for the Amazon Web Services API.
- `--amazonec2-security-group`: AWS VPC security group name.
- `--amazonec2-security-group-readonly`: Skip adding default rules to security groups.
- `--amazonec2-session-token`: Your session token for the Amazon Web Services API.
- `--amazonec2-spot-price`: Spot instance bid price in dollars. Requires the `--amazonec2-request-spot-instance` flag.
- `--amazonec2-ssh-keypath`: Path to private key file to use for instance. Requires a matching public key with `.pub` extension to exist.
- `--amazonec2-ssh-user`: The SSH login username, which must match the default SSH user set in the AMI being used.
- `--amazonec2-subnet-id`: AWS VPC subnet ID.
- `--amazonec2-tags`: A comma-separated list of AWS extra tag key-value pairs. For example, `key1,value1,key2,value2`.
- `--amazonec2-use-ebs-optimized-instance`: Create an EBS Optimized Instance. Instance type must support it.
- `--amazonec2-use-private-address`: Use the private IP address for docker-machine, but still create a public IP address.
- `--amazonec2-userdata`: Path to file with cloud-init user data.
- `--amazonec2-volume-type`: The Amazon EBS volume type to be attached to the instance.
- `--amazonec2-vpc-id`: Your VPC ID to launch the instance in.
- `--amazonec2-zone`: The AWS zone to launch the instance in (one of a,b,c,d, and e).
#### Environment variables and default values:
| CLI option | Environment variable | Default |
|:-----------------------------------------|:------------------------------|:-----------------|
| `--amazonec2-access-key` | `AWS_ACCESS_KEY_ID` | - |
| `--amazonec2-ami` | `AWS_AMI` | `ami-c60b90d1` |
| `--amazonec2-block-duration-minutes` | - | - |
| `--amazonec2-device-name` | `AWS_DEVICE_NAME` | `/dev/sda1` |
| `--amazonec2-endpoint` | `AWS_ENDPOINT` | - |
| `--amazonec2-iam-instance-profile` | `AWS_INSTANCE_PROFILE` | - |
| `--amazonec2-insecure-transport` | `AWS_INSECURE_TRANSPORT` | - |
| `--amazonec2-instance-type` | `AWS_INSTANCE_TYPE` | `t2.micro` |
| `--amazonec2-keypair-name` | `AWS_KEYPAIR_NAME` | - |
| `--amazonec2-monitoring` | - | `false` |
| `--amazonec2-open-port` | - | - |
| `--amazonec2-private-address-only` | - | `false` |
| `--amazonec2-region` | `AWS_DEFAULT_REGION` | `us-east-1` |
| `--amazonec2-request-spot-instance` | - | `false` |
| `--amazonec2-retries` | - | `5` |
| `--amazonec2-root-size` | `AWS_ROOT_SIZE` | `16` |
| `--amazonec2-secret-key` | `AWS_SECRET_ACCESS_KEY` | - |
| `--amazonec2-security-group` | `AWS_SECURITY_GROUP` | `docker-machine` |
| `--amazonec2-security-group-readonly` | `AWS_SECURITY_GROUP_READONLY` | `false` |
| `--amazonec2-session-token` | `AWS_SESSION_TOKEN` | - |
| `--amazonec2-spot-price` | - | `0.50` |
| `--amazonec2-ssh-keypath` | `AWS_SSH_KEYPATH` | - |
| `--amazonec2-ssh-user` | `AWS_SSH_USER` | `ubuntu` |
| `--amazonec2-subnet-id` | `AWS_SUBNET_ID` | - |
| `--amazonec2-tags` | `AWS_TAGS` | - |
| `--amazonec2-use-ebs-optimized-instance` | - | `false` |
| `--amazonec2-use-private-address` | - | `false` |
| `--amazonec2-userdata` | `AWS_USERDATA` | - |
| `--amazonec2-volume-type` | `AWS_VOLUME_TYPE` | `gp2` |
| `--amazonec2-vpc-id` | `AWS_VPC_ID` | - |
| `--amazonec2-zone` | `AWS_ZONE` | `a` |
## Default AMIs
By default, the Amazon EC2 driver uses a daily image of `Ubuntu 16.04 LTS`.
| Region | AMI ID |
| -------------- | ------------ |
| ap-northeast-1 | ami-785c491f |
| ap-northeast-2 | ami-94d20dfa |
| ap-southeast-1 | ami-2378f540 |
| ap-southeast-2 | ami-e94e5e8a |
| ap-south-1 | ami-49e59a26 |
| ca-central-1 | ami-7ed56a1a |
| cn-north-1 | ami-a163b4cc |
| eu-central-1 | ami-1c45e273 |
| eu-west-1 | ami-6d48500b |
| eu-west-2 | ami-cc7066a8 |
| eu-west-3 | ami-c1cf79bc |
| sa-east-1 | ami-34afc458 |
| us-east-1 | ami-d15a75c7 |
| us-east-2 | ami-8b92b4ee |
| us-west-1 | ami-73f7da13 |
| us-west-2 | ami-835b4efa |
| us-gov-west-1 | ami-939412f2 |
## Security Group
A security group is created and associated to the host. This security group has the following ports opened inbound:
- ssh (22/tcp)
- docker (2376/tcp)
- swarm (3376/tcp), only if the node is a swarm master
If you specify a security group yourself using the `--amazonec2-security-group` flag, the above ports are checked and opened and the security group is modified.
If you want more ports to be opened such as application-specific ports, use the AWS console and modify the configuration manually.
## VPC ID
Your default VPC ID is determined at the start of a command. In some cases, either because your account does not have a default VPC, or you do not want to use the default one, you can specify a VPC with the `--amazonec2-vpc-id` flag.
### To find the VPC ID:
1. Login to the AWS console.
2. Go to **Services -> VPC -> Your VPCs**.
3. Locate the VPC ID you want from the *_VPC_* column.
4. Go to **Services -> VPC -> Subnets**. Examine the _Availability Zone_ column to verify that zone `a` exists and matches your VPC ID. For example, `us-east1-a` is in the `a` availability zone. If the `a` zone is not present, you can create a new subnet in that zone or specify a different zone when you create the machine.
### To create a machine with a non-default VPC-ID:
$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C********* --amazonec2-vpc-id vpc-****** aws02
This example assumes the VPC ID was found in the `a` availability zone. Use the`--amazonec2-zone` flag to specify a zone other than the `a` zone. For example, `--amazonec2-zone c` signifies `us-east1-c`.
## VPC Connectivity
Docker Machine uses SSH to complete the set up of instances in EC2 and requires the ability to access the instance directly.
If you use the flag `--amazonec2-private-address-only`, ensure that you can access the new instance from within the internal network of the VPC, such as a corporate VPN to the VPC, a VPN instance inside the VPC, or using `docker-machine` from an instance within your VPC.
Configuration of VPCs is beyond the scope of this guide. However, the first step in troubleshooting is making sure that you are using private subnets that follow the design guidance in the [AWS VPC User Guide](http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Scenario2.html) and have some form of NAT available so that the setup process can access the internet to complete the setup.
## Custom AMI and SSH username
The default SSH username for the default AMIs is `ubuntu`.
You need to change the SSH username only if the custom AMI you use has a different SSH username.
You can change the SSH username with the `--amazonec2-ssh-user` according to the AMI you selected with the `--amazonec2-ami` option.

119
machine/drivers/azure.md
View File

@ -1,119 +0,0 @@
---
description: Microsoft Azure driver for machine
keywords: machine, Microsoft Azure, driver
title: Microsoft Azure
---
You need an Azure Subscription to use this Docker Machine driver.
[Sign up for a free trial.][trial]
> **Note**: This documentation is for the new version of the Azure driver, which started
> shipping with v0.7.0. This driver is not backwards-compatible with the old
> Azure driver. If you want to continue managing your existing Azure machines, please
> download and use machine versions prior to v0.7.0.
[azure]: https://azure.microsoft.com/
[trial]: https://azure.microsoft.com/free/
## Authentication
The first time you try to create a machine, Azure driver asks you to
authenticate:
$ docker-machine create --driver azure --azure-subscription-id <subs-id> <machine-name>
Running pre-create checks...
Microsoft Azure: To sign in, use a web browser to open the page https://aka.ms/devicelogin.
Enter the code [...] to authenticate.
After authenticating, the driver remembers your credentials up to two weeks.
> **KNOWN ISSUE:** There is a known issue with Azure Active Directory causing stored
> credentials to expire within hours rather than 14 days when the user logs in with
> personal Microsoft Account (formerly _Live ID_) instead of an Active Directory account.
> Currently, there is no ETA for resolution, however in the meanwhile you can
> [create an AAD account][aad-docs] and login with that as a workaround.
[aad-docs]: https://azure.microsoft.com/documentation/articles/virtual-machines-windows-create-aad-work-id/
## Options
Azure driver only has a single required argument to make things easier. Please
read the optional flags to configure machine details and placement further.
Required:
- `--azure-subscription-id`: **(required)** Your Azure Subscription ID.
Optional:
- `--azure-availability-set`: Azure Availability Set to place the virtual machine into. [[?][av-set]]
- `--azure-docker-port`: Port number for Docker engine.
- `--azure-environment`: Azure environment. For example, `AzurePublicCloud` or`AzureChinaCloud`.
- `--azure-image`: Azure virtual machine image in the format of Publisher:Offer:Sku:Version [[?][vm-image]]
- `--azure-location`: Azure region to create the virtual machine. [[?][location]]
- `--azure-no-public-ip`: Do not create a public IP address for the machine (implies `--azure-use-private-ip`). Should be used only when creating machines from an Azure VM within the same subnet.
- `--azure-open-port`: Make additional port number(s) accessible from the Internet [[?][nsg]]
- `--azure-private-ip-address`: Specify a static private IP address for the machine.
- `--azure-resource-group`: Azure Resource Group name to create the resources in.
- `--azure-size`: Size for Azure Virtual Machine. [[?][vm-size]]
- `--azure-ssh-user`: Username for SSH login.
- `--azure-static-public-ip`: Assign a static public IP address to the machine.
- `--azure-subnet`: Azure Subnet Name to be used within the Virtual Network.
- `--azure-subnet-prefix`: Private CIDR block. Used to create subnet if it does not exist. Must match in the case that the subnet does exist.
- `--azure-use-private-ip`: Use private IP address of the machine to connect. Useful for managing Docker machines from another machine on the same network, such as when deploying Swarm.
- `--azure-vnet`: Azure Virtual Network name to connect the virtual machine.
[[?][vnet]] To specify a Virtual Network from another resource group, use `resourcegroup:vnet-name` format.
[vm-image]: https://azure.microsoft.com/en-us/documentation/articles/resource-groups-vm-searching/
[location]: https://azure.microsoft.com/en-us/regions/
[vm-size]: https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-size-specs/
[vnet]: https://azure.microsoft.com/en-us/documentation/articles/virtual-networks-overview/
[av-set]: https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-manage-availability/
#### Environment variables and default values
| CLI option | Environment variable | Default |
| ------------------------------- | ----------------------------- | ------------------ |
| `--azure-availability-set` | `AZURE_AVAILABILITY_SET` | `docker-machine` |
| `--azure-docker-port` | `AZURE_DOCKER_PORT` | `2376` |
| `--azure-environment` | `AZURE_ENVIRONMENT` | `AzurePublicCloud` |
| `--azure-image` | `AZURE_IMAGE` | `canonical:UbuntuServer:16.04.0-LTS:latest` |
| `--azure-location` | `AZURE_LOCATION` | `westus` |
| `--azure-no-public-ip` | - | - |
| `--azure-open-port` | - | - |
| `--azure-private-ip-address` | - | - |
| `--azure-resource-group` | `AZURE_RESOURCE_GROUP` | `docker-machine` |
| `--azure-size` | `AZURE_SIZE` | `Standard_A2` |
| `--azure-ssh-user` | `AZURE_SSH_USER` | `docker-user` |
| `--azure-static-public-ip` | - | - |
| `--azure-subnet-prefix` | `AZURE_SUBNET_PREFIX` | `192.168.0.0/16` |
| `--azure-subnet` | `AZURE_SUBNET` | `docker-machine` |
| **`--azure-subscription-id`** | `AZURE_SUBSCRIPTION_ID` | - |
| `--azure-use-private-ip` | - | - |
| `--azure-vnet` | `AZURE_VNET` | `docker-machine` |
## Notes
Azure runs fully on the new [Azure Resource Manager (ARM)][arm] stack. Each
machine created comes with a few more Azure resources associated with it:
* A [Virtual Network][vnet] and a subnet under it is created to place your
machines into. This establishes a local network between your docker machines.
* An [Availability Set][av-set] is created to maximize availability of your
machines.
These are created once when the first machine is created and reused afterwards.
Although they are free resources, driver does a best effort to clean them up
after the last machine using these resources is removed.
Each machine is created with a public dynamic IP address for external
connectivity. All its ports (except Docker and SSH) are closed by default. You
can use `--azure-open-port` argument to specify multiple port numbers to be
accessible from Internet.
Once the machine is created, you can modify [Network Security Group][nsg]
rules and open ports of the machine from the [Azure Portal][portal].
[arm]: https://azure.microsoft.com/en-us/documentation/articles/resource-group-overview/
[nsg]: https://azure.microsoft.com/en-us/documentation/articles/virtual-networks-nsg/
[portal]: https://portal.azure.com/

63
machine/drivers/digital-ocean.md
View File

@ -1,63 +0,0 @@
---
description: DigitalOcean driver for machine
keywords: machine, digitalocean, driver
title: DigitalOcean
---
Create Docker machines on [DigitalOcean](https://www.digitalocean.com/).
You need to create a personal access token under "Apps & API" in the DigitalOcean
Control Panel and pass that to `docker-machine create` with the `--digitalocean-access-token` option.
## Usage
$ docker-machine create --driver digitalocean --digitalocean-access-token=aa9399a2175a93b17b1c86c807e08d3fc4b79876545432a629602f61cf6ccd6b test-this
### When explicitly passing environment variables
export DIGITALOCEAN_ACCESS_TOKEN="yourtoken"; export DIGITALOCEAN_SSH_KEY_FINGERPRINT="from your DO's profile security-ssh keys"; \ export DIGITALOCEAN_IMAGE="centos-7-x64"; export DIGITALOCEAN_REGION="tor1"
$ docker-machine create --driver digitalocean --digitalocean-access-token $DIGITALOCEAN_ACCESS_TOKEN --digitalocean-ssh-key-fingerprint $DIGITALOCEAN_SSH_KEY_FINGERPRINT --digitalocean-image $DIGITALOCEAN_IMAGE --digitalocean-region $DIGITALOCEAN_REGION
### When passing a boolean value to any option
$ docker-machine create --driver digitalocean --digitalocean-access-token=aa9399a2175a93b17b1c86c807e08d3fc4b79876545432a629602f61cf6ccd6b --digitalocean-size 1gb --digitalocean-backups=true test-this
## Options
- `--digitalocean-access-token`: **required**. Your personal access token for the DigitalOcean API.
- `--digitalocean-backups`: Enable DigitalOcean backups for the droplet.
- `--digitalocean-image`: The name of the DigitalOcean image to use.
- `--digitalocean-ipv6`: Enable IPv6 support for the droplet.
- `--digitalocean-monitoring`: Enable monitoring for the droplet.
- `--digitalocean-private-networking`: Enable private networking support for the droplet.
- `--digitalocean-region`: The region to create the droplet in, see [Regions API](https://developers.digitalocean.com/documentation/v2/#regions) for how to get a list.
- `--digitalocean-size`: The size of the DigitalOcean droplet (larger than default options are of the form `2gb`).
- `--digitalocean-ssh-key-fingerprint`: Use an existing SSH key instead of creating a new one, see [SSH keys](https://developers.digitalocean.com/documentation/v2/#ssh-keys).
- `--digitalocean-ssh-key-path`: SSH private key path.
- `--digitalocean-ssh-port`: SSH port.
- `--digitalocean-ssh-user`: SSH username.
- `--digitalocean-tags`: Comma-separated list of tags to apply to the Droplet, see [Droplet tagging](https://developers.digitalocean.com/documentation/v2/#tags)
- `--digitalocean-userdata`: Path to file containing User Data for the droplet.
The DigitalOcean driver uses `ubuntu-16-04-x64` as the default image.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| ----------------------------------- | --------------------------------- | ------------------ |
| **`--digitalocean-access-token`** | `DIGITALOCEAN_ACCESS_TOKEN` | - |
| `--digitalocean-backups` | `DIGITALOCEAN_BACKUPS` | `false` |
| `--digitalocean-image` | `DIGITALOCEAN_IMAGE` | `ubuntu-16-04-x64` |
| `--digitalocean-ipv6` | `DIGITALOCEAN_IPV6` | `false` |
| `--digitalocean-private-networking` | `DIGITALOCEAN_PRIVATE_NETWORKING` | `false` |
| `--digitalocean-region` | `DIGITALOCEAN_REGION` | `nyc3` |
| `--digitalocean-size` | `DIGITALOCEAN_SIZE` | `s-1vcpu-1gb` |
| `--digitalocean-ssh-key-fingerprint`| `DIGITALOCEAN_SSH_KEY_FINGERPRINT`| - |
| `--digitalocean-ssh-key-path` | `DIGITALOCEAN_SSH_KEY_PATH` | - |
| `--digitalocean-ssh-port` | `DIGITALOCEAN_SSH_PORT` | 22 |
| `--digitalocean-ssh-user` | `DIGITALOCEAN_SSH_USER` | `root` |
| `--digitalocean-tags` | `DIGITALOCEAN_TAGS` | - |
| `--digitalocean-userdata` | `DIGITALOCEAN_USERDATA` | - |
| `--digitalocean-monitoring` | `$DIGITALOCEAN_MONITORING` | `false` |

102
machine/drivers/exoscale.md
View File

@ -1,102 +0,0 @@
---
description: Exoscale driver for machine
keywords: machine, exoscale, driver
title: Exoscale
---
Create machines on [Exoscale](https://www.exoscale.com/).
Get your API key and API secret key from [API details](https://portal.exoscale.com/account/api) and pass them to `machine create` with the `--exoscale-api-key` and `--exoscale-api-secret-key` options.
## Usage
$ docker-machine create --driver exoscale \
--exoscale-api-key=API \
--exoscale-api-secret-key=SECRET \
MY_COMPUTE_INSTANCE
If you encounter any troubles, activate the debug mode with `docker-machine --debug create ...`.
## Options
- `--exoscale-affinity-group`: [Anti-affinity group][anti-affinity] the machine is started in.
- `--exoscale-api-key`: **required** Your API key;
- `--exoscale-api-secret-key`: **required** Your API secret key;
- `--exoscale-availability-zone`: Exoscale [availability zone][datacenters] (ch-dk-2, at-vie-1, de-fra-1, ...);
- `--exoscale-disk-size`: Disk size for the host in GiB (at least 10);
- `--exoscale-image`: Image template, for example `ubuntu-16.04`, also known as `Linux Ubuntu 16.04 LTS 64-bit`, [see below](#image-template-name));
- `--exoscale-instance-profile`: Instance profile (Small, Medium, Large, ...);
- `--exoscale-security-group`: Security group. _It is created if it doesn't exist_;
- `--exoscale-ssh-key`: Path to the SSH user private key. _A new one is created if left empty_;
- `--exoscale-ssh-user`: SSH username to connect, such as `ubuntu`, [see below](#ssh-username));
- `--exoscale-url`: Your API endpoint;
- `--exoscale-userdata`: Path to file containing user data for [cloud-init](https://cloud-init.io/);
### Environment variables and default values
| CLI option | Environment variable | Default |
| ------------------------------- | ---------------------------- | --------------------------------- |
| `--exoscale-affinity-group` | `EXOSCALE_AFFINITY_GROUP` | - |
| **`--exoscale-api-key`** | `EXOSCALE_API_KEY` | - |
| **`--exoscale-api-secret-key`** | `EXOSCALE_API_SECRET` | - |
| `--exoscale-availability-zone` | `EXOSCALE_AVAILABILITY_ZONE` | `ch-dk-2` |
| `--exoscale-disk-size` | `EXOSCALE_DISK_SIZE` | `50` |
| `--exoscale-image` | `EXOSCALE_IMAGE` | `Linux Ubuntu 16.04 LTS 64-bit` |
| `--exoscale-instance-profile` | `EXOSCALE_INSTANCE_PROFILE` | `small` |
| `--exoscale-security-group` | `EXOSCALE_SECURITY_GROUP` | `docker-machine` |
| `--exoscale-ssh-key` | `EXOSCALE_SSH_KEY` | - |
| `--exoscale-ssh-user` | `EXOSCALE_SSH_USER` | - |
| `--exoscale-url` | `EXOSCALE_ENDPOINT` | `https://api.exoscale.ch/compute` |
| `--exoscale-userdata` | `EXOSCALE_USERDATA` | - |
**NB:** the _instance profile_, _image_, and _availability zone_ are case insensitive.
### Image template name
The [VM templates][templates] available at Exoscale are listed on the Portal
when adding a new instance.
For any Linux template, you may use the shorter name composed only of the name
and version, as shown below.
| Full name | Short name |
| ------------------------------- | -------------------- |
| Linux Debian 8 64-bit | `debian-8` |
| Linux Ubuntu 16.04 LTS 64-bit | `ubuntu-16.04` |
| Linux CentOS 7.3 64-bit | `centos-7.3` |
| Linux CoreOS stable 1298 64-bit | `coreos-stable-1298` |
**NB:** Docker doesn't work for non-Linux machines like OpenBSD or Windows Server.
### SSH Username
The Exoscale driver does an educated guess to pick the correct default SSH
user. If left empty, it picks a suitable one following those rules:
- `centos` for CentOS;
- `core` for Linux CoreOS (aka Container Linux);
- `debian` for Debian;
- `ubuntu` for Ubuntu;
- `fedora` for Fedora;
- `cloud-user` for Red Hat;
- otherwise, `root`.
### Custom security group
If a custom security group is provided, you need to ensure that you allow TCP ports 22 and 2376 in an ingress rule.
Moreover, if you want to use [Docker Swarm](../../engine/swarm/swarm-tutorial/index.md), also add TCP port 2377, UDP/TCP on 7946, and UDP on 4789.
### Debian 9
The [default storage driver](../../storage/storagedriver/select-storage-driver.md) may fail on Debian, specifying `overlay2` should resolve this issue.
$ docker-machine create --engine-storage-driver overlay2 ...`
### More than 8 docker machines?
There is a limit to the number of machines that an anti-affinity group can have. This can be worked around by specifying an additional anti-affinity group using `--exoscale-affinity-group=docker-machineX`
[templates]: https://www.exoscale.com/templates/
[datacenters]: https://www.exoscale.com/datacenters/
[anti-affinity]: https://community.exoscale.com/documentation/compute/anti-affinity-groups/

94
machine/drivers/gce.md
View File

@ -1,94 +0,0 @@
---
description: Google Compute Engine driver for machine
keywords: machine, Google Compute Engine, driver
title: Google Compute Engine
---
Create machines on [Google Compute Engine](https://cloud.google.com/compute/).
You need a Google account and a project ID.
See [https://cloud.google.com/compute/docs/projects](https://cloud.google.com/compute/docs/projects) for details on projects.
### Credentials
The Google driver uses [Application Default Credentials](https://developers.google.com/identity/protocols/application-default-credentials)
to get authorization credentials for use in calling Google APIs.
So if `docker-machine` is used from a GCE host, authentication occurs automatically
via the built-in service account.
Otherwise, [install gcloud](https://cloud.google.com/sdk/) and get
through the oauth2 process with `gcloud auth login`.
Or, manually download the credentials.json file to the local, and set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable point to its location, such as:
export GOOGLE_APPLICATION_CREDENTIALS=$HOME/gce-credentials.json
### Example
To create a machine instance, specify `--driver google`, the project ID and the machine name.
$ gcloud auth login
$ docker-machine create --driver google --google-project PROJECT_ID vm01
$ docker-machine create --driver google \
--google-project PROJECT_ID \
--google-zone us-central1-a \
--google-machine-type f1-micro \
vm02
### Options
- `--google-address`: Instance's static external IP (name or IP).
- `--google-disk-size`: The disk size of instance.
- `--google-disk-type`: The disk type of instance.
- `--google-machine-image`: The absolute URL to a base VM image to instantiate.
- `--google-machine-type`: The type of instance.
- `--google-network`: Specify network in which to provision VM.
- `--google-preemptible`: Instance preemptibility.
- `--google-project`: **required** The ID of your project to use when launching the instance.
- `--google-scopes`: The scopes for OAuth 2.0 to Access Google APIs. See [Google Compute Engine Doc](https://cloud.google.com/storage/docs/authentication).
- `--google-subnetwork`: Specify subnetwork in which to provision VM.
- `--google-tags`: Instance tags (comma-separated).
- `--google-use-existing`: Don't create a new VM, use an existing one. This is useful when you'd like to provision Docker on a VM you created yourself, maybe because it uses create options not supported by this driver.
- `--google-use-internal-ip-only`: When this option is used during create, the new VM is not assigned a public IP address. This is useful only when the host running `docker-machine` is located inside the Google Cloud infrastructure; otherwise, `docker-machine` can't reach the VM to provision the Docker daemon. The presence of this flag implies `--google-use-internal-ip`.
- `--google-use-internal-ip`: When this option is used during create, docker-machine uses internal rather than public NATed IPs. The flag is persistent in the sense that a machine created with it retains the IP. It's useful for managing docker machines from another machine on the same network, such as when deploying swarm.
- `--google-username`: The username to use for the instance.
- `--google-zone`: The zone to launch the instance.
The GCE driver uses the `ubuntu-1604-xenial-v20161130` instance image unless otherwise specified. To obtain a
list of image URLs run:
gcloud compute images list --uri
Google Compute Engine supports [image families](https://cloud.google.com/compute/docs/images#image_families).
An image family is like an image alias that always points to the latest image in the family. To create an
instance from an image family, set `--google-machine-image` to the family's URL.
The following command shows images and which family they belong to (if any):
gcloud compute images list
To obtain a family URL, replace `<PROJECT>` and `<FAMILY>` in the following template.
https://www.googleapis.com/compute/v1/projects/<PROJECT>/global/images/family/<FAMILY>
For example, to create an instance from the latest Ubuntu 16 LTS image, specify
`https://www.googleapis.com/compute/v1/projects/ubuntu-os-cloud/global/images/family/ubuntu-1604-lts`.
#### Environment variables and default values
| CLI option | Environment variable | Default |
|:---------------------------|:-------------------------|:-------------------------------------|
| `--google-address` | `GOOGLE_ADDRESS` | - |
| `--google-disk-size` | `GOOGLE_DISK_SIZE` | `10` |
| `--google-disk-type` | `GOOGLE_DISK_TYPE` | `pd-standard` |
| `--google-machine-image` | `GOOGLE_MACHINE_IMAGE` | `ubuntu-1510-wily-v20151114` |
| `--google-machine-type` | `GOOGLE_MACHINE_TYPE` | `f1-standard-1` |
| `--google-network` | `GOOGLE_NETWORK` | `default` |
| `--google-preemptible` | `GOOGLE_PREEMPTIBLE` | - |
| **`--google-project`** | `GOOGLE_PROJECT` | - |
| `--google-scopes` | `GOOGLE_SCOPES` | `devstorage.read_only,logging.write` |
| `--google-subnetwork` | `GOOGLE_SUBNETWORK` | - |
| `--google-tags` | `GOOGLE_TAGS` | - |
| `--google-use-existing` | `GOOGLE_USE_EXISTING` | - |
| `--google-use-internal-ip` | `GOOGLE_USE_INTERNAL_IP` | - |
| `--google-username` | `GOOGLE_USERNAME` | `docker-user` |
| `--google-zone` | `GOOGLE_ZONE` | `us-central1-a` |

73
machine/drivers/generic.md
View File

@ -1,73 +0,0 @@
---
description: Generic driver for machine
keywords: machine, Generic, driver
title: Generic
---
Create machines using an existing VM/Host with SSH.
This is useful if you are using a provider that Machine does not support
directly or if you would like to import an existing host to allow Docker
Machine to manage.
The driver performs a list of tasks on create:
- If docker is not running on the host, it is installed automatically.
- It updates the host packages (`apt-get update`, `yum update`...).
- It generates certificates to secure the docker daemon.
- If the host uses systemd, it creates /etc/systemd/system/docker.service.d/10-machine.conf
- The docker daemon restarts, thus all running containers are stopped.
- The hostname is updated to fit the machine name.
### Example
To create a machine instance, specify `--driver generic`, the IP address or DNS
name of the host and the path to the SSH private key authorized to connect
to the host.
$ docker-machine create \
--driver generic \
--generic-ip-address=203.0.113.81 \
--generic-ssh-key ~/.ssh/id_rsa \
vm
### Sudo privileges
The user that is used to SSH into the host can be specified with
`--generic-ssh-user` flag. This user needs password-less sudo
privileges.
If it's not the case, you need to edit the `sudoers` file and configure the user
as a sudoer with `NOPASSWD`. See https://help.ubuntu.com/community/Sudoers.
### Options
- `--generic-engine-port`: Port to use for Docker Daemon (Note: This flag does not work with boot2docker).
- `--generic-ip-address`: **required** IP Address of host.
- `--generic-ssh-key`: Path to the SSH user private key.
- `--generic-ssh-user`: SSH username used to connect.
- `--generic-ssh-port`: Port to use for SSH.
> **Note**: You must use a base operating system supported by Machine.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| -------------------------- | -------------------- | ------------------------- |
| `--generic-engine-port` | `GENERIC_ENGINE_PORT`| `2376` |
| **`--generic-ip-address`** | `GENERIC_IP_ADDRESS` | - |
| `--generic-ssh-key` | `GENERIC_SSH_KEY` | - |
| `--generic-ssh-user` | `GENERIC_SSH_USER` | `root` |
| `--generic-ssh-port` | `GENERIC_SSH_PORT` | `22` |
### Systemd settings
For systems that use systemd, if you have an existing configuration defined in
'/etc/systemd/system/docker.service.d/' this may conflict with the settings created by
docker-machine. Make sure you don't have any other configuration files in this location
that override the [ExecStart] setting.
Once you have confirmed any conflicting settings have been removed, run
`sudo systemctl daemon-reload` followed by `sudo systemctl restart docker`

152
machine/drivers/hyper-v.md
View File

@ -1,152 +0,0 @@
---
description: Microsoft Hyper-V driver for machine
keywords: machine, Microsoft Hyper-V, driver
title: Microsoft Hyper-V
toc_max: 4
---
Creates a Boot2Docker virtual machine locally on your Windows machine
using Hyper-V.
Hyper-V must be enabled on your desktop system. Docker Desktop for Windows automatically
enables it upon install. See this article on the Microsoft developer network for instructions on
[how to manually enable
Hyper-V](https://msdn.microsoft.com/en-us/virtualization/hyperv_on_windows/quick_start/walkthrough_install).
> **Notes**:
>
> * You must use an Administrator level account to create and manage Hyper-V machines.
>
>* You need an existing virtual switch to use the
> driver. Hyper-V can share an external network interface (also known as
> bridging). See [this blog](https://docs.microsoft.com/en-us/archive/blogs/canitpro/step-by-step-enabling-hyper-v-for-use-on-windows-8-1) to learn more.
> If you would like to use NAT, create an internal network, and use
> [Internet Connection Sharing](https://packet6.com/allowing-windows-8-1-hyper-v-vm-to-work-with-wifi/).
>
> * This reference page includes an [example](hyper-v.md#example) showing you how to use an elevated (Administrator-level) PowerShell and create and use an external network switch.
## Usage
$ docker-machine create --driver hyperv vm
## Options
- `--hyperv-boot2docker-url`: The URL of the boot2docker ISO.
- `--hyperv-virtual-switch`: Name of the virtual switch to use.
- `--hyperv-disk-size`: Size of disk for the host in MB.
- `--hyperv-memory`: Size of memory for the host in MB.
- `--hyperv-cpu-count`: Number of CPUs for the host.
- `--hyperv-static-macaddress`: Hyper-V network adapter's static MAC address.
- `--hyperv-vlan-id`: Hyper-V network adapter's VLAN ID if any.
- `--hyperv-disable-dynamic-memory`: Disable dynamic memory management.
## Environment variables and default values
| CLI option | Environment variable | Default |
| --------------------------------- | ------------------------------- | ------------------------ |
| `--hyperv-boot2docker-url` | `HYPERV_BOOT2DOCKER_URL` | _Latest boot2docker url_ |
| `--hyperv-cpu-count` | `HYPERV_CPU_COUNT` | `1` |
| `--hyperv-disk-size` | `HYPERV_DISK_SIZE` | `20000` |
| `--hyperv-memory` | `HYPERV_MEMORY` | `1024` |
| `--hyperv-static-macaddress` | `HYPERV_STATIC_MACADDRESS` | _undefined_ |
| `--hyperv-virtual-switch` | `HYPERV_VIRTUAL_SWITCH` | _first found_ |
| `--hyperv-vlan-id` | `HYPERV_VLAN_ID` | _undefined_ |
| `--hyperv-disable-dynamic-memory` | `HYPERV_DISABLE_DYNAMIC_MEMORY` | `false` |
## Example:
#### 1. Make sure Hyper-V is enabled.
Hyper-V is automatically enabled on a Docker Desktop for Windows installation. To enable it manually, see [instructions on how to manually enable Hyper-V](https://msdn.microsoft.com/en-us/virtualization/hyperv_on_windows/quick_start/walkthrough_install) on the Microsoft developer network.
#### 2. Set up a new external network switch (Optional)
> **Note**: If you already have an external network switch, skip this setup and use that one instead.
Make sure you have Ethernet connectivity while you are doing this.
Open the **Hyper-V Manager**. (On Windows 10, search for the Hyper-V Manager in the lower left search field.)
Select the **Virtual Switch Manager** on the right-hand **Actions** panel.
![Hyper-V manager](../img/hyperv-manager.png)
Set up a new **external network switch** to use instead of DockerNAT network switch (for Moby), which is set up by default when you install Docker Desktop for Windows. If you already have another network switch set up, use that one instead but make sure it is an **external** switch.)
For this example, we created a virtual switch called `Primary Virtual Switch`.
![Defining a new virtual switch](../img/hyperv-network-switch.png)
#### 3. Reboot
See this issue on virtualbox: [Hangs on Waiting for VM to start #986](https://github.com/docker/machine/issues/986).
Reboot your desktop system to clear out any routing table problems. Without a reboot first, `docker-machine create ...` might get hung up on `Waiting for host to start...`. If you are still hung on "Waiting for host to start..." after you reboot, make sure you selected the correct network in the Virtual Switch Manager.
#### 4. Create the nodes with Docker Machine and the Microsoft Hyper-V driver
* Start an "elevated" PowerShell with administrator privileges. To do this, search for PowerShell, then right click and choose ***Run as administrator***.
* Run the `docker-machine create` commands to create machines.
For example, if you follow along with the [Swarm mode tutorial](../../engine/swarm/swarm-tutorial/index.md)
which asks you to create [three networked host machines](../../engine/swarm/swarm-tutorial/index.md#three-networked-host-machines),
you can create these swarm nodes: `manager1`, `worker1`, `worker2`.
* Use the Microsoft Hyper-V driver and reference the new virtual switch you created.
```console
$ docker-machine create -d hyperv --hyperv-virtual-switch <NameOfVirtualSwitch> <nameOfNode>
```
Here is an example of creating a `manager1` node:
```console
PS C:\WINDOWS\system32> docker-machine create -d hyperv --hyperv-virtual-switch "Primary Virtual Switch" manager1
Running pre-create checks...
Creating machine...
(manager1) Copying C:\Users\<your_username>\.docker\machine\cache\boot2docker.iso to C:\Users\<your_username>\.docker\machine\machines\manag
er1\boot2docker.iso...
(manager1) Creating SSH key...
(manager1) Creating VM...
(manager1) Using switch "Primary Virtual Switch"
(manager1) Creating VHD
(manager1) Starting VM...
(manager1) Waiting for host to start...
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: C:\Program Files\Doc
ker\Docker\Resources\bin\docker-machine.exe env manager1
PS C:\WINDOWS\system32>
```
* Use the same process, driver, and network switch to create the other nodes.
For our example, the commands are:
```console
$ docker-machine create -d hyperv --hyperv-virtual-switch "Primary Virtual Switch" worker1
$ docker-machine create -d hyperv --hyperv-virtual-switch "Primary Virtual Switch" worker2
```
## Where to go next
As a point of interest, the virtual machines you create with
[`docker-machine create`](../reference/create.md) show up in the
Hyper-V Manager under "Virtual Machines", but you need to manage them with
[`docker-machine`](../reference/index.md) commands and not through the Hyper-V
Manager.
To get started using `docker-machine` commands, see these topics:
* [Run containers and experiment with Machine commands](../get-started.md#run-containers-and-experiment-with-machine-commands) and the introductory topics that follow
* [Docker Machine commmand line reference](../reference/index.md)

26
machine/drivers/index.md
View File

@ -1,26 +0,0 @@
---
description: Reference for drivers Docker Machine supports
keywords: machine, drivers, supports
title: Machine drivers
---
- [Amazon Web Services](aws.md)
- [Microsoft Azure](azure.md)
- [DigitalOcean](digital-ocean.md)
- [Exoscale](exoscale.md)
- [Generic](generic.md)
- [Google Compute Engine](gce.md)
- [Linode](linode.md) (unofficial plugin, not supported by Docker)
- [Microsoft Hyper-V](hyper-v.md)
- [OpenStack](openstack.md)
- [Rackspace](rackspace.md)
- [IBM Softlayer](soft-layer.md)
- [Oracle VirtualBox](virtualbox.md)
- [VMware vCloud Air](vm-cloud.md)
- [VMware Fusion](vm-fusion.md)
- [VMware vSphere](vsphere.md)
- [VMware Workstation](https://github.com/pecigonzalo/docker-machine-vmwareworkstation) (unofficial plugin, not supported by Docker)
- [Grid 5000](https://github.com/Spirals-Team/docker-machine-driver-g5k) (unofficial plugin, not supported by Docker)
- [Scaleway](https://github.com/scaleway/docker-machine-driver-scaleway) (unofficial plugin, not supported by Docker)
- [Hetzner Cloud](https://github.com/JonasProgrammer/docker-machine-driver-hetzner) (unofficial plugin, not supported by Docker)
- [ArvanCloud](https://github.com/satrobit/docker-machine-driver-arvan) (unofficial plugin, not supported by Docker)

61
machine/drivers/linode.md
View File

@ -1,61 +0,0 @@
---
description: Linode driver for machine
keywords: machine, Linode, driver
title: Linode
---
Create machines on [Linode](https://www.linode.com).
### Credentials
You will need a Linode APIv4 Personal Access Token. Get one here: <https://developers.linode.com/api/v4#section/Personal-Access-Token>.
Supply the token to `docker-machine create -d linode` with `--linode-token`.
### Install
`docker-machine` is required, [see the installation documentation](https://docs.docker.com/machine/install-machine/).
Then, install the latest release of the Linode machine driver for your environment from the [releases list](https://github.com/linode/docker-machine-driver-linode/releases).
### Usage
```console
$ docker-machine create -d linode --linode-token=<linode-token> linode
```
See the [Linode Docker machine driver project page](https://github.com/linode/docker-machine-driver-linode) for more examples.
#### Options, Environment Variables, and Defaults
| Argument | Env | Default | Description
| --- | --- | --- | ---
| `linode-token` | `LINODE_TOKEN` | None | **required** Linode APIv4 Token (see [here](https://developers.linode.com/api/v4#section/Personal-Access-Token))
| `linode-root-pass` | `LINODE_ROOT_PASSWORD` | *generated* | The Linode Instance `root_pass` (password assigned to the `root` account)
| `linode-authorized-users` | `LINODE_AUTHORIZED_USERS` | None | Linode user accounts (separated by commas) whose Linode SSH keys will be permitted root access to the created node
| `linode-label` | `LINODE_LABEL` | *generated* | The Linode Instance `label`, unless overridden this will match the docker-machine name. This `label` must be unique on the account.
| `linode-region` | `LINODE_REGION` | `us-east` | The Linode Instance `region` (see [here](https://api.linode.com/v4/regions))
| `linode-instance-type` | `LINODE_INSTANCE_TYPE` | `g6-standard-4` | The Linode Instance `type` (see [here](https://api.linode.com/v4/linode/types))
| `linode-image` | `LINODE_IMAGE` | `linode/ubuntu18.04` | The Linode Instance `image` which provides the Linux distribution (see [here](https://api.linode.com/v4/images)).
| `linode-ssh-port` | `LINODE_SSH_PORT` | `22` | The port that SSH is running on, needed for Docker Machine to provision the Linode.
| `linode-ssh-user` | `LINODE_SSH_USER` | `root` | The user as which docker-machine should log in to the Linode instance to install Docker. This user must have passwordless sudo.
| `linode-docker-port` | `LINODE_DOCKER_PORT` | `2376` | The TCP port of the Linode that Docker will be listening on
| `linode-swap-size` | `LINODE_SWAP_SIZE` | `512` | The amount of swap space provisioned on the Linode Instance
| `linode-stackscript` | `LINODE_STACKSCRIPT` | None | Specifies the Linode StackScript to use to create the instance, either by numeric ID, or using the form *username*/*label*.
| `linode-stackscript-data` | `LINODE_STACKSCRIPT_DATA` | None | A JSON string specifying data that is passed (via UDF) to the selected StackScript.
| `linode-create-private-ip` | `LINODE_CREATE_PRIVATE_IP` | None | A flag specifying to create private IP for the Linode instance.
| `linode-tags` | `LINODE_TAGS` | None | A comma separated list of tags to apply to the Linode resource
| `linode-ua-prefix` | `LINODE_UA_PREFIX` | None | Prefix the User-Agent in Linode API calls with some 'product/version'
#### Notes
* When using the `linode/containerlinux` `linode-image`, the `linode-ssh-user` will default to `core`
* A `linode-root-pass` will be generated if not provided. This password will not be shown. Rely on `docker-machine ssh` or [Linode's Rescue features](https://www.linode.com/docs/quick-answers/linode-platform/reset-the-root-password-on-your-linode/) to access the node directly.
#### Debugging
Detailed run output will be emitted when using the LinodeGo `LINODE_DEBUG=1` option along with the `docker-machine` `--debug` option.
```console
$ LINODE_DEBUG=1 docker-machine --debug create -d linode --linode-token=$LINODE_TOKEN machinename
```

75
machine/drivers/openstack.md
View File

@ -1,75 +0,0 @@
---
description: OpenStack driver for machine
keywords: machine, OpenStack, driver
title: OpenStack
---
Create machines on [OpenStack](https://www.openstack.org/software/)
Mandatory:
- `--openstack-auth-url`: Keystone service base URL.
- `--openstack-flavor-id` or `--openstack-flavor-name`: Identify the flavor used for the machine.
- `--openstack-image-id` or `--openstack-image-name`: Identify the image used for the machine.
## Usage
$ docker-machine create --driver openstack vm
## Options
- `--openstack-active-timeout`: The timeout in seconds until the OpenStack instance must be active.
- `--openstack-availability-zone`: The availability zone in which to launch the server.
- `--openstack-config-drive`: Whether OpenStack should mount a configuration drive for the machine.
- `--openstack-domain-name` or `--openstack-domain-id`: Domain to use for authentication (Keystone v3 only).
- `--openstack-endpoint-type`: Endpoint type can be `internalURL`, `adminURL`, or `publicURL`. It is a helper for the driver
to choose the right URL in the OpenStack service catalog. If not provided the default is `publicURL`.
- `--openstack-floatingip-pool`: The IP pool used to get a public IP can assign it to the machine. If there is an
IP address already allocated but not assigned to any machine, this IP is chosen and assigned to the machine. If
there is no IP address already allocated, a new IP is allocated and assigned to the machine.
- `--openstack-keypair-name`: Specify the existing Nova keypair to use.
- `--openstack-insecure`: Explicitly allow openstack driver to perform "insecure" SSL (https) requests. The server's certificate is not verified against any certificate authorities. This option should be used with caution.
- `--openstack-ip-version`: If the instance has both IPv4 and IPv6 address, you can select IP version. If not provided, defaults to `4`.
- `--openstack-net-name` or `--openstack-net-id`: Identify the private network the machine is connected to. If your OpenStack project contains only one private network it is used automatically.
- `--openstack-password`: User password. It can be omitted if the standard environment variable `OS_PASSWORD` is set.
- `--openstack-private-key-file`: Used with `--openstack-keypair-name`, associates the private key to the keypair.
- `--openstack-region`: The region to work on. Can be omitted if there is only one region on the OpenStack.
- `--openstack-sec-groups`: If security groups are available on your OpenStack you can specify a comma separated list
to use for the machine, such as `secgrp001,secgrp002`.
- `--openstack-ssh-port`: Customize the SSH port if the SSH server on the machine does not listen on the default port.
- `--openstack-ssh-user`: The username to use for SSH into the machine. If not provided defaults to `root`.
- `--openstack-tenant-name` or `--openstack-tenant-id`: Identify the tenant in which the machine is created.
- `--openstack-user-data-file`: File containing an OpenStack userdata script.
- `--openstack-username`: User identifier to authenticate with.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| ------------------------------- | ---------------------- | ----------- |
| `--openstack-active-timeout` | `OS_ACTIVE_TIMEOUT` | `200` |
| `--openstack-auth-url` | `OS_AUTH_URL` | - |
| `--openstack-availability-zone` | `OS_AVAILABILITY_ZONE` | - |
| `--openstack-config-drive` | `OS_CONFIG_DRIVE` | `false` |
| `--openstack-domain-id` | `OS_DOMAIN_ID` | - |
| `--openstack-domain-name` | `OS_DOMAIN_NAME` | - |
| `--openstack-endpoint-type` | `OS_ENDPOINT_TYPE` | `publicURL` |
| `--openstack-flavor-id` | `OS_FLAVOR_ID` | - |
| `--openstack-flavor-name` | `OS_FLAVOR_NAME` | - |
| `--openstack-floatingip-pool` | `OS_FLOATINGIP_POOL` | - |
| `--openstack-image-id` | `OS_IMAGE_ID` | - |
| `--openstack-image-name` | `OS_IMAGE_NAME` | - |
| `--openstack-insecure` | `OS_INSECURE` | `false` |
| `--openstack-ip-version` | `OS_IP_VERSION` | `4` |
| `--openstack-keypair-name` | `OS_KEYPAIR_NAME` | - |
| `--openstack-net-id` | `OS_NETWORK_ID` | - |
| `--openstack-net-name` | `OS_NETWORK_NAME` | - |
| `--openstack-password` | `OS_PASSWORD` | - |
| `--openstack-private-key-file` | `OS_PRIVATE_KEY_FILE` | - |
| `--openstack-region` | `OS_REGION_NAME` | - |
| `--openstack-sec-groups` | `OS_SECURITY_GROUPS` | - |
| `--openstack-ssh-port` | `OS_SSH_PORT` | `22` |
| `--openstack-ssh-user` | `OS_SSH_USER` | `root` |
| `--openstack-tenant-id` | `OS_TENANT_ID` | - |
| `--openstack-tenant-name` | `OS_TENANT_NAME` | - |
| `--openstack-user-data-file` | `OS_USER_DATA_FILE` | - |
| `--openstack-username` | `OS_USERNAME` | - |

50
machine/drivers/os-base.md
View File

@ -1,50 +0,0 @@
---
description: Identify active machines
keywords: machine, driver, base, operating system
title: Driver options and operating system defaults
---
When Docker Machine provisions containers on local network provider or with a
remote, cloud provider such as Amazon Web Services, you must define both the
driver for your provider and a base operating system. There are over 10
supported drivers and a generic driver for adding machines for other providers.
Each driver has a set of options specific to that provider. These options
provide information to machine such as connection credentials, ports, and so
forth. For example, to create an Azure machine:
Grab your subscription ID from the portal, then run `docker-machine create` with
these details:
```console
$ docker-machine create -d azure --azure-subscription-id="SUB_ID" --azure-subscription-cert="mycert.pem" A-VERY-UNIQUE-NAME
```
To see a list of providers and review the options available to a provider, see
the reference for that driver.
In addition to the provider, you have the option of identifying a base operating
system. It is an option because Docker Machine has defaults for both local and
remote providers. For local providers such as VirtualBox, Fusion, Hyper-V, and
so forth, the default base operating system is Boot2Docker. For cloud providers,
the base operating system is the latest Ubuntu LTS the provider supports.
| Operating System | Version | Notes |
| ----------------------- | ------- | ------------------ |
| Boot2Docker | 1.5+ | default for local |
| Ubuntu | 12.04+ | default for remote |
| RancherOS | 0.3+ | |
| Debian | 8.0+ | experimental |
| RedHat Enterprise Linux | 7.0+ | experimental |
| CentOS | 7+ | experimental |
| Fedora | 21+ | experimental |
To use a different base operating system on a remote provider, specify the
provider's image flag and one of its available images. For example, to select a
`debian-8-x64` image on DigitalOcean you would supply the
`--digitalocean-image=debian-8-x64` flag.
If you change the parent image for a provider, you may also need to change
the SSH user. For example, the default Red Hat AMI on EC2 expects the
SSH user to be `ec2-user`, so you need to specify this with
`--amazonec2-ssh-user ec2-user`.

41
machine/drivers/rackspace.md
View File

@ -1,41 +0,0 @@
---
description: Rackspace driver for machine
keywords: machine, Rackspace, driver
title: Rackspace
---
Create machines on [Rackspace cloud](https://www.rackspace.com/cloud)
## Usage
$ docker-machine create --driver rackspace --rackspace-username=user --rackspace-api-key=KEY --rackspace-region=region vm
## Options
- `--rackspace-active-timeout`: Rackspace active timeout
- `--rackspace-api-key`: **required** Rackspace API key.
- `--rackspace-docker-install`: Set if Docker needs to be installed on the machine.
- `--rackspace-endpoint-type`: Rackspace endpoint type (`adminURL`, `internalURL` or the default `publicURL`).
- `--rackspace-flavor-id`: Rackspace flavor ID. Default: General Purpose 1GB.
- `--rackspace-image-id`: Rackspace image ID. Default: Ubuntu 16.04 LTS (Xenial Xerus) (PVHVM).
- `--rackspace-region`: **required** Rackspace region name.
- `--rackspace-ssh-port`: SSH port for the newly booted machine.
- `--rackspace-ssh-user`: SSH user for the newly booted machine.
- `--rackspace-username`: **required** Rackspace account username.
The Rackspace driver uses `821ba5f4-712d-4ec8-9c65-a3fa4bc500f9` (Ubuntu 16.04 LTS) by default.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| ---------------------------- | -------------------- | -------------------------------------- |
| `--rackspace-active-timeout` | `OS_ACTIVE_TIMEOUT` | `300` |
| **`--rackspace-api-key`** | `OS_API_KEY` | - |
| `--rackspace-docker-install` | - | `true` |
| `--rackspace-endpoint-type` | `OS_ENDPOINT_TYPE` | `publicURL` |
| `--rackspace-flavor-id` | `OS_FLAVOR_ID` | `general1-1` |
| `--rackspace-image-id` | `OS_IMAGE_ID` | `821ba5f4-712d-4ec8-9c65-a3fa4bc500f9` |
| **`--rackspace-region`** | `OS_REGION_NAME` | `IAD` (Northern Virginia) |
| `--rackspace-ssh-port` | `OS_SSH_PORT` | `22` |
| `--rackspace-ssh-user` | `OS_SSH_USER` | `root` |
| **`--rackspace-username`** | `OS_USERNAME` | - |

55
machine/drivers/soft-layer.md
View File

@ -1,55 +0,0 @@
---
description: IBM Softlayer driver for machine
keywords: machine, IBM Softlayer, driver
title: IBM Softlayer
---
Create machines on [Softlayer](http://softlayer.com).
You need to generate an API key in the softlayer control panel.
[Retrieve your API key](http://knowledgelayer.softlayer.com/procedure/retrieve-your-api-key).
## Usage
$ docker-machine create --driver softlayer --softlayer-user=user --softlayer-api-key=KEY --softlayer-domain=domain vm
## Options
- `--softlayer-api-endpoint`: Change SoftLayer API endpoint.
- `--softlayer-api-key`: **required** API key for your user account.
- `--softlayer-cpu`: Number of CPUs for the machine.
- `--softlayer-disk-size`: A value of `0` sets the SoftLayer default.
- `--softlayer-domain`: **required** Domain name for the machine.
- `--softlayer-hostname`: Hostname for the machine.
- `--softlayer-hourly-billing`: Specifies that hourly billing should be used, otherwise monthly billing is used.
- `--softlayer-image`: OS Image to use.
- `--softlayer-local-disk`: Use local machine disk instead of SoftLayer SAN.
- `--softlayer-memory`: Memory for host in MB.
- `--softlayer-network-max-speed`: Speed of network uplinks in Mbps (1000, 100, 10).
- `--softlayer-private-net-only`: Disable public networking.
- `--softlayer-private-vlan-id`: Your private VLAN ID.
- `--softlayer-public-vlan-id`: Your public VLAN ID.
- `--softlayer-region`: SoftLayer region.
- `--softlayer-user`: **required** Username for your SoftLayer account, API key needs to match this user.
The SoftLayer driver uses `UBUNTU_LATEST` as the image type by default.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| ------------------------------ | --------------------------- | --------------------------- |
| `--softlayer-api-endpoint` | `SOFTLAYER_API_ENDPOINT` | `api.softlayer.com/rest/v3` |
| **`--softlayer-api-key`** | `SOFTLAYER_API_KEY` | - |
| `--softlayer-cpu` | `SOFTLAYER_CPU` | `1` |
| `--softlayer-disk-size` | `SOFTLAYER_DISK_SIZE` | `0` |
| **`--softlayer-domain`** | `SOFTLAYER_DOMAIN` | - |
| `--softlayer-hostname` | `SOFTLAYER_HOSTNAME` | `docker` |
| `--softlayer-hourly-billing` | `SOFTLAYER_HOURLY_BILLING` | `false` |
| `--softlayer-image` | `SOFTLAYER_IMAGE` | `UBUNTU_LATEST` |
| `--softlayer-local-disk` | `SOFTLAYER_LOCAL_DISK` | `false` |
| `--softlayer-memory` | `SOFTLAYER_MEMORY` | `1024` |
| `--softlayer-private-net-only` | `SOFTLAYER_PRIVATE_NET` | `false` |
| `--softlayer-private-vlan-id` | `SOFTLAYER_PRIVATE_VLAN_ID` | `0` |
| `--softlayer-public-vlan-id` | `SOFTLAYER_PUBLIC_VLAN_ID` | `0` |
| `--softlayer-region` | `SOFTLAYER_REGION` | `dal01` |
| **`--softlayer-user`** | `SOFTLAYER_USER` | - |

106
machine/drivers/virtualbox.md
View File

@ -1,106 +0,0 @@
---
description: Oracle VirtualBox driver for machine
keywords: machine, Oracle VirtualBox, driver
title: Oracle VirtualBox
---
Create machines locally using [VirtualBox](https://www.virtualbox.org/).
This driver requires VirtualBox 5+ to be installed on your host.
Using VirtualBox 4.3+ should work but emits a warning. Older versions
do not work.
## Usage
$ docker-machine create --driver=virtualbox vbox-test
You can create an entirely new machine or you can convert a Boot2Docker VM into
a machine by importing the VM. To convert a Boot2Docker VM, you'd use the following
command:
$ docker-machine create -d virtualbox --virtualbox-import-boot2docker-vm boot2docker-vm b2d
The size of the VM's disk can be configured this way:
$ docker-machine create -d virtualbox --virtualbox-disk-size "100000" large
## Options
- `--virtualbox-boot2docker-url`: The URL of the boot2docker image. Defaults to the latest available version.
- `--virtualbox-cpu-count`: Number of CPUs to use to create the VM. Defaults to single CPU.
- `--virtualbox-disk-size`: Size of disk for the host in MB.
- `--virtualbox-host-dns-resolver`: Use the host DNS resolver. (Boolean value, defaults to false)
- `--virtualbox-hostonly-cidr`: The CIDR of the host only adapter.
- `--virtualbox-hostonly-nicpromisc`: Host Only Network Adapter Promiscuous Mode. Possible options are deny , allow-vms, allow-all
- `--virtualbox-hostonly-nictype`: Host Only Network Adapter Type. Possible values are '82540EM' (Intel PRO/1000), 'Am79C973' (PCnet-FAST III), and 'virtio' Paravirtualized network adapter.
- `--virtualbox-hostonly-no-dhcp`: Disable the Host Only DHCP Server
- `--virtualbox-import-boot2docker-vm`: The name of a Boot2Docker VM to import.
- `--virtualbox-memory`: Size of memory for the host in MB.
- `--virtualbox-nat-nictype`: Specify the NAT Network Adapter Type. Possible values are '82540EM' (Intel PRO/1000), 'Am79C973' (PCnet-FAST III) and 'virtio' Paravirtualized network adapter.
- `--virtualbox-no-dns-proxy`: Disable proxying all DNS requests to the host (Boolean value, default to false)
- `--virtualbox-no-share`: Disable the mount of your home directory
- `--virtualbox-no-vtx-check`: Disable checking for the availability of hardware virtualization before the vm is started
- `--virtualbox-share-folder`: Mount the specified directory instead of the default home location.
- `--virtualbox-ui-type`: Specify the UI Type: (gui|sdl|headless|separate)
The `--virtualbox-boot2docker-url` flag takes a few different forms. By
default, if no value is specified for this flag, Machine checks locally for
a boot2docker ISO. If one is found, it is used as the ISO for the
created machine. If one is not found, the latest ISO release available on
[boot2docker/boot2docker](https://github.com/boot2docker/boot2docker) is
downloaded and stored locally for future use. Therefore, you must run
`docker-machine upgrade` deliberately on a machine if you wish to update the "cached"
boot2docker ISO.
This is the default behavior (when `--virtualbox-boot2docker-url=""`), but the
option also supports specifying ISOs by the `http://` and `file://` protocols.
`file://` looks at the path specified locally to locate the ISO: for
instance, you could specify `--virtualbox-boot2docker-url
file://$HOME/Downloads/rc.iso` to test out a release candidate ISO that you have
downloaded already. You could also just get an ISO straight from the Internet
using the `http://` form.
To customize the host only adapter, you can use the `--virtualbox-hostonly-cidr`
flag. This specifies the host IP and Machine calculates the VirtualBox
DHCP server address (a random IP on the subnet between `.1` and `.25`) so
it does not clash with the specified host IP.
Machine specifies the DHCP lower bound to `.100` and the upper bound
to `.254`. For example, a specified CIDR of `192.168.24.1/24` would have a
DHCP server between `192.168.24.2-25`, a lower bound of `192.168.24.100` and
upper bound of `192.168.24.254`.
With the flag `--virtualbox-share-folder`, you can specify which folder the host
shares with the created machine. The format is `local-folder:machine-folder`.
For example, `\\?\C:\docker-share:\home\users\`. if you specify the flag with the
docker-toolbox using docker-machine from a Windows cmd, it looks like
`C:\docker-share\\:/home/users`. The `:` sign needs to be escaped.
#### Environment variables and default values
| CLI option | Environment variable | Default |
|:-------------------------------------|:-----------------------------------|:-------------------------|
| `--virtualbox-boot2docker-url` | `VIRTUALBOX_BOOT2DOCKER_URL` | _Latest boot2docker url_ |
| `--virtualbox-cpu-count` | `VIRTUALBOX_CPU_COUNT` | `1` |
| `--virtualbox-disk-size` | `VIRTUALBOX_DISK_SIZE` | `20000` |
| `--virtualbox-host-dns-resolver` | `VIRTUALBOX_HOST_DNS_RESOLVER` | `false` |
| `--virtualbox-hostonly-cidr` | `VIRTUALBOX_HOSTONLY_CIDR` | `192.168.99.1/24` |
| `--virtualbox-hostonly-nicpromisc` | `VIRTUALBOX_HOSTONLY_NIC_PROMISC` | `deny` |
| `--virtualbox-hostonly-nictype` | `VIRTUALBOX_HOSTONLY_NIC_TYPE` | `82540EM` |
| `--virtualbox-hostonly-no-dhcp` | `VIRTUALBOX_HOSTONLY_NO_DHCP` | `false` |
| `--virtualbox-import-boot2docker-vm` | `VIRTUALBOX_BOOT2DOCKER_IMPORT_VM` | `boot2docker-vm` |
| `--virtualbox-memory` | `VIRTUALBOX_MEMORY_SIZE` | `1024` |
| `--virtualbox-nat-nictype` | `VIRTUALBOX_NAT_NICTYPE` | `82540EM` |
| `--virtualbox-no-dns-proxy` | `VIRTUALBOX_NO_DNS_PROXY` | `false` |
| `--virtualbox-no-share` | `VIRTUALBOX_NO_SHARE` | `false` |
| `--virtualbox-no-vtx-check` | `VIRTUALBOX_NO_VTX_CHECK` | `false` |
| `--virtualbox-share-folder` | `VIRTUALBOX_SHARE_FOLDER` | - |
| `--virtualbox-ui-type` | `VIRTUALBOX_UI_TYPE` | `headless` |
## Known Issues
Vboxfs suffers from a [longstanding bug](https://www.virtualbox.org/ticket/9069)
causing [sendfile(2)](http://linux.die.net/man/2/sendfile) to serve cached file
contents.
This causes problems when using a web server such as Nginx to serve
static files from a shared volume. For development environments, a good
workaround is to disable sendfile in your server configuration.

51
machine/drivers/vm-cloud.md
View File

@ -1,51 +0,0 @@
---
description: VMware vCloud Air driver for machine
keywords: machine, VMware vCloud Air, driver
title: VMware vCloud Air
---
Creates machines on [vCloud Air](https://cloudsolutions.vmware.com) subscription service.
You need an account within an existing subscription of vCloud Air VPC or
Dedicated Cloud.
## Usage
$ docker-machine create --driver vmwarevcloudair --vmwarevcloudair-username=user --vmwarevcloudair-password=SECRET vm
## Options
- `--vmwarevcloudair-catalog`: Catalog.
- `--vmwarevcloudair-catalogitem`: Catalog Item.
- `--vmwarevcloudair-computeid`: Compute ID (if using Dedicated Cloud).
- `--vmwarevcloudair-cpu-count`: VM CPU Count.
- `--vmwarevcloudair-docker-port`: Docker port.
- `--vmwarevcloudair-edgegateway`: Organization Edge Gateway.
- `--vmwarevcloudair-memory-size`: VM Memory Size in MB.
- `--vmwarevcloudair-orgvdcnetwork`: Organization VDC Network to attach.
- `--vmwarevcloudair-password`: **required** vCloud Air Password.
- `--vmwarevcloudair-provision`: Install Docker binaries.
- `--vmwarevcloudair-publicip`: Org Public IP to use.
- `--vmwarevcloudair-ssh-port`: SSH port.
- `--vmwarevcloudair-username`: **required** vCloud Air Username.
- `--vmwarevcloudair-vdcid`: Virtual Data Center ID.
The VMware vCloud Air driver uses the `Ubuntu Server 12.04 LTS (amd64 20140927)` image by default.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| --------------------------------- | ------------------------- | ------------------------------------------ |
| `--vmwarevcloudair-catalog` | `VCLOUDAIR_CATALOG` | `Public Catalog` |
| `--vmwarevcloudair-catalogitem` | `VCLOUDAIR_CATALOGITEM` | `Ubuntu Server 12.04 LTS (amd64 20140927)` |
| `--vmwarevcloudair-computeid` | `VCLOUDAIR_COMPUTEID` | - |
| `--vmwarevcloudair-cpu-count` | `VCLOUDAIR_CPU_COUNT` | `1` |
| `--vmwarevcloudair-docker-port` | `VCLOUDAIR_DOCKER_PORT` | `2376` |
| `--vmwarevcloudair-edgegateway` | `VCLOUDAIR_EDGEGATEWAY` | `<vdcid>` |
| `--vmwarevcloudair-memory-size` | `VCLOUDAIR_MEMORY_SIZE` | `2048` |
| `--vmwarevcloudair-orgvdcnetwork` | `VCLOUDAIR_ORGVDCNETWORK` | `<vdcid>-default-routed` |
| **`--vmwarevcloudair-password`** | `VCLOUDAIR_PASSWORD` | - |
| `--vmwarevcloudair-provision` | `VCLOUDAIR_PROVISION` | `true` |
| `--vmwarevcloudair-publicip` | `VCLOUDAIR_PUBLICIP` | - |
| `--vmwarevcloudair-ssh-port` | `VCLOUDAIR_SSH_PORT` | `22` |
| **`--vmwarevcloudair-username`** | `VCLOUDAIR_USERNAME` | - |
| `--vmwarevcloudair-vdcid` | `VCLOUDAIR_VDCID` | - |

32
machine/drivers/vm-fusion.md
View File

@ -1,32 +0,0 @@
---
description: VMware Fusion driver for machine
keywords: machine, VMware Fusion, driver
title: VMware Fusion
---
Creates machines locally on [VMware Fusion](https://www.vmware.com/products/fusion.html). Requires VMware Fusion to be installed.
## Usage
$ docker-machine create --driver vmwarefusion vm
## Options
- `--vmwarefusion-boot2docker-url`: URL for boot2docker image.
- `--vmwarefusion-cpu-count`: Number of CPUs for the machine (-1 to use the number of CPUs available)
- `--vmwarefusion-disk-size`: Size of disk for host VM (in MB).
- `--vmwarefusion-memory-size`: Size of memory for host VM (in MB).
- `--vmwarefusion-no-share`: Disable the mount of your home directory.
The VMware Fusion driver uses the latest boot2docker image.
See [frapposelli/boot2docker](https://github.com/boot2docker/boot2docker)
#### Environment variables and default values
| CLI option | Environment variable | Default |
| -------------------------------- | ------------------------ | ------------------------ |
| `--vmwarefusion-boot2docker-url` | `FUSION_BOOT2DOCKER_URL` | _Latest boot2docker url_ |
| `--vmwarefusion-cpu-count` | `FUSION_CPU_COUNT` | `1` |
| `--vmwarefusion-disk-size` | `FUSION_DISK_SIZE` | `20000` |
| `--vmwarefusion-memory-size` | `FUSION_MEMORY_SIZE` | `1024` |
| `--vmwarefusion-no-share` | `FUSION_NO_SHARE` | `false` |

52
machine/drivers/vsphere.md
View File

@ -1,52 +0,0 @@
---
description: VMware vSphere driver for machine
keywords: machine, VMware vSphere, driver
title: VMware vSphere
---
Creates machines on a [VMware vSphere](https://www.vmware.com/products/vsphere.html)
Virtual Infrastructure. The machine must have a working vSphere ESXi
installation. You can use a paid license or free 60 day trial license. Your
installation may also include an optional VCenter server.
## Usage
$ docker-machine create --driver vmwarevsphere --vmwarevsphere-username=user --vmwarevsphere-password=SECRET vm
## Options
- `--vmwarevsphere-boot2docker-url`: URL for boot2docker image.
- `--vmwarevsphere-cpu-count`: CPU number for Docker VM.
- `--vmwarevsphere-datacenter`: Datacenter for Docker VM (must be set to `ha-datacenter` when connecting to a single host).
- `--vmwarevsphere-datastore`: Datastore for Docker VM.
- `--vmwarevsphere-disk-size`: Size of disk for Docker VM (in MB).
- `--vmwarevsphere-folder`: vSphere folder for the docker VM. This folder must already exist in the datacenter.
- `--vmwarevsphere-hostsystem`: vSphere compute resource where the docker VM is instantiated. This can be omitted if using a cluster with DRS.
- `--vmwarevsphere-memory-size`: Size of memory for Docker VM (in MB).
- `--vmwarevsphere-network`: Network where the Docker VM is attached.
- `--vmwarevsphere-password`: **required** vSphere Password.
- `--vmwarevsphere-pool`: Resource pool for Docker VM.
- `--vmwarevsphere-username`: **required** vSphere Username.
- `--vmwarevsphere-vcenter-port`: vSphere Port for vCenter.
- `--vmwarevsphere-vcenter`: IP/hostname for vCenter (or ESXi if connecting directly to a single host).
The VMware vSphere driver uses the latest boot2docker image.
#### Environment variables and default values
| CLI option | Environment variable | Default |
| --------------------------------- | ------------------------- | ------------------------ |
| `--vmwarevsphere-boot2docker-url` | `VSPHERE_BOOT2DOCKER_URL` | _Latest boot2docker url_ |
| `--vmwarevsphere-cpu-count` | `VSPHERE_CPU_COUNT` | `2` |
| `--vmwarevsphere-datacenter` | `VSPHERE_DATACENTER` | - |
| `--vmwarevsphere-datastore` | `VSPHERE_DATASTORE` | - |
| `--vmwarevsphere-disk-size` | `VSPHERE_DISK_SIZE` | `20000` |
| `--vmwarevsphere-hostsystem` | `VSPHERE_HOSTSYSTEM` | - |
| `--vmwarevsphere-memory-size` | `VSPHERE_MEMORY_SIZE` | `2048` |
| `--vmwarevsphere-network` | `VSPHERE_NETWORK` | - |
| **`--vmwarevsphere-password`** | `VSPHERE_PASSWORD` | - |
| `--vmwarevsphere-pool` | `VSPHERE_POOL` | - |
| **`--vmwarevsphere-username`** | `VSPHERE_USERNAME` | - |
| `--vmwarevsphere-vcenter-port` | `VSPHERE_VCENTER_PORT` | 443 |
| `--vmwarevsphere-vcenter` | `VSPHERE_VCENTER` | - |
| `--vmwarevsphere-folder` | `VSPHERE_FOLDER` | - |

212
machine/examples/aws.md
View File

@ -1,212 +0,0 @@
---
description: Using Docker Machine to provision hosts on AWS
keywords: docker, machine, cloud, aws
title: Amazon Web Services (AWS) EC2 example
---
Follow along with this example to create a Dockerized [Amazon Web Services (AWS)](https://aws.amazon.com/) EC2 instance.
### Step 1. Sign up for AWS and configure credentials
1. If you are not already an AWS user, sign up for [AWS](https://aws.amazon.com/) to create an account and get root access to EC2 cloud computers.
If you have an Amazon account, you can use it as your root user account.
2. Create an IAM (Identity and Access Management) administrator user, an admin group, and a key pair associated with a region.
From the AWS menus, select **Services** > **IAM** to get started.
To create machines on AWS, you must supply two parameters:
* an AWS Access Key ID
* an AWS Secret Access Key
See the AWS documentation on [Setting Up with Amazon EC2](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html). Follow the steps for "Create an IAM User" and "Create a Key Pair".
### Step 2. Use Machine to create the instance
1. Optionally, create an AWS credential file.
You can create an `~/.aws/credentials` file to hold your AWS keys so that
you don't need to type them every time you run the `docker-machine create`
command. Here is an example of a credentials file.
```conf
[default]
aws_access_key_id = AKID1234567890
aws_secret_access_key = MY-SECRET-KEY
```
2. Run `docker-machine create` with the `amazonec2` driver, credentials, inbound
port, region, and a name for the new instance. For example:
```console
$ docker-machine create --driver amazonec2 --amazonec2-open-port 8000 --amazonec2-region us-west-1 aws-sandbox
```
> **Note**: For all aws create flags, run: `docker-machine create --driver amazonec2 --help`
**Use aws credentials file**
If you set your keys in a credentials file, the command looks like this to
create an instance called `aws-sandbox`:
```console
$ docker-machine create --driver amazonec2 aws-sandbox
```
**Specify keys at the command line**
If you don't have a credentials file, you can use the flags
`--amazonec2-access-key` and `--amazonec2-secret-key` on the command line:
```console
$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******* aws-sandbox
```
**Expose a port**
To expose an inbound port to the new machine, use the flag, `--amazonec2-open-port`:
```console
$ docker-machine create --driver amazonec2 --amazonec2-open-port 8000 aws-sandbox
```
**Specify a region**
By default, the driver creates new instances in region us-east-1 (North
Virginia). You can specify a different region by using the
`--amazonec2-region` flag. For example, create aws-sandbox in us-west-1
(Northern California).
```console
$ docker-machine create --driver amazonec2 --amazonec2-region us-west-1 aws-sandbox
```
3. Go to the AWS EC2 Dashboard to view the new instance.
Log into AWS with your IAM credentials, and navigate to your EC2 Running Instances.
![instance on AWS EC2 Dashboard](../img/aws-instance-east.png)
> **Note**: To ensure that you see your new instance, select your region from
> the menu in the upper right. If you did not specify a region as part of
> `docker-machine create` (with the optional `--amazonec2-region` flag), select
> the default, US East (N. Virginia).
4. Ensure that your new machine is the active host.
```console
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
aws-sandbox * amazonec2 Running tcp://52.90.113.128:2376 v1.10.0
default - virtualbox Running tcp://192.168.99.100:2376 v1.10.0-rc4
digi-sandbox - digitalocean Running tcp://104.131.43.236:2376 v1.9.1
```
The new `aws-sandbox` instance is running and is the active host as
indicated by the asterisk (\*). When you create a new machine, your command
shell automatically connects to it. You can also check active status by
running `docker-machine active`.
> **Note**: If your new machine is not the active host, connect to it by
running `docker-machine env aws-sandbox` and the returned eval command:
`eval $(docker-machine env aws-sandbox)`.
5. Inspect the remote host. For example, `docker-machine ip <machine>` returns
the host IP address and `docker-machine inspect <machine>` lists all the
details.
```console
$ docker-machine ip aws-sandbox
192.168.99.100
$ docker-machine inspect aws-sandbox
{
"ConfigVersion": 3,
"Driver": {
"IPAddress": "52.90.113.128",
"MachineName": "aws-sandbox",
"SSHUser": "ubuntu",
"SSHPort": 22,
...
}
}
```
### Step 3. Run Docker commands on the new instance
You can run docker commands from a local terminal to the active docker machine.
1. Run docker on the active docker machine by downloading and running the
hello-world image:
```console
$ docker run hello-world
```
2. Ensure that you ran hello-world on aws-sandbox (and not localhost or some
other machine):
Log on to aws-sandbox with ssh and list all containers. You should see
hello-world (with a recent exited status):
```console
$ docker-machine ssh aws-sandbox
$ sudo docker container ls -a
$ exit
```
Log off aws-sandbox and unset this machine as active. Then list images
again. You should not see hello-world (at least not with the same exited
status):
```console
$ eval $(docker-machine env -u)
$ docker container ls -a
```
3. Reset aws-sandbox as the active docker machine:
```console
$ eval $(docker-machine env aws-sandbox)
```
For a more interesting test, run a Dockerized webserver on your new machine.
> **Note**: In this example, we use port `8000` which we added to the
> docker-machine AWS Security Group during `docker-machine create`. To run your
> container on another port, update the security group to reflect that.
In this example, the `-p` option is used to expose port 80 from the `nginx`
container and make it accessible on port `8000` of the `aws-sandbox` host:
```console
$ docker run -d -p 8000:80 --name webserver kitematic/hello-world-nginx
Unable to find image 'kitematic/hello-world-nginx:latest' locally
latest: Pulling from kitematic/hello-world-nginx
a285d7f063ea: Pull complete
2d7baf27389b: Pull complete
...
Digest: sha256:ec0ca6dcb034916784c988b4f2432716e2e92b995ac606e080c7a54b52b87066
Status: Downloaded newer image for kitematic/hello-world-nginx:latest
942dfb4a0eaae75bf26c9785ade4ff47ceb2ec2a152be82b9d7960e8b5777e65
```
In a web browser, go to `http://<host_ip>:8000` to bring up the webserver
home page. You got the `<host_ip>` from the output of the `docker-machine ip <machine>`
command you ran in a previous step. Use the port you exposed in the
`docker run` command.
![nginx webserver](../img/nginx-webserver.png)
### Step 4. Use Machine to remove the instance
To remove an instance and all of its containers and images, first stop the
machine, then use `docker-machine rm`.
## Where to go next
- [Understand Machine concepts](../concepts.md)
- [Docker Machine driver reference](../drivers/index.md)
- [Docker Machine subcommand reference](../reference/index.md)

7
machine/examples/index.md
View File

@ -1,7 +0,0 @@
---
description: Examples of cloud installs
keywords: docker, machine, amazonec2, azure, digitalocean, google, openstack, rackspace, softlayer, virtualbox, vmwarefusion, vmwarevcloudair, vmwarevsphere, exoscale
title: Learn by example
---
- [DigitalOcean Example](ocean.md)
- [AWS Example](aws.md)

146
machine/examples/ocean.md
View File

@ -1,146 +0,0 @@
---
description: Using Docker Machine to provision hosts on DigitalOcean
keywords: docker, machine, cloud, digitalocean
title: DigitalOcean example
---
Follow along with this example to create a Dockerized [DigitalOcean](https://digitalocean.com) Droplet (cloud host).
### Step 1. Create a DigitalOcean account
If you have not done so already, go to [DigitalOcean](https://digitalocean.com), create an account, and log in.
### Step 2. Generate a personal access token
To generate your access token:
1. Go to the DigitalOcean administrator console and click **API** in the header.
![Click API in DigitalOcean console](../img/ocean_click_api.png)
2. Click **Generate new token** to get to the token generator.
![Generate token](../img/ocean_gen_token.png)
3. Give the token a descriptive name, make sure the **Write (Optional)** checkbox is checked, and click **Generate Token**.
![Name and generate token](../img/ocean_token_create.png)
4. Grab (copy to clipboard) the generated big long hex string and store it somewhere safe.
![Copy and save personal access token](../img/ocean_save_token.png)
This is the personal access token used in the next step to create your cloud server.
### Step 3. Use Machine to create the Droplet
1. Run `docker-machine create` with the `digitalocean` driver and pass your key to the `--digitalocean-access-token` flag, along with a name for the new cloud server.
For this example, the new Droplet is called `docker-sandbox`:
```none
$ docker-machine create --driver digitalocean --digitalocean-access-token xxxxx docker-sandbox
Running pre-create checks...
Creating machine...
(docker-sandbox) OUT | Creating SSH key...
(docker-sandbox) OUT | Creating Digital Ocean droplet...
(docker-sandbox) OUT | Waiting for IP address to be assigned to the Droplet...
Waiting for machine to be running, this may take a few minutes...
Machine is running, waiting for SSH to be available...
Detecting operating system of created instance...
Detecting the provisioner...
Provisioning created instance...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
To see how to connect Docker to this machine, run: docker-machine env docker-sandbox
```
When the Droplet is created, Docker generates a unique SSH key and stores it on your local system in `~/.docker/machines`. Initially, this is used to provision the host. Later, it's used under the hood to access the Droplet directly with the `docker-machine ssh` command. Docker Engine is installed on the cloud server and the daemon is configured to accept remote connections over TCP using TLS for authentication.
2. Go to the DigitalOcean console to view the new Droplet.
![Droplet in DigitalOcean created with Machine](../img/ocean_droplet.png)
3. At the command terminal, run `docker-machine ls`.
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM
default - virtualbox Running tcp://192.168.99.100:2376
docker-sandbox * digitalocean Running tcp://45.55.139.48:2376
The new `docker-sandbox` machine is running, and it is the active host as
indicated by the asterisk (\*). When you create a new machine, your command
shell automatically connects to it. If for some reason your new machine is
not the active host, run `docker-machine env docker-sandbox`, followed by
`eval $(docker-machine env docker-sandbox)` to connect to it.
### Step 4. Run Docker commands on the Droplet
1. Run some `docker-machine` commands to inspect the remote host. For example, `docker-machine ip <machine>` gets the host IP address and `docker-machine inspect <machine>` lists all the details.
$ docker-machine ip docker-sandbox
104.131.43.236
$ docker-machine inspect docker-sandbox
{
"ConfigVersion": 3,
"Driver": {
"IPAddress": "104.131.43.236",
"MachineName": "docker-sandbox",
"SSHUser": "root",
"SSHPort": 22,
"SSHKeyPath": "/Users/samanthastevens/.docker/machine/machines/docker-sandbox/id_rsa",
"StorePath": "/Users/samanthastevens/.docker/machine",
"SwarmMaster": false,
"SwarmHost": "tcp://0.0.0.0:3376",
"SwarmDiscovery": "",
...
2. Verify Docker Engine is installed correctly by running `docker` commands.
Start with something basic like `docker run hello-world`, or for a more interesting test, run a Dockerized webserver on your new remote machine.
In this example, the `-p` option is used to expose port 80 from the `nginx` container and make it accessible on port `8000` of the `docker-sandbox` host.
$ docker run -d -p 8000:80 --name webserver kitematic/hello-world-nginx
Unable to find image 'kitematic/hello-world-nginx:latest' locally
latest: Pulling from kitematic/hello-world-nginx
a285d7f063ea: Pull complete
2d7baf27389b: Pull complete
...
Digest: sha256:ec0ca6dcb034916784c988b4f2432716e2e92b995ac606e080c7a54b52b87066
Status: Downloaded newer image for kitematic/hello-world-nginx:latest
942dfb4a0eaae75bf26c9785ade4ff47ceb2ec2a152be82b9d7960e8b5777e65
In a web browser, go to `http://<host_ip>:8000` to bring up the webserver home page. You got the `<host_ip>` from the output of the `docker-machine ip <machine>` command you ran in a previous step. Use the port you exposed in the `docker run` command.
![nginx webserver](../img/nginx-webserver.png)
### Step 5. Use Machine to remove the Droplet
To remove a host and all of its containers and images, first stop the machine, then use `docker-machine rm`:
$ docker-machine stop docker-sandbox
$ docker-machine rm docker-sandbox
Do you really want to remove "docker-sandbox"? (y/n): y
Successfully removed docker-sandbox
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM
default * virtualbox Running tcp:////xxx.xxx.xx.xxx:xxxx
If you monitor the DigitalOcean console while you run these commands, notice
that it updates first to reflect that the Droplet was stopped, and then removed.
If you create a host with Docker Machine, but remove it through the cloud
provider console, Machine loses track of the server status. Use the
`docker-machine rm` command for hosts you create with `docker-machine create`.
## Where to go next
- [Understand Machine concepts](../concepts.md)
- [Docker Machine driver reference](../drivers/index.md)
- [Docker Machine subcommand reference](../reference/index.md)
- [Create containers for your Docker Machine](../../get-started/02_our_app.md)

124
machine/get-started-cloud.md
View File

@ -1,124 +0,0 @@
---
description: Using Docker Machine to provision hosts on cloud providers
keywords: docker, machine, amazonec2, azure, digitalocean, google, openstack, rackspace, softlayer, virtualbox, vmwarefusion, vmwarevcloudair, vmwarevsphere, exoscale
title: Use Docker Machine to provision hosts on cloud providers
---
Docker Machine driver plugins are available for many cloud platforms, so you can
use Machine to provision cloud hosts. When you use Docker Machine for
provisioning, you create cloud hosts with Docker Engine installed on them.
Install and run Docker Machine, and create an account with the
cloud provider.
Then you provide account verification, security credentials, and configuration
options for the providers as flags to `docker-machine create`. The flags are
unique for each cloud-specific driver. For instance, to pass a DigitalOcean
access token you use the `--digitalocean-access-token` flag. Take a look at the
examples below for DigitalOcean and AWS.
## Examples
### DigitalOcean
For DigitalOcean, this command creates a Droplet (cloud host) called
"docker-sandbox".
```console
$ docker-machine create --driver digitalocean --digitalocean-access-token xxxxx docker-sandbox
```
For a step-by-step guide on using Machine to create Docker hosts on Digital
Ocean, see the [DigitalOcean Example](examples/ocean.md).
### Amazon Web Services (AWS)
For AWS EC2, this command creates an instance called "aws-sandbox":
```console
$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******* aws-sandbox
```
For a step-by-step guide on using Machine to create Dockerized AWS instances,
see the [Amazon Web Services (AWS) example](examples/aws.md).
## The docker-machine create command
The `docker-machine create` command typically requires that you specify, at a
minimum:
* `--driver` - to indicate the provider on which to create the
machine (VirtualBox, DigitalOcean, AWS, and so on)
* Account verification and security credentials (for cloud providers),
specific to the cloud service you are using
* `<machine>` - name of the host you want to create
For convenience, `docker-machine` uses sensible defaults for choosing
settings such as the image that the server is based on, but you override the
defaults using the respective flags, such as `--digitalocean-image`. This is
useful if, for example, you want to create a cloud server with a lot of memory
and CPUs, rather than the default behavior of creating smaller servers.
For a full list of the flags/settings available and their defaults, see the
output of `docker-machine create -h` at the command line, the
[create](reference/create.md){: target="_blank" rel="noopener" class="_" } command in
the Machine [command line reference](reference/index.md){:
target="_blank" rel="noopener" class="_" }, and [driver options and operating system defaults](drivers/os-base.md){: target="_blank" rel="noopener" class="_" }
in the Machine driver reference.
## Drivers for cloud providers
When you install Docker Machine, you get a set of drivers for various cloud
providers (like Amazon Web Services, DigitalOcean, or Microsoft Azure) and
local providers (like Oracle VirtualBox, VMWare Fusion, or Microsoft Hyper-V).
See [Docker Machine driver reference](drivers/index.md){:target="_blank" rel="noopener" class="_"}
for details on the drivers, including required flags and configuration options
(which vary by provider).
## 3rd-party driver plugins
Several Docker Machine driver plugins for use with other cloud platforms are
available from 3rd party contributors. These are use-at-your-own-risk plugins,
not maintained by or formally associated with Docker.
See [Available driver plugins](https://github.com/docker/docker.github.io/blob/master/machine/AVAILABLE_DRIVER_PLUGINS.md){:target="_blank" rel="noopener" class="_"}.
## Add a host without a driver
You can register an already existing docker host by passing the daemon url. With that, you can have the same workflow as on a host provisioned by docker-machine.
$ docker-machine create --driver none --url=tcp://50.134.234.20:2376 custombox
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
custombox * none Running tcp://50.134.234.20:2376
## Use Machine to provision Docker Swarm clusters
> Swarm mode supersedes Docker Machine provisioning of swarm clusters
>
> In previous releases, Docker Machine was used to provision swarm
> clusters, but this is legacy. [Swarm mode](../engine/swarm/index.md), built
> into Docker Engine, supersedes Machine provisioning of swarm clusters. The
> topics below show you how to get started with the new swarm mode.
{: .important}
You can use Docker Machine to create local virtual hosts on which to deploy
and test [swarm mode](../engine/swarm/index.md) clusters.
Good places to start working with Docker Machine and swarm mode are these
tutorials:
* [Get started with Docker](../get-started/index.md)
* [Getting started with swarm mode](../engine/swarm/swarm-tutorial/index.md)
## Where to go next
- Example: Provision Dockerized [DigitalOcean Droplets](examples/ocean.md)
- Example: Provision Dockerized [AWS EC2 Instances](examples/aws.md)
- [Understand Machine concepts](concepts.md)
- [Docker Machine driver reference](drivers/index.md)
- [Docker Machine subcommand reference](reference/index.md)

358
machine/get-started.md
View File

@ -1,358 +0,0 @@
---
description: Get started with Docker Machine and a local VM
keywords: machine, virtualbox
title: Get started with Docker Machine and a local VM
---
Let's take a look at using `docker-machine` to create, use, and manage a
Docker host inside of a local virtual machine.
> **Note**
>
> Docker Machine is no longer included in the Docker Desktop installer. You can download it separately from the [docker/machine](https://github.com/docker/machine/releases/){: target="_blank" rel="noopener" class="_" } release
page on GitHub.
## Prerequisite information
With the advent of [Docker Desktop for Mac](../desktop/mac/index.md) and
[Docker Desktop for Windows](../desktop/windows/index.md), we recommend that you use these for your
primary Docker workflows. You can use these applications to run Docker natively
on your local system without using Docker Machine at all.
For now, however, if you want to create _multiple_ local machines, you still
need Docker Machine to create and manage machines for multi-node
experimentation.
The new solutions come with their own native virtualization solutions rather
than Oracle VirtualBox, so keep the following considerations in mind when using
Machine to create local VMs.
* **Docker Desktop for Mac** - You can use `docker-machine create` with the `virtualbox` driver to create additional local machines.
* **Docker Desktop for Windows** - You can use `docker-machine create` with the `hyperv` driver to create additional local machines.
#### If you are using Docker Desktop for Windows
Docker Desktop for Windows uses [Microsoft
Hyper-V](https://msdn.microsoft.com/en-us/virtualization/hyperv_on_windows/windows_welcome)
for virtualization, and Hyper-V is not compatible with Oracle VirtualBox.
Therefore, you cannot run the two solutions simultaneously. But you can still
use `docker-machine` to create more local VMs by using the Microsoft Hyper-V
driver.
The prerequisites are:
* Have Docker Desktop for Windows installed, and running (which requires that virtualization and Hyper-V are enabled, as described in [What to know before you install Docker Desktop for Windows](../desktop/windows/install.md#system-requirements)).
* Set up the Hyper-V driver to use an external virtual network switch See
the [Docker Machine driver for Microsoft Hyper-V](drivers/hyper-v.md) topic,
which includes an [example](drivers/hyper-v.md#example) of how to do this.
#### If you are using Docker Desktop for Mac
Docker Desktop for Mac uses [HyperKit](https://github.com/docker/HyperKit/), a
lightweight macOS virtualization solution built on top of the
[Hypervisor.framework](https://developer.apple.com/reference/hypervisor).
Currently, there is no `docker-machine create` driver for HyperKit, so
use the `virtualbox` driver to create local machines. (See the
[Docker Machine driver for Oracle VirtualBox](drivers/virtualbox.md).) You can
run both HyperKit and Oracle VirtualBox on the same system.
* Make sure you have [the latest VirtualBox](https://www.virtualbox.org/wiki/Downloads){: target="_blank" rel="noopener" class="_"}
correctly installed on your system.
## Use Machine to run Docker containers
To run a Docker container, you:
* create a new (or start an existing) Docker virtual machine
* switch your environment to your new VM
* use the docker client to create, load, and manage containers
Once you create a machine, you can reuse it as often as you like. Like any VirtualBox VM, it maintains its configuration between uses.
The examples here show how to create and start a machine, run Docker commands, and work with containers.
## Create a machine
1. Open a command shell or terminal window.
These command examples shows a Bash shell. For a different shell, such as C Shell, the same commands are the same except where noted.
2. Use `docker-machine ls` to list available machines.
In this example, no machines have been created yet.
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
3. Create a machine.
Run the `docker-machine create` command, pass the appropriate driver to the
`--driver` flag and provide a machine name. If this is your first machine, name
it `default` as shown in the example. If you already have a "default" machine,
choose another name for this new machine.
On Docker Desktop for Windows systems that support Hyper-V, use the `hyperv` driver as shown in the [Docker Machine Microsoft Hyper-V driver reference](drivers/hyper-v.md) and follow the [example](drivers/hyper-v.md#example), which shows how to use an external network switch and provides the flags for the full command. (See [prerequisites](get-started.md#prerequisite-information) above to learn more.)
$ docker-machine create --driver virtualbox default
Running pre-create checks...
Creating machine...
(staging) Copying /Users/ripley/.docker/machine/cache/boot2docker.iso to /Users/ripley/.docker/machine/machines/default/boot2docker.iso...
(staging) Creating VirtualBox VM...
(staging) Creating SSH key...
(staging) Starting the VM...
(staging) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Machine is running, waiting for SSH to be available...
Detecting operating system of created instance...
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 Docker to this machine, run: docker-machine env default
This command downloads a lightweight Linux distribution ([boot2docker](https://github.com/boot2docker/boot2docker){: target="_blank" rel="noopener" class="_"}) with the Docker daemon installed, and creates and starts a VirtualBox VM with Docker running.
4. List available machines again to see your newly minted machine.
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
default * virtualbox Running tcp://192.168.99.187:2376 v1.9.1
5. Get the environment commands for your new VM.
As noted in the output of the `docker-machine create` command, you need to tell Docker to talk to the new machine. You can do this with the `docker-machine env` command.
$ docker-machine env default
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://172.16.62.130:2376"
export DOCKER_CERT_PATH="/Users/<yourusername>/.docker/machine/machines/default"
export DOCKER_MACHINE_NAME="default"
# Run this command to configure your shell:
# eval "$(docker-machine env default)"
6. Connect your shell to the new machine.
$ eval "$(docker-machine env default)"
**Note**: If you are using `fish`, or a Windows shell such as
Powershell/`cmd.exe`, the above method does not work as described.
Instead, see [the `env` command's documentation](reference/env.md){: target="_blank" rel="noopener" class="_"}
to learn how to set the environment variables for your shell.
This sets environment variables for the current shell that the Docker
client reads which specify the TLS settings. You need to do this
each time you open a new shell or restart your machine. (See also, how to
[unset environment variables in the current shell](get-started.md#unset-environment-variables-in-the-current-shell).)
You can now run Docker commands on this host.
## Run containers and experiment with Machine commands
Run a container with `docker run` to verify your set up.
1. Use `docker run` to download and run `busybox` with a simple 'echo' command.
$ docker run busybox echo hello world
Unable to find image 'busybox' locally
Pulling repository busybox
e72ac664f4f0: Download complete
511136ea3c5a: Download complete
df7546f9f060: Download complete
e433a6c5b276: Download complete
hello world
2. Get the host IP address.
Any exposed ports are available on the Docker host’s IP address, which you can get using the `docker-machine ip` command:
$ docker-machine ip default
192.168.99.100
3. Run a [Nginx](https://www.nginx.com/){: target="_blank" rel="noopener" class="_"} webserver in a container with the following command:
$ docker run -d -p 8000:80 nginx
When the image is finished pulling, you can hit the server at port 8000 on the IP address given to you by `docker-machine ip`. For instance:
$ curl $(docker-machine ip default):8000
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
body {
width: 35em;
margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif;
}
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support, refer to
<a href="https://nginx.org">nginx.org</a>.<br/>
Commercial support is available at
<a href="https://www.nginx.com">www.nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
You can create and manage as many local VMs running Docker as your local resources permit; just run `docker-machine create` again. All created machines appear in the output of `docker-machine ls`.
## Start and stop machines
If you are finished using a host for the time being, you can stop it with `docker-machine stop` and later start it again with `docker-machine start`.
$ docker-machine stop default
$ docker-machine start default
## Operate on machines without specifying the name
Some `docker-machine` commands assume that the given operation should be run on a machine named `default` (if it exists) if no machine name is specified. Because using a local VM named `default` is such a common pattern, this allows you to save some typing on the most frequently used Machine commands.
For example:
$ docker-machine stop
Stopping "default"....
Machine "default" was stopped.
$ docker-machine start
Starting "default"...
(default) Waiting for an IP...
Machine "default" was started.
Started machines may have new IP addresses. You may need to re-run the `docker-machine env` command.
$ eval $(docker-machine env)
$ docker-machine ip
192.168.99.100
Commands that follow this style are:
- `docker-machine config`
- `docker-machine env`
- `docker-machine inspect`
- `docker-machine ip`
- `docker-machine kill`
- `docker-machine provision`
- `docker-machine regenerate-certs`
- `docker-machine restart`
- `docker-machine ssh`
- `docker-machine start`
- `docker-machine status`
- `docker-machine stop`
- `docker-machine upgrade`
- `docker-machine url`
For machines other than `default`, and commands other than those listed above, you must always specify the name explicitly as an argument.
## Unset environment variables in the current shell
You might want to use the current shell to connect to a different Docker Engine.
In such scenarios, you have the option to switch the environment for the current
shell to talk to different Docker engines.
1. Run `env|grep DOCKER` to check whether DOCKER environment variables are set.
```none
$ env | grep DOCKER
DOCKER_HOST=tcp://192.168.99.100:2376
DOCKER_MACHINE_NAME=default
DOCKER_TLS_VERIFY=1
DOCKER_CERT_PATH=/Users/<your_username>/.docker/machine/machines/default
```
If it returns output (as shown in the example), you can unset the `DOCKER` environment variables.
2. Use one of two methods to unset DOCKER environment variables in the current shell.
* Run the `unset` command on the following `DOCKER` environment variables.
```none
unset DOCKER_TLS_VERIFY
unset DOCKER_CERT_PATH
unset DOCKER_MACHINE_NAME
unset DOCKER_HOST
```
* Alternatively, run a shortcut command `docker-machine env -u` to show the command you need to run to unset all DOCKER variables:
```none
$ docker-machine env -u
unset DOCKER_TLS_VERIFY
unset DOCKER_HOST
unset DOCKER_CERT_PATH
unset DOCKER_MACHINE_NAME
# Run this command to configure your shell:
# eval $(docker-machine env -u)
```
Run `eval $(docker-machine env -u)` to unset all DOCKER variables in the current shell.
3. Now, after running either of the above commands, this command should return no output.
```
$ env | grep DOCKER
```
If you are running Docker Desktop for Mac, you can run Docker commands to talk
to the Docker Engine installed with that app.
## Start local machines on startup
To ensure that the Docker client is automatically configured at the start of
each shell session, you can embed `eval $(docker-machine env default)` in your
shell profiles, by adding it to the `~/.bash_profile` file or the equivalent
configuration file for your shell. However, this fails if a machine called
`default` is not running. You can configure your system to start the `default`
machine automatically. The following example shows how to do this in macOS.
Create a file called `com.docker.machine.default.plist` in the
`~/Library/LaunchAgents/` directory, with the following content:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>EnvironmentVariables</key>
<dict>
<key>PATH</key>
<string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
</dict>
<key>Label</key>
<string>com.docker.machine.default</string>
<key>ProgramArguments</key>
<array>
<string>/usr/local/bin/docker-machine</string>
<string>start</string>
<string>default</string>
</array>
<key>RunAtLoad</key>
<true/>
</dict>
</plist>
```
You can change the `default` string above to make this `LaunchAgent` start a
different machine.
## Where to go next
- Provision multiple Docker hosts [on your cloud provider](get-started-cloud.md)
- [Understand Machine concepts](concepts.md)
- [Docker Machine list of reference pages for all supported drivers](drivers/index.md)
- [Docker Machine driver for Oracle VirtualBox](drivers/virtualbox.md)
- [Docker Machine driver for Microsoft Hyper-V](drivers/hyper-v.md)
- [`docker-machine` command line reference](reference/index.md)

BIN
machine/img/aws-instance-east.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 207 KiB

BIN
machine/img/engine.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 9.5 KiB

BIN
machine/img/hyperv-manager.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 229 KiB

BIN
machine/img/hyperv-network-switch.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 272 KiB

1195
machine/img/linux_docker_host.svg
View File

File diff suppressed because it is too large Load Diff
Side by Side

Before

Width:  |  Height:  |  Size: 72 KiB

BIN
machine/img/machine-mac-win.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 9.8 KiB

BIN
machine/img/machine.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 38 KiB

BIN
machine/img/nginx-webserver.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 59 KiB

BIN
machine/img/ocean_click_api.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 36 KiB

BIN
machine/img/ocean_droplet.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 26 KiB

BIN
machine/img/ocean_gen_token.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 41 KiB

BIN
machine/img/ocean_save_token.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 50 KiB

BIN
machine/img/ocean_token_create.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
machine/img/provision-use-case.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 14 KiB

163
machine/index.md
View File

@ -1,106 +1,69 @@
---
description: Introduction and Overview of Machine
keywords: docker, machine, amazonec2, azure, digitalocean, google, openstack, rackspace, softlayer, virtualbox, vmwarefusion, vmwarevcloudair, vmwarevsphere, exoscale
title: Docker Machine overview
description: Docker Machine
keywords: docker, machine
title: Docker Machine
redirect_from:
- /machine/overview/
- /machine/AVAILABLE_DRIVER_PLUGINS/
- /machine/DRIVER_SPEC/
- /machine/RELEASE/
- /machine/completion/
- /machine/concepts/
- /machine/drivers/aws/
- /machine/drivers/azure/
- /machine/drivers/digital-ocean/
- /machine/drivers/exoscale/
- /machine/drivers/gce/
- /machine/drivers/generic/
- /machine/drivers/hyper-v/
- /machine/drivers/index/
- /machine/drivers/linode/
- /machine/drivers/openstack/
- /machine/drivers/os-base/
- /machine/drivers/rackspace/
- /machine/drivers/soft-layer/
- /machine/drivers/virtualbox/
- /machine/drivers/vm-cloud/
- /machine/drivers/vm-fusion/
- /machine/drivers/vsphere/
- /machine/examples/aws/
- /machine/examples/index/
- /machine/examples/ocean/
- /machine/get-started-cloud/
- /machine/get-started/
- /machine/install-machine/
- /machine/migrate-to-machine/
- /machine/reference/active/
- /machine/reference/config/
- /machine/reference/create/
- /machine/reference/env/
- /machine/reference/help/
- /machine/reference/index/
- /machine/reference/inspect/
- /machine/reference/ip/
- /machine/reference/kill/
- /machine/reference/ls/
- /machine/reference/mount/
- /machine/reference/provision/
- /machine/reference/regenerate-certs/
- /machine/reference/restart/
- /machine/reference/rm/
- /machine/reference/scp/
- /machine/reference/ssh/
- /machine/reference/start/
- /machine/reference/status/
- /machine/reference/stop/
- /machine/reference/upgrade/
- /machine/reference/url/
- /machine/release-notes/
notoc: true
---
You can use Docker Machine to:
> **Deprecated**
>
> Docker Machine has been deprecated. Please use Docker Desktop instead. See [Docker Desktop for Mac](../desktop/mac/index.md)
> and [Docker Desktop for Windows](../desktop/windows/index.md).
> You can also use other cloud provisioning tools.
{: .warning }
* Install and run Docker on Mac or Windows
* Provision and manage multiple remote Docker hosts
* Provision Swarm clusters
## What is Docker Machine?
Docker Machine is a tool that lets you install Docker Engine on virtual hosts,
and manage the hosts with `docker-machine` commands. You can use Machine to
create Docker hosts on your local Mac or Windows box, on your company network,
in your data center, or on cloud providers like Azure, AWS, or DigitalOcean.
Using `docker-machine` commands, you can start, inspect, stop, and restart a
managed host, upgrade the Docker client and daemon, and configure a Docker
client to talk to your host.
Point the Machine CLI at a running, managed host, and you can run `docker`
commands directly on that host. For example, run `docker-machine env default` to
point to a host called `default`, follow on-screen instructions to complete
`env` setup, and run `docker ps`, `docker run hello-world`, and so forth.
Machine _was_ the _only_ way to run Docker on Mac or Windows previous to Docker
v1.12. Starting with the beta program and Docker v1.12,
[Docker Desktop for Mac](../desktop/mac/index.md) and
[Docker Desktop for Windows](../desktop/windows/index.md) are available as native apps and the
better choice for this use case on newer desktops and laptops. We encourage you
to try out these new apps.
If you aren't sure where to begin, see [Get Started with Docker](../get-started/index.md),
which guides you through a brief end-to-end tutorial on Docker.
## Why should I use it?
Docker Machine enables you to provision multiple remote Docker hosts on various
flavors of Linux.
Additionally, Machine allows you to run Docker on older Mac or Windows systems,
as described in the previous topic.
Docker Machine has these two broad use cases.
* **I have an older desktop system and want to run Docker on Mac or Windows**
![Docker Machine on Mac and Windows](img/machine-mac-win.png){: .white-bg}
If you work primarily on an older Mac or Windows laptop or desktop that doesn't meet the requirements for the new [Docker Desktop for Mac](../desktop/mac/index.md) and [Docker Desktop for Windows](../desktop/windows/index.md) apps, then you need Docker Machine to run Docker Engine locally.
* **I want to provision Docker hosts on remote systems**
![Docker Machine for provisioning multiple systems](img/provision-use-case.png){: .white-bg}
Docker Engine runs natively on Linux systems. If you have a Linux box as your
primary system, and want to run `docker` commands, all you need to do is
download and install Docker Engine. However, if you want an efficient way to
provision multiple Docker hosts on a network, in the cloud or even locally,
you need Docker Machine.
Whether your primary system is Mac, Windows, or Linux, you can install Docker
Machine on it and use `docker-machine` commands to provision and manage large
numbers of Docker hosts. It automatically creates hosts, installs Docker
Engine on them, then configures the `docker` clients. Each managed host
("**_machine_**") is the combination of a Docker host and a configured client.
## What's the difference between Docker Engine and Docker Machine?
When people say "Docker" they typically mean **Docker Engine**, the
client-server application made up of the Docker daemon, a REST API that
specifies interfaces for interacting with the daemon, and a command line
interface (CLI) client that talks to the daemon (through the REST API wrapper).
Docker Engine accepts `docker` commands from the CLI, such as
`docker run <image>`, `docker ps` to list running containers, `docker image ls`
to list images, and so on.
![Docker Engine](img/engine.png)
**Docker Machine** is a tool for provisioning and managing your Dockerized hosts
(hosts with Docker Engine on them). Typically, you install Docker Machine on
your local system. Docker Machine has its own command line client
`docker-machine` and the Docker Engine client, `docker`. You can use Machine to
install Docker Engine on one or more virtual systems. These virtual systems can
be local (as when you use Machine to install and run Docker Engine in VirtualBox
on Mac or Windows) or remote (as when you use Machine to provision Dockerized
hosts on cloud providers). The Dockerized hosts themselves can be thought of,
and are sometimes referred to as, managed "**_machines_**".
![Docker Machine](img/machine.png){: .white-bg}
## Where to go next
- [Install Docker Machine](install-machine.md)
- Create and run a Docker host on your [local system using VirtualBox](get-started.md)
- Provision multiple Docker hosts [on your cloud provider](get-started-cloud.md)
- [Getting started with swarm mode](../engine/swarm/swarm-tutorial/index.md)
- [Understand Machine concepts](concepts.md)
- [Docker Machine driver reference](drivers/index.md)
- [Docker Machine subcommand reference](reference/index.md)
- [Migrate from Boot2Docker to Docker Machine](migrate-to-machine.md)
The source code for Docker Machine has been archived. You can find the source code on [GitHub](https://github.com/docker/machine){:target="_blank" rel="noopener" class="_"}.

132
machine/install-machine.md
View File

@ -1,132 +0,0 @@
---
description: How to install Docker Machine
keywords: machine, orchestration, install, installation, docker, documentation, uninstall Docker Machine, uninstall
title: Install Docker Machine
---
Install Docker Machine binaries by following the instructions in the following section. You can find the latest
versions of the binaries on the [docker/machine release
page](https://github.com/docker/machine/releases/){: target="_blank" rel="noopener" class="_" }
on GitHub.
## Install Docker Machine
1. Install [Docker](../engine/install/index.md){: target="_blank" rel="noopener" class="_" }.
2. Download the Docker Machine binary and extract it to your PATH.
If you are running **macOS**:
```console
$ base=https://github.com/docker/machine/releases/download/v{{site.machine_version}} \
&& curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/usr/local/bin/docker-machine \
&& chmod +x /usr/local/bin/docker-machine
```
If you are running **Linux**:
```console
$ base=https://github.com/docker/machine/releases/download/v{{site.machine_version}} \
&& 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
```
If you are running **Windows** with [Git BASH](https://git-for-windows.github.io/){: target="_blank" rel="noopener" class="_"}:
```console
$ base=https://github.com/docker/machine/releases/download/v{{site.machine_version}} \
&& 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"
```
> The above command works on Windows only if you use a
terminal emulator such as [Git BASH](https://git-for-windows.github.io/){: target="_blank" rel="noopener" class="_"}, which supports Linux commands like `chmod`.
{: .important}
Otherwise, download one of the releases from the [docker/machine release
page](https://github.com/docker/machine/releases/){: target="_blank" rel="noopener" class="_" } directly.
3. Check the installation by displaying the Machine version:
```console
$ docker-machine version
docker-machine version {{site.machine_version}}, build 9371605
```
## Install bash completion scripts
The Machine repository supplies several `bash` scripts that add features such
as:
- command completion
- a function that displays the active machine in your shell prompt
- a function wrapper that adds a `docker-machine use` subcommand to switch the
active machine
Confirm the version and save scripts to `/etc/bash_completion.d` or
`/usr/local/etc/bash_completion.d`:
```bash
base=https://raw.githubusercontent.com/docker/machine/v{{site.machine_version}}
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
```
Then you need to run `source
/etc/bash_completion.d/docker-machine-prompt.bash` in your bash
terminal to tell your setup where it can find the file
`docker-machine-prompt.bash` that you previously downloaded.
To enable the `docker-machine` shell prompt, add
`$(__docker_machine_ps1)` to your `PS1` setting in `~/.bashrc`.
```bash
PS1='[\u@\h \W$(__docker_machine_ps1)]\$ '
```
You can find additional documentation in the comments at the [top of
each
script](https://github.com/docker/machine/tree/master/contrib/completion/bash){:
target="_blank" rel="noopener" class="_"}.
## How to uninstall Docker Machine
To uninstall Docker Machine:
* Optionally, remove the machines you created.
To remove each machine individually: `docker-machine rm <machine-name>`
To remove all machines: `docker-machine rm -f $(docker-machine ls
-q)` (you might need to use `-force` on Windows).
Removing machines is an optional step because there are cases where
you might want to save and migrate existing machines to a
[Docker for Mac](../desktop/mac/index.md) or
[Docker Desktop for Windows](../desktop/windows/index.md) environment,
for example.
* Remove the executable: `rm $(which docker-machine)`
> **Note**
>
> As a point of information, the `config.json`, certificates,
> and other data related to each virtual machine created by `docker-machine`
> is stored in `~/.docker/machine/machines/` on Mac and Linux and in
> `~\.docker\machine\machines\` on Windows. We recommend that you do not edit or
> remove those files directly as this only affects information for the Docker
> CLI, not the actual VMs, regardless of whether they are local or on remote
> servers.
## Where to go next
- [Docker Machine overview](index.md)
- Create and run a Docker host on your [local system using virtualization](get-started.md)
- Provision multiple Docker hosts [on your cloud provider](get-started-cloud.md)
- [Docker Machine driver reference](drivers/index.md)
- [Docker Machine subcommand reference](reference/index.md)

41
machine/migrate-to-machine.md
View File

@ -1,41 +0,0 @@
---
description: Migrate from Boot2Docker to Docker Machine
keywords: machine, commands, boot2docker, migrate, docker
title: Migrate from Boot2Docker to Machine
---
If you were using Boot2Docker previously, you have a pre-existing Docker
`boot2docker-vm` VM on your local system. To allow Docker Machine to manage
this older VM, you must migrate it.
1. Open a terminal or the Docker CLI on your system.
2. Type the following command.
$ docker-machine create -d virtualbox --virtualbox-import-boot2docker-vm boot2docker-vm docker-vm
3. Use the `docker-machine` command to interact with the migrated VM.
## Subcommand comparison
The `docker-machine` subcommands are slightly different than the `boot2docker`
subcommands. The table below lists the equivalent `docker-machine` subcommand
and what it does:
| `boot2docker` | `docker-machine` | `docker-machine` description |
| ------------- | ---------------- | --------------------------------------------------------------------------------- |
| init | create | Creates a new docker host. |
| up | start | Starts a stopped machine. |
| ssh | ssh | Runs a command or interactive ssh session on the machine. |
| save | - | Not applicable. |
| down | stop | Stops a running machine. |
| poweroff | stop | Stops a running machine. |
| reset | restart | Restarts a running machine. |
| config | inspect | Prints machine configuration details. |
| status | ls | Lists all machines and their status. |
| info | inspect | Displays a machine's details. |
| ip | ip | Displays the machine's IP address. |
| shellinit | env | Displays shell commands needed to configure your shell to interact with a machine |
| delete | rm | Removes a machine. |
| download | - | Not applicable. |
| upgrade | upgrade | Upgrades a machine's Docker client to the latest stable release. |

22
machine/reference/active.md
View File

@ -1,22 +0,0 @@
---
description: Identify active machines
keywords: machine, active, subcommand
title: docker-machine active
---
See which machine is "active" (a machine is considered active if the
`DOCKER_HOST` environment variable points to it).
```console
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev - virtualbox Running tcp://192.168.99.103:2376
staging * digitalocean Running tcp://203.0.113.81:2376
$ echo $DOCKER_HOST
tcp://203.0.113.81:2376
$ docker-machine active
staging
```

29
machine/reference/config.md
View File

@ -1,29 +0,0 @@
---
description: Show client configuration
keywords: machine, config, subcommand
title: docker-machine config
---
```none
Usage: docker-machine config [OPTIONS] [arg...]
Print the connection config for machine
Description:
Argument is a machine name.
Options:
--swarm Display the Swarm config instead of the Docker daemon
```
For example:
```console
$ docker-machine config dev \
--tlsverify \
--tlscacert="/Users/ehazlett/.docker/machines/dev/ca.pem" \
--tlscert="/Users/ehazlett/.docker/machines/dev/cert.pem" \
--tlskey="/Users/ehazlett/.docker/machines/dev/key.pem" \
-H tcp://192.168.99.103:2376
```

261
machine/reference/create.md
View File

@ -1,261 +0,0 @@
---
description: Create a machine.
keywords: machine, create, subcommand
title: docker-machine create
---
Create a machine. Requires the `--driver` flag to indicate which provider
(VirtualBox, DigitalOcean, AWS, etc.) the machine should be created on, and an
argument to indicate the name of the created machine.
> Looking for the full list of available drivers?
>
>For a full list of drivers that work with `docker-machine create` and
information on how to use them, see [Machine drivers](../drivers/index.md).
{: .important}
## Example
Here is an example of using the `--virtualbox` driver to create a machine called `dev`.
```console
$ docker-machine create --driver virtualbox dev
Creating CA: /home/username/.docker/machine/certs/ca.pem
Creating client certificate: /home/username/.docker/machine/certs/cert.pem
Image cache does not exist, creating it at /home/username/.docker/machine/cache...
No default boot2docker iso found locally, downloading the latest release...
Downloading https://github.com/boot2docker/boot2docker/releases/download/v1.6.2/boot2docker.iso to /home/username/.docker/machine/cache/boot2docker.iso...
Creating VirtualBox VM...
Creating SSH key...
Starting VirtualBox VM...
Starting VM...
To see how to connect Docker to this machine, run: docker-machine env dev
```
## Accessing driver-specific flags in the help text
The `docker-machine create` command has some flags which apply to all
drivers. These largely control aspects of Machine's provisioning process
(including the creation of Docker Swarm containers) that the user may wish to
customize.
```console
$ docker-machine create
Docker Machine Version: 0.5.0 (45e3688)
Usage: docker-machine create [OPTIONS] [arg...]
Create a machine.
Run 'docker-machine create --driver name' to include the create flags for that driver in the help text.
Options:
--driver, -d "none" Driver to create machine with.
--engine-install-url "https://get.docker.com" Custom URL to use for engine installation [$MACHINE_DOCKER_INSTALL_URL]
--engine-opt [--engine-opt option --engine-opt option] Specify arbitrary flags to include with the created engine in the form flag=value
--engine-insecure-registry [--engine-insecure-registry option --engine-insecure-registry option] Specify insecure registries to allow with the created engine
--engine-registry-mirror [--engine-registry-mirror option --engine-registry-mirror option] Specify registry mirrors to use [$ENGINE_REGISTRY_MIRROR]
--engine-label [--engine-label option --engine-label option] Specify labels for the created engine
--engine-storage-driver Specify a storage driver to use with the engine
--engine-env [--engine-env option --engine-env option] Specify environment variables to set in the engine
--swarm Configure Machine with Swarm
--swarm-image "swarm:latest" Specify Docker image to use for Swarm [$MACHINE_SWARM_IMAGE]
--swarm-master Configure Machine to be a Swarm master
--swarm-discovery Discovery service to use with Swarm
--swarm-strategy "spread" Define a default scheduling strategy for Swarm
--swarm-opt [--swarm-opt option --swarm-opt option] Define arbitrary flags for swarm
--swarm-host "tcp://0.0.0.0:3376" ip/socket to listen on for Swarm master
--swarm-addr addr to advertise for Swarm (default: detect and use the machine IP)
--swarm-experimental Enable Swarm experimental features
```
Additionally, drivers can specify flags that Machine can accept as part of their
plugin code. These allow users to customize the provider-specific parameters of
the created machine, such as size (`--amazonec2-instance-type m1.medium`),
geographical region (`--amazonec2-region us-west-1`), and so on.
To see the provider-specific flags, simply pass a value for `--driver` when
invoking the `create` help text.
```console
$ docker-machine create --driver virtualbox --help
Usage: docker-machine create [OPTIONS] [arg...]
Create a machine.
Run 'docker-machine create --driver name' to include the create flags for that driver in the help text.
Options:
--driver, -d "none" Driver to create machine with.
--engine-env [--engine-env option --engine-env option] Specify environment variables to set in the engine
--engine-insecure-registry [--engine-insecure-registry option --engine-insecure-registry option] Specify insecure registries to allow with the created engine
--engine-install-url "https://get.docker.com" Custom URL to use for engine installation [$MACHINE_DOCKER_INSTALL_URL]
--engine-label [--engine-label option --engine-label option] Specify labels for the created engine
--engine-opt [--engine-opt option --engine-opt option] Specify arbitrary flags to include with the created engine in the form flag=value
--engine-registry-mirror [--engine-registry-mirror option --engine-registry-mirror option] Specify registry mirrors to use [$ENGINE_REGISTRY_MIRROR]
--engine-storage-driver Specify a storage driver to use with the engine
--swarm Configure Machine with Swarm
--swarm-addr addr to advertise for Swarm (default: detect and use the machine IP)
--swarm-discovery Discovery service to use with Swarm
--swarm-experimental Enable Swarm experimental features
--swarm-host "tcp://0.0.0.0:3376" ip/socket to listen on for Swarm master
--swarm-image "swarm:latest" Specify Docker image to use for Swarm [$MACHINE_SWARM_IMAGE]
--swarm-master Configure Machine to be a Swarm master
--swarm-opt [--swarm-opt option --swarm-opt option] Define arbitrary flags for swarm
--swarm-strategy "spread" Define a default scheduling strategy for Swarm
--virtualbox-boot2docker-url The URL of the boot2docker image. Defaults to the latest available version [$VIRTUALBOX_BOOT2DOCKER_URL]
--virtualbox-cpu-count "1" number of CPUs for the machine (-1 to use the number of CPUs available) [$VIRTUALBOX_CPU_COUNT]
--virtualbox-disk-size "20000" Size of disk for host in MB [$VIRTUALBOX_DISK_SIZE]
--virtualbox-host-dns-resolver Use the host DNS resolver [$VIRTUALBOX_HOST_DNS_RESOLVER]
--virtualbox-dns-proxy Proxy all DNS requests to the host [$VIRTUALBOX_DNS_PROXY]
--virtualbox-hostonly-cidr "192.168.99.1/24" Specify the Host Only CIDR [$VIRTUALBOX_HOSTONLY_CIDR]
--virtualbox-hostonly-nicpromisc "deny" Specify the Host Only Network Adapter Promiscuous Mode [$VIRTUALBOX_HOSTONLY_NIC_PROMISC]
--virtualbox-hostonly-nictype "82540EM" Specify the Host Only Network Adapter Type [$VIRTUALBOX_HOSTONLY_NIC_TYPE]
--virtualbox-import-boot2docker-vm The name of a Boot2Docker VM to import
--virtualbox-memory "1024" Size of memory for host in MB [$VIRTUALBOX_MEMORY_SIZE]
--virtualbox-no-share Disable the mount of your home directory
```
You may notice that some flags specify environment variables that they are
associated with as well (located to the far left hand side of the row). If
these environment variables are set when `docker-machine create` is invoked,
Docker Machine uses them for the default value of the flag.
## Specifying configuration options for the created Docker engine
As part of the process of creation, Docker Machine installs Docker and
configures it with some sensible defaults. For instance, it allows connection
from the outside world over TCP with TLS-based encryption and defaults to AUFS
as the [storage driver](/engine/reference/commandline/dockerd/#daemon-storage-driver)
when available.
There are several cases where the user might want to set options for the created
Docker engine (also known as the Docker _daemon_) themselves. For example, they
may want to allow connection to a [registry](../../registry/index.md)
that they are running themselves using the `--insecure-registry` flag for the
daemon. Docker Machine supports the configuration of such options for the
created engines via the `create` command flags which begin with `--engine`.
Docker Machine only sets the configured parameters on the daemon
and does not set up any of the "dependencies" for you. For instance, if you
specify that the created daemon should use `btrfs` as a storage driver, you
still must ensure that the proper dependencies are installed, the BTRFS
filesystem has been created, and so on.
The following is an example usage:
```console
$ docker-machine create -d virtualbox \
--engine-label foo=bar \
--engine-label spam=eggs \
--engine-storage-driver overlay \
--engine-insecure-registry registry.myco.com \
foobarmachine
```
This creates a virtual machine running locally in VirtualBox which uses the
`overlay` storage backend, has the key-value pairs `foo=bar` and `spam=eggs` as
labels on the engine, and allows pushing / pulling from the insecure registry
located at `registry.myco.com`. You can verify much of this by inspecting the
output of `docker info`:
```console
$ eval $(docker-machine env foobarmachine)
$ docker info
Containers: 0
Images: 0
Storage Driver: overlay
...
Name: foobarmachine
...
Labels:
foo=bar
spam=eggs
provider=virtualbox
```
The supported flags are as follows:
- `--engine-insecure-registry`: Specify [insecure registries](/engine/reference/commandline/dockerd/#insecure-registries) to allow with the created engine
- `--engine-registry-mirror`: Specify [registry mirrors](../../registry/recipes/mirror.md) to use
- `--engine-label`: Specify [labels](../../config/labels-custom-metadata.md) for the created engine
- `--engine-storage-driver`: Specify a [storage driver](/engine/reference/commandline/dockerd/#daemon-storage-driver) to use with the engine
If the engine supports specifying the flag multiple times (such as with
`--label`), then so does Docker Machine.
In addition to this subset of daemon flags which are directly supported, Docker
Machine also supports an additional flag, `--engine-opt`, which can be used to
specify arbitrary daemon options with the syntax `--engine-opt flagname=value`.
For example, to specify that the daemon should use `8.8.8.8` as the DNS server
for all containers, and always use the `syslog` [log driver](../../config/containers/logging/configure.md)
you could run the following create command:
```console
$ docker-machine create -d virtualbox \
--engine-opt dns=8.8.8.8 \
--engine-opt log-driver=syslog \
gdns
```
Additionally, Docker Machine supports a flag, `--engine-env`, which can be used to
specify arbitrary environment variables to be set within the engine with the syntax `--engine-env name=value`. For example, to specify that the engine should use `example.com` as the proxy server, you could run the following create command:
```console
$ docker-machine create -d virtualbox \
--engine-env HTTP_PROXY=http://example.com:8080 \
--engine-env HTTPS_PROXY=https://example.com:8080 \
--engine-env NO_PROXY=example2.com \
proxbox
```
## Specifying Docker Swarm options for the created machine
In addition to configuring Docker Engine options as listed above,
you can use Machine to specify how the created swarm manager is
configured. There is a `--swarm-strategy` flag, which you can use to specify
the scheduling strategy
which Docker Swarm should use (Machine defaults to the `spread` strategy).
There is also a general purpose `--swarm-opt` option which works similar to the aforementioned `--engine-opt` option, except that it specifies options
for the `swarm manage` command (used to boot a master node) instead of the base
command. You can use this to configure features that power users might be
interested in, such as configuring the heartbeat interval or Swarm's willingness
to over-commit resources. There is also the `--swarm-experimental` flag, that
allows you to access [experimental features](https://github.com/docker/swarm/tree/master/experimental)
in Docker Swarm.
If you're not sure how to configure these options, it is best to not specify
configuration at all. Docker Machine chooses sensible defaults for you and
you don't need to worry about it.
Example create:
```console
$ docker-machine create -d virtualbox \
--swarm \
--swarm-master \
--swarm-discovery token://<token> \
--swarm-strategy binpack \
--swarm-opt heartbeat=5s \
upbeat
```
This sets the swarm scheduling strategy to "binpack" (pack in containers as
tightly as possible per host instead of spreading them out), and the "heartbeat"
interval to 5 seconds.
## Pre-create check
Many drivers require a certain set of conditions to be in place before
machines can be created. For instance, VirtualBox needs to be installed before
the `virtualbox` driver can be used. For this reason, Docker Machine has a
"pre-create check" which is specified at the driver level.
If this pre-create check succeeds, Docker Machine proceeds with the creation
as normal. If the pre-create check fails, the Docker Machine process exits
with status code 3 to indicate that the source of the non-zero exit was the
pre-create check failing.

121
machine/reference/env.md
View File

@ -1,121 +0,0 @@
---
description: Set environment variables on a machine
keywords: machine, env, subcommand
title: docker-machine env
---
Set environment variables to dictate that `docker` should run a command against
a particular machine.
```console
$ docker-machine env --help
Usage: docker-machine env [OPTIONS] [arg...]
Display the commands to set up the environment for the Docker client
Description:
Argument is a machine name.
Options:
--swarm Display the Swarm config instead of the Docker daemon
--shell Force environment to be configured for a specified shell: [fish, cmd, powershell, tcsh], default is sh/bash
--unset, -u Unset variables instead of setting them
--no-proxy Add machine IP to NO_PROXY environment variable
```
`docker-machine env machinename` prints out `export` commands which can be
run in a subshell. Running `docker-machine env -u` prints `unset` commands
which reverse this effect.
```console
$ env | grep DOCKER
$ eval "$(docker-machine env dev)"
$ env | grep DOCKER
DOCKER_HOST=tcp://192.168.99.101:2376
DOCKER_CERT_PATH=/Users/nathanleclaire/.docker/machines/.client
DOCKER_TLS_VERIFY=1
DOCKER_MACHINE_NAME=dev
$ # If you run a docker command, now it runs against that host.
$ eval "$(docker-machine env -u)"
$ env | grep DOCKER
$ # The environment variables have been unset.
```
The output described above is intended for the shells `bash` and `zsh` (if
you're not sure which shell you're using, there's a very good possibility that
it's `bash`). However, these are not the only shells which Docker Machine
supports. Docker Machine detects the shells available in your environment and lists them.
Docker supports `bash`, `cmd`, `powershell`, and `emacs`.
If you are using `fish` and the `SHELL` environment variable is correctly set to
the path where `fish` is located, `docker-machine env name` prints out the
values in the format which `fish` expects:
```fish
set -x DOCKER_TLS_VERIFY 1;
set -x DOCKER_CERT_PATH "/Users/nathanleclaire/.docker/machine/machines/overlay";
set -x DOCKER_HOST tcp://192.168.99.102:2376;
set -x DOCKER_MACHINE_NAME overlay
# Run this command to configure your shell:
# eval "$(docker-machine env overlay)"
```
If you are on Windows and using either PowerShell or `cmd.exe`, `docker-machine env`
Docker Machine should now detect your shell automatically. If the automatic detection does not work, you
can still override it using the `--shell` flag for `docker-machine env`.
For PowerShell:
```console
$ docker-machine.exe env --shell powershell dev
$Env:DOCKER_TLS_VERIFY = "1"
$Env:DOCKER_HOST = "tcp://192.168.99.101:2376"
$Env:DOCKER_CERT_PATH = "C:\Users\captain\.docker\machine\machines\dev"
$Env:DOCKER_MACHINE_NAME = "dev"
# Run this command to configure your shell:
# docker-machine.exe env --shell=powershell dev | Invoke-Expression
```
For `cmd.exe`:
```console
$ docker-machine.exe env --shell cmd dev
set DOCKER_TLS_VERIFY=1
set DOCKER_HOST=tcp://192.168.99.101:2376
set DOCKER_CERT_PATH=C:\Users\captain\.docker\machine\machines\dev
set DOCKER_MACHINE_NAME=dev
# Run this command to configure your shell: copy and paste the above values into your command prompt
```
>**Tip:** See also, how to [unset environment variables in the current shell](../get-started.md#unset-environment-variables-in-the-current-shell).
## Excluding the created machine from proxies
The env command supports a `--no-proxy` flag which ensures that the created
machine's IP address is added to the [`NO_PROXY`/`no_proxy` environment
variable](https://wiki.archlinux.org/index.php/Proxy_settings).
This is useful when using `docker-machine` with a local VM provider, such as
`virtualbox` or `vmwarefusion`, in network environments where an HTTP proxy is
required for internet access.
```console
$ docker-machine env --no-proxy default
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.99.104:2376"
export DOCKER_CERT_PATH="/Users/databus23/.docker/machine/certs"
export DOCKER_MACHINE_NAME="default"
export NO_PROXY="192.168.99.104"
# Run this command to configure your shell:
# eval "$(docker-machine env default)"
```
You may also want to visit the documentation on setting `HTTP_PROXY` for the
created daemon using the `--engine-env` flag for
[`docker-machine create`](create.md#specifying-configuration-options-for-the-created-docker-engine).

30
machine/reference/help.md
View File

@ -1,30 +0,0 @@
---
description: Show command help
keywords: machine, help, subcommand
title: docker-machine help
---
```none
Usage: docker-machine help [arg...]
Shows a list of commands or help for one command
```
Usage: docker-machine help _subcommand_
For example:
```console
$ docker-machine help config
Usage: docker-machine config [OPTIONS] [arg...]
Print the connection config for machine
Description:
Argument is a machine name.
Options:
--swarm Display the Swarm config instead of the Docker daemon
```

27
machine/reference/index.md
View File

@ -1,27 +0,0 @@
---
description: Docker Machine Commands Overview
keywords: machine, commands
title: Docker Machine command-line reference
---
- [active](active.md)
- [config](config.md)
- [create](create.md)
- [env](env.md)
- [help](help.md)
- [inspect](inspect.md)
- [ip](ip.md)
- [kill](kill.md)
- [ls](ls.md)
- [mount](mount.md)
- [provision](provision.md)
- [regenerate-certs](regenerate-certs.md)
- [restart](restart.md)
- [rm](rm.md)
- [scp](scp.md)
- [ssh](ssh.md)
- [start](start.md)
- [status](status.md)
- [stop](stop.md)
- [upgrade](upgrade.md)
- [url](url.md)

100
machine/reference/inspect.md
View File

@ -1,100 +0,0 @@
---
description: Inspect information about a machine
keywords: machine, inspect, subcommand
title: docker-machine inspect
---
```none
Usage: docker-machine inspect [OPTIONS] [arg...]
Inspect information about a machine
Description:
Argument is a machine name.
Options:
--format, -f Format the output using the given go template.
```
By default, this renders information about a machine as JSON. If a format is
specified, the given template is executed for each result.
Go's [text/template](http://golang.org/pkg/text/template/) package
describes all the details of the format.
In addition to the `text/template` syntax, there are some additional functions,
`json` and `prettyjson`, which can be used to format the output as JSON (documented below).
## Examples
**List all the details of a machine:**
This is the default usage of `inspect`.
```console
$ docker-machine inspect dev
{
"DriverName": "virtualbox",
"Driver": {
"MachineName": "docker-host-128be8d287b2028316c0ad5714b90bcfc11f998056f2f790f7c1f43f3d1e6eda",
"SSHPort": 55834,
"Memory": 1024,
"DiskSize": 20000,
"Boot2DockerURL": "",
"IPAddress": "192.168.5.99"
},
...
}
```
**Get a machine's IP address:**
For the most part, you can pick out any field from the JSON in a fairly
straightforward manner.
{% raw %}
```console
$ docker-machine inspect --format='{{.Driver.IPAddress}}' dev
192.168.5.99
```
{% endraw %}
**Formatting details:**
If you want a subset of information formatted as JSON, you can use the `json`
function in the template.
```console
$ docker-machine inspect --format='{{json .Driver}}' dev-fusion
{"Boot2DockerURL":"","CPUS":8,"CPUs":8,"CaCertPath":"/Users/hairyhenderson/.docker/machine/certs/ca.pem","DiskSize":20000,"IPAddress":"172.16.62.129","ISO":"/Users/hairyhenderson/.docker/machine/machines/dev-fusion/boot2docker-1.5.0-GH747.iso","MachineName":"dev-fusion","Memory":1024,"PrivateKeyPath":"/Users/hairyhenderson/.docker/machine/certs/ca-key.pem","SSHPort":22,"SSHUser":"docker","SwarmDiscovery":"","SwarmHost":"tcp://0.0.0.0:3376","SwarmMaster":false}
```
While this is usable, it's not very human-readable. For this reason, there is
`prettyjson`:
{% raw %}
```console
$ docker-machine inspect --format='{{prettyjson .Driver}}' dev-fusion
{
"Boot2DockerURL": "",
"CPUS": 8,
"CPUs": 8,
"CaCertPath": "/Users/hairyhenderson/.docker/machine/certs/ca.pem",
"DiskSize": 20000,
"IPAddress": "172.16.62.129",
"ISO": "/Users/hairyhenderson/.docker/machine/machines/dev-fusion/boot2docker-1.5.0-GH747.iso",
"MachineName": "dev-fusion",
"Memory": 1024,
"PrivateKeyPath": "/Users/hairyhenderson/.docker/machine/certs/ca-key.pem",
"SSHPort": 22,
"SSHUser": "docker",
"SwarmDiscovery": "",
"SwarmHost": "tcp://0.0.0.0:3376",
"SwarmMaster": false
}
{% endraw %}
```

18
machine/reference/ip.md
View File

@ -1,18 +0,0 @@
---
description: Show client configuration
keywords: machine, ip, subcommand
title: docker-machine ip
---
Get the IP address of one or more machines.
```console
$ docker-machine ip dev
192.168.99.104
$ docker-machine ip dev dev2
192.168.99.104
192.168.99.105
```

29
machine/reference/kill.md
View File

@ -1,29 +0,0 @@
---
description: Kill (abruptly force stop) a machine.
keywords: machine, kill, subcommand
title: docker-machine kill
---
```none
Usage: docker-machine kill [arg...]
Kill (abruptly force stop) a machine
Description:
Argument(s) are one or more machine names.
```
For example:
```console
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.104:2376
$ docker-machine kill dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Stopped
```

117
machine/reference/ls.md
View File

@ -1,117 +0,0 @@
---
description: List machines
keywords: machine, ls, subcommand
title: docker-machine ls
---
```none
Usage: docker-machine ls [OPTIONS] [arg...]
List machines
Options:
--quiet, -q Enable quiet mode
--filter [--filter option --filter option] Filter output based on conditions provided
--timeout, -t "10" Timeout in seconds, default to 10s
--format, -f Pretty-print machines using a Go template
```
## Timeout
The `ls` command tries to reach each host in parallel. If a given host does not
answer in less than 10 seconds, the `ls` command states that this host is in
`Timeout` state. In some circumstances (poor connection, high load, or while
troubleshooting), you may want to increase or decrease this value. You can use
the -t flag for this purpose with a numerical value in seconds.
### Example
```none
$ docker-machine ls -t 12
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
default - virtualbox Running tcp://192.168.99.100:2376 v1.9.1
```
## Filtering
The filtering flag (`--filter`) format is a `key=value` pair. If there is more
than one filter, then pass multiple flags. For example:
`--filter "foo=bar" --filter "bif=baz"`
The currently supported filters are:
- driver (driver name)
- swarm (swarm master's name)
- state (`Running|Paused|Saved|Stopped|Stopping|Starting|Error`)
- name (Machine name returned by driver, supports [golang style](https://github.com/google/re2/wiki/Syntax) regular expressions)
- label (Machine created with `--engine-label` option, can be filtered with `label=<key>[=<value>]`)
### Examples
```none
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
dev - virtualbox Stopped
foo0 - virtualbox Running tcp://192.168.99.105:2376 v1.9.1
foo1 - virtualbox Running tcp://192.168.99.106:2376 v1.9.1
foo2 * virtualbox Running tcp://192.168.99.107:2376 v1.9.1
$ docker-machine ls --filter name=foo0
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
foo0 - virtualbox Running tcp://192.168.99.105:2376 v1.9.1
$ docker-machine ls --filter driver=virtualbox --filter state=Stopped
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
dev - virtualbox Stopped v1.9.1
$ docker-machine ls --filter label=com.class.app=foo1 --filter label=com.class.app=foo2
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
foo1 - virtualbox Running tcp://192.168.99.105:2376 v1.9.1
foo2 * virtualbox Running tcp://192.168.99.107:2376 v1.9.1
```
## Formatting
The formatting option (`--format`) pretty-prints machines using a Go template.
Valid placeholders for the Go template are listed below:
| Placeholder | Description |
|:---------------|:-----------------------------------------|
| .Name | Machine name |
| .Active | Is the machine active? |
| .ActiveHost | Is the machine an active non-swarm host? |
| .ActiveSwarm | Is the machine an active swarm master? |
| .DriverName | Driver name |
| .State | Machine state (running, stopped...) |
| .URL | Machine URL |
| .Swarm | Machine swarm name |
| .Error | Machine errors |
| .DockerVersion | Docker Daemon version |
| .ResponseTime | Time taken by the host to respond |
When using the `--format` option, the `ls` command either outputs the data exactly as the template declares or,
when using the table directive, includes column headers as well.
The following example uses a template without headers and outputs the `Name` and `Driver` entries separated by a colon
for all running machines:
{% raw %}
```none
$ docker-machine ls --format "{{.Name}}: {{.DriverName}}"
default: virtualbox
ec2: amazonec2
```
{% endraw %}
To list all machine names with their driver in a table format you can use:
{% raw %}
```none
$ docker-machine ls --format "table {{.Name}} {{.DriverName}}"
NAME DRIVER
default virtualbox
ec2 amazonec2
```
{% endraw %}

51
machine/reference/mount.md
View File

@ -1,51 +0,0 @@
---
description: Mount directory from machine
keywords: machine, mount, subcommand
title: docker-machine mount
---
Mount directories from a machine to your local host, using `sshfs`.
The notation is `machinename:/path/to/dir` for the argument; you can also supply an alternative mount point (default is the same dir path).
## Example
Consider the following example:
```console
$ mkdir foo
$ docker-machine ssh dev mkdir foo
$ docker-machine mount dev:/home/docker/foo foo
$ touch foo/bar
$ docker-machine ssh dev ls foo
bar
```
Now you can use the directory on the machine, for mounting into containers.
Any changes done in the local directory, is reflected in the machine too.
```console
$ eval $(docker-machine env dev)
$ docker run -v /home/docker/foo:/tmp/foo busybox ls /tmp/foo
bar
$ touch foo/baz
$ docker run -v /home/docker/foo:/tmp/foo busybox ls /tmp/foo
bar
baz
```
The files are actually being transferred using `sftp` (over an ssh connection),
so this program ("sftp") needs to be present on the machine - but it usually is.
To unmount the directory again, you can use the same options but the `-u` flag.
You can also call `fuserunmount` (or `fusermount -u`) commands directly.
```console
$ docker-machine mount -u dev:/home/docker/foo foo
$ rmdir foo
```
**Files are actually being stored on the machine, *not* on the host.**
So make sure to make a copy of any files you want to keep, before removing it!

34
machine/reference/provision.md
View File

@ -1,34 +0,0 @@
---
description: Re-run provisioning on a created machine.
keywords: machine, provision, subcommand
title: docker-machine provision
---
Re-run provisioning on a created machine.
Sometimes it may be helpful to re-run Machine's provisioning process on a
created machine. Reasons for doing so may include a failure during the original
provisioning process, or a drift from the desired system state (including the
originally specified Swarm or Engine configuration).
Usage is `docker-machine provision [name]`. Multiple names may be specified.
```console
$ docker-machine provision foo bar
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
```
The Machine provisioning process will:
1. Set the hostname on the instance to the name Machine addresses it by, such
as `default`.
2. Install Docker if it is not present already.
3. Generate a set of certificates (usually with the default, self-signed CA) and
configure the daemon to accept connections over TLS.
4. Copy the generated certificates to the server and local config directory.
5. Configure the Docker Engine according to the options specified at create
time.
6. Configure and activate Swarm if applicable.

42
machine/reference/regenerate-certs.md
View File

@ -1,42 +0,0 @@
---
description: Regenerate and update TLS certificates
keywords: machine, regenerate-certs, subcommand
title: docker-machine regenerate-certs
---
```none
Usage: docker-machine regenerate-certs [OPTIONS] [arg...]
Regenerate TLS Certificates for a machine
Description:
Argument(s) are one or more machine names.
Options:
--force, -f Force rebuild and do not prompt
--client-certs Also regenerate client certificates and CA.
```
Regenerate TLS certificates and update the machine with new certs.
For example:
```console
$ docker-machine regenerate-certs dev
Regenerate TLS machine certs? Warning: this is irreversible. (y/n): y
Regenerating TLS certificates
```
If your certificates have expired, you'll need to regenerate the client certs
as well using the `--client-certs` option:
```console
$ docker-machine regenerate-certs --client-certs dev
Regenerate TLS machine certs? Warning: this is irreversible. (y/n): y
Regenerating TLS certificates
Regenerating local certificates
...
```

24
machine/reference/restart.md
View File

@ -1,24 +0,0 @@
---
description: Restart a machine
keywords: machine, restart, subcommand
title: docker-machine restart
---
```none
Usage: docker-machine restart [arg...]
Restart a machine
Description:
Argument(s) are one or more machine names.
```
Restart a machine. Oftentimes this is equivalent to
`docker-machine stop; docker-machine start`. But some cloud driver try to implement a clever restart which keeps the same
IP address.
```console
$ docker-machine restart dev
Waiting for VM to start...
```

70
machine/reference/rm.md
View File

@ -1,70 +0,0 @@
---
description: Remove a machine.
keywords: machine, rm, subcommand
title: docker-machine rm
---
Remove a machine. This removes the local reference and deletes it
on the cloud provider or virtualization management platform.
```console
$ docker-machine rm --help
Usage: docker-machine rm [OPTIONS] [arg...]
Remove a machine
Description:
Argument(s) are one or more machine names.
Options:
--force, -f Remove local configuration even if machine cannot be removed, also implies an automatic yes (`-y`)
-y Assumes automatic yes to proceed with remove, without prompting further user confirmation
```
## Examples
```console
$ docker-machine ls
NAME ACTIVE URL STATE URL SWARM DOCKER ERRORS
bar - virtualbox Running tcp://192.168.99.101:2376 v1.9.1
baz - virtualbox Running tcp://192.168.99.103:2376 v1.9.1
foo - virtualbox Running tcp://192.168.99.100:2376 v1.9.1
qix - virtualbox Running tcp://192.168.99.102:2376 v1.9.1
$ docker-machine rm baz
About to remove baz
Are you sure? (y/n): y
Successfully removed baz
$ docker-machine ls
NAME ACTIVE URL STATE URL SWARM DOCKER ERRORS
bar - virtualbox Running tcp://192.168.99.101:2376 v1.9.1
foo - virtualbox Running tcp://192.168.99.100:2376 v1.9.1
qix - virtualbox Running tcp://192.168.99.102:2376 v1.9.1
$ docker-machine rm bar qix
About to remove bar, qix
Are you sure? (y/n): y
Successfully removed bar
Successfully removed qix
$ docker-machine ls
NAME ACTIVE URL STATE URL SWARM DOCKER ERRORS
foo - virtualbox Running tcp://192.168.99.100:2376 v1.9.1
$ docker-machine rm -y foo
About to remove foo
Successfully removed foo
```

86
machine/reference/scp.md
View File

@ -1,86 +0,0 @@
---
description: Copy files among machines
keywords: machine, scp, subcommand
title: docker-machine scp
---
Copy files from your local host to a machine, from machine to machine, or from a
machine to your local host using `scp`.
The notation is `machinename:/path/to/files` for the arguments; in the host
machine's case, you don't need to specify the name, just the path.
## Example
Consider the following example:
```console
$ cat foo.txt
cat: foo.txt: No such file or directory
$ docker-machine ssh dev pwd
/home/docker
$ docker-machine ssh dev 'echo A file created remotely! >foo.txt'
$ docker-machine scp dev:/home/docker/foo.txt .
foo.txt 100% 28 0.0KB/s 00:00
$ cat foo.txt
A file created remotely!
```
Just like how `scp` has a `-r` flag for copying files recursively,
`docker-machine` has a `-r` flag for this feature.
In the case of transferring files from machine to machine,
they go through the local host's filesystem first (using `scp`'s `-3` flag).
When transferring large files or updating directories with lots of files,
you can use the `-d` flag, which uses `rsync` to transfer deltas instead of
transferring all of the files.
When transferring directories and not just files, avoid rsync surprises
by using trailing slashes on both the source and destination. For example:
```console
$ mkdir -p bar
$ touch bar/baz
$ docker-machine scp -r -d bar/ dev:/home/docker/bar/
$ docker-machine ssh dev ls bar
baz
```
## Specifying file paths for remote deployments
When you copy files to a remote server with `docker-machine scp` for app
deployment, make sure `docker-compose` and the Docker daemon know how to find
them. Avoid using relative paths, but specify absolute paths in
[Compose files](../../compose/compose-file/index.md). It's best to specify absolute
paths both for the location on the Docker daemon and within the container.
For example, imagine you want to transfer your local directory
`/Users/<username>/webapp` to a remote machine and bind mount it into a
container on the remote host. If the remote user is `ubuntu`, use a command like
this:
```console
$ docker-machine scp -r /Users/<username>/webapp MACHINE-NAME:/home/ubuntu/webapp
```
Then write a docker-compose file that bind mounts it in:
```yaml
version: "{{ site.compose_file_v3 }}"
services:
webapp:
image: alpine
command: cat /app/root.php
volumes:
- "/home/ubuntu/webapp:/app"
```
And we can try it out like so:
```console
$ eval $(docker-machine env MACHINE-NAME)
$ docker-compose run webapp
```

94
machine/reference/ssh.md
View File

@ -1,94 +0,0 @@
---
description: Log into or run a command on a machine using SSH.
keywords: machine, ssh, subcommand
title: docker-machine ssh
---
Log into or run a command on a machine using SSH.
To login, just run `docker-machine ssh machinename`:
```console
$ docker-machine ssh dev
## .
## ## ## ==
## ## ## ## ===
/""""""""""""""""\___/ ===
~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ / ===- ~~~
\______ o __/
\ \ __/
\____\______/
_ _ ____ _ _
| |__ ___ ___ | |_|___ \ __| | ___ ___| | _____ _ __
| '_ \ / _ \ / _ \| __| __) / _` |/ _ \ / __| |/ / _ \ '__|
| |_) | (_) | (_) | |_ / __/ (_| | (_) | (__| < __/ |
|_.__/ \___/ \___/ \__|_____\__,_|\___/ \___|_|\_\___|_|
Boot2Docker version 1.4.0, build master : 69cf398 - Fri Dec 12 01:39:42 UTC 2014
docker@boot2docker:~$ ls /
Users/ dev/ home/ lib/ mnt/ proc/ run/ sys/ usr/
bin/ etc/ init linuxrc opt/ root/ sbin/ tmp var/
```
You can also specify commands to run remotely by appending them directly to the
`docker-machine ssh` command, much like the regular `ssh` program works:
```console
$ docker-machine ssh dev free
total used free shared buffers
Mem: 1023556 183136 840420 0 30920
-/+ buffers: 152216 871340
Swap: 1212036 0 1212036
```
Commands with flags work as well:
```console
$ docker-machine ssh dev df -h
Filesystem Size Used Available Use% Mounted on
rootfs 899.6M 85.9M 813.7M 10% /
tmpfs 899.6M 85.9M 813.7M 10% /
tmpfs 499.8M 0 499.8M 0% /dev/shm
/dev/sda1 18.2G 58.2M 17.2G 0% /mnt/sda1
cgroup 499.8M 0 499.8M 0% /sys/fs/cgroup
/dev/sda1 18.2G 58.2M 17.2G 0%
/mnt/sda1/var/lib/docker/aufs
```
If you are using the "external" SSH type as detailed in the next section, you
can include additional arguments to pass through to the `ssh` binary in the
generated command (unless they conflict with any of the default arguments for
the command generated by Docker Machine). For instance, the following command
forwards port 8080 from the `default` machine to `localhost` on your host
computer:
```console
$ docker-machine ssh default -L 8080:localhost:8080
```
## Different types of SSH
When Docker Machine is invoked, it checks to see if you have the venerable
`ssh` binary around locally and attempts to use that for the SSH commands it
needs to run, whether they are a part of an operation such as creation or have
been requested by the user directly. If it does not find an external `ssh`
binary locally, it defaults to using a native Go implementation from
[crypto/ssh](https://godoc.org/golang.org/x/crypto/ssh). This is useful in
situations where you may not have access to traditional UNIX tools, such as if
you are using Docker Machine on Windows without having msysgit installed
alongside of it.
In most situations, you do not need to worry about this implementation detail
and Docker Machine acts sensibly out of the box. However, if you
deliberately want to use the Go native version, you can do so with a global
command line flag / environment variable like so:
```console
$ docker-machine --native-ssh ssh dev
```
There are some variations in behavior between the two methods, so report
any issues or inconsistencies if you come across them.

23
machine/reference/start.md
View File

@ -1,23 +0,0 @@
---
description: Start a machine
keywords: machine, start, subcommand
title: docker-machine start
---
```none
Usage: docker-machine start [arg...]
Start a machine
Description:
Argument(s) are one or more machine names.
```
For example:
```console
$ docker-machine start dev
Starting VM...
```

22
machine/reference/status.md
View File

@ -1,22 +0,0 @@
---
description: Get the status of a machine
keywords: machine, status, subcommand
title: docker-machine status
---
```none
Usage: docker-machine status [arg...]
Get the status of a machine
Description:
Argument is a machine name.
```
For example:
```console
$ docker-machine status dev
Running
```

29
machine/reference/stop.md
View File

@ -1,29 +0,0 @@
---
description: Gracefully stop a machine
keywords: machine, stop, subcommand
title: docker-machine stop
---
```none
Usage: docker-machine stop [arg...]
Gracefully Stop a machine
Description:
Argument(s) are one or more machine names.
```
For example:
```console
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.104:2376
$ docker-machine stop dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Stopped
```

30
machine/reference/upgrade.md
View File

@ -1,30 +0,0 @@
---
description: Upgrade Docker on a machine
keywords: machine, upgrade, subcommand
title: docker-machine upgrade
---
Upgrade a machine to the latest version of Docker. How this upgrade happens
depends on the underlying distribution used on the created instance.
For example, if the machine uses Ubuntu as the underlying operating system, it
runs a command similar to `sudo apt-get upgrade docker-engine`, because
Machine expects Ubuntu machines it manages to use this package. As another
example, if the machine uses boot2docker for its OS, this command downloads
the latest boot2docker ISO and replace the machine's existing ISO with the
latest.
```console
$ docker-machine upgrade default
Stopping machine to do the upgrade...
Upgrading machine default...
Downloading latest boot2docker release to /home/username/.docker/machine/cache/boot2docker.iso...
Starting machine back up...
Waiting for VM to start...
```
> **Note**: If you are using a custom boot2docker ISO specified using
> `--virtualbox-boot2docker-url` or an equivalent flag, running an upgrade on
> that machine completely replaces the specified ISO with the latest
> "vanilla" boot2docker ISO available.

13
machine/reference/url.md
View File

@ -1,13 +0,0 @@
---
description: Get the URL of a host
keywords: machine, url, subcommand
title: docker-machine url
---
Get the URL of a host
```console
$ docker-machine url dev
tcp://192.168.99.109:2376
```

919
machine/release-notes.md
View File

@ -1,919 +0,0 @@
---
title: Docker Machine release notes
description: Release notes for Docker Machine
keywords: release notes, machine
toc_max: 2
redirect_from:
- /release-notes/docker-machine/
---
## 0.16.2 (2019-09-02)
### General
* Compile with Golang 1.12.9.
* Fix VTX detection.
### Drivers
`amazonec2`
* Add ssh-port flag
* Add eu-north-1 zone
`vmwarefusion`
* Add nonempty flag to fix share-folder bug
`hyperv`
* Allow localized names for Virtual Switch
`google`
* Add support for non-default service account
`openstack`
* Add flag for metadata
`softlayer`
* Don't set the request method again
## 0.16.0 (2018-11-08)
### General
* Updated the default storage driver to `overlay2` for several systems.
* Improved error reporting for the `ssh` subcommand when using the `--native-ssh` flag.
### Drivers
`amazonec2`
* Improved handling of VPC errors.
`openstack`
* Machine removal no longer fails upon attempting to delete a nonexistent keypair.
## 0.15.0 (2018-06-12)
### General
* `docker-machine` can now be installed using `go install`.
* Docker Machine is now built with Go `1.10`.
* SSH connections now include a keep alive option. (docker/machine #4450)
### Drivers
`amazonec2`
* Updated default AMIs to mitigate Meltdown and Spectre.
* Added `--amazonec2-security-group-readonly` flag to prevent mutating security groups.
`exoscale`
* Updated driver to `v0.9.23`.
`hyperv`
* Fixed Hyper-V precreate issues. (docker/machine #4426)
* Added the ability to disable Hyper-V dynamic memory management during VM creation with `--hyperv-disable-dynamic-memory`.
`vmwarefusion`
* Improved shell checks (docker/machine #4491).
## 0.14.0 (2018-03-06)
### General
* Added `--client-certs` flag to the `docker-machine regenerate-certs` command.
* Improved OpenBSD support.
* Fixed a bug with `scp` commands issued from a Windows host.
* Enabled progress output by default for `scp` commands using `rsync`.
* Added `--quiet` flag to `scp` to suppress progress output.
* Machine now uses the `ss` command to detect connectivity when `netstat` is unavailable.
* Added bash completion for `docker-machine mount`.
* Improved provisioning resilience on Debian-based hosts.
### Drivers
`amazonec2`
* Added support for `eu-west-3` region
* Upon failure, the `create` command now ensures dangling resources are cleaned up before exiting
* Machine creation no longer fails when waiting on spot instance readiness
`digitalocean`
* Added `--digitalocean-monitoring` flag
* Increased the default droplet size
`exoscale`
* Updated driver library
* Several improvements and fixes to the default machine template
* Added support for user-provided SSH key (`--exoscale-ssh-key`)
* Added support for arbitrary disk size
`google`
* Enabled disk auto-deletion on newly created machines.
* Fixed a bug preventing the removal of a machine if it had already been removed remotely.
* Added support for fully qualified network and subnetwork names.
`hyperv`
* Fixed potential cmdlet collision with VMWare powercli.
* Fixed a bug with virtual switch selection.
* Machine now correctly detects if the user is a Hyper-V administrator when using a localized version of Windows.
`openstack`
* Added `--openstack-config-drive` flag
* Fixed an issue causing some user-uploaded keypairs to be removed when removing the associated machine.
* Fixed a bug preventing the removal of a machine if it had already been removed remotely.
`virtualbox`
* Added OpenBSD support
`vmwarefusion`
* Improved error detection and reporting when creating a new instance.
`vmwarevsphere`
* Added `--vmwarevsphere-folder` flag.
## 0.13.0 (2017-10-12)
### General
- Added new `docker-machine mount` command for mounting machine directories over SSHFS.
- Improved some logging messages.
- Fixed a bug with the `scp` command when using an identity file.
- Fixed a parsing error that caused the boot2docker ISO cache to malfunction, forcing a new download everytime.
### Drivers
- `azure`
- `docker-machine rm` now also cleans up the associated storage account if it has no remaining storage containers.
- The creation process will no longer recreate the associated subnet if it already it exists.
- `exoscale`
- Updated driver.
- Removed default `docker-machine` affinity group if no other affinity group was specified.
- `virtualbox`
- Fixed a bug where the machine would sometimes be assigned an invalid IP address at creation time.
- `vmwaresphere`
- Added support for multiple networks.
## 0.12.2 (2017-7-12)
### General
* The `scp` sub-command now allows to provide an optional `user@` to the address.
* Fixed bash completion on OS X.
### Drivers
* `amazonec2`
* Updated default AMIs to the latest version of Ubuntu 16.04 LTS.
* Fixed a bug preventing proper machine removal.
* `vmwarevsphere`
* Creating VMs on a DRS-enabled cluster should now work properly.
* Fixed a bug that prevented provisioning.
* `vmwarefusion`
* Fixed a bug that prevented provisioning.
* `exoscale`
* Updated library.
## 0.12.1 (2017-6-30)
### General
- Fixed an issue with the version comparison function that prevented machines created with Engine 17.06.0 from starting properly.
## 0.12.0 (2017-6-5)
### General
- Various bash completion improvements.
- Bump Go to version 1.8.3.
### Drivers
- `openstack`
- Enable `HTTP_PROXY`
- `digitalocean`
- Add support for tagging.
- `virtualbox`
- Scope DHCP address range based on CIDR
- `generic`
- Increase default timeout
- `google`
- Add subnetwork support
### Provisioners
- Remove restriction on `--engine-install-url` in default-to-boot2docker drivers (`virtualbox`, `vmwarefusion`, etc.)
- Reduce provisioning time of SUSE/openSUSE systems
## 0.11.0 (2017-4-25)
### General
- Various bugfixes and updated library dependencies
- new `docker-machine scp --delta` to invoke `rsync` behind the scenes for more efficient transfer
### Drivers
- `digitalocean`
- Add support for tagging DigitalOcean instances.
- `google`
- Add support for subnetworks
## 0.10.0 (2017-2-27)
### General
- Various improvements to shell tab completion
- Add support for compiling on ARM64 architecture
### Drivers
- Make `virtualbox` default driver
- `amazonec2`
- Update AMIs to latest version of Ubuntu 16.04 LTS
- `virtualbox`
- Fix parsing of `--virtualbox-share-folder` on Windows
- `google`
- Add `--google-open-port` flag to specify additional ports to open
### Provisioners
- Machine now uses systemd drop-in files instead of over-writing the system units
- Add support for upgrade to new Docker versioning scheme
- Use `dockerd` only in Docker versions where it is available
- Support multiple architectures in SUSE provisioner
## 0.9.0 (2017-1-17)
### General
- On Windows, the `COMPOSE_CONVERT_WINDOWS_PATHS` environment variable is now set by `docker-machine env` to improve Compose usability.
- Docker Machine can now be built on FreeBSD
- `docker-machine scp` non-22 port support
- `scp` supports SSH agent
- Bump Go version to 1.7.4
### Drivers
- `amazonec2`
- Credentials can now be loaded from IAM instance profiles
- Add `--amazonec2-userdata` flag
- Add `--amazonec2-block-duration-minutes` flag
- Add support for `us-east-2` (Ohio)
- Update base images to Ubuntu 16.04
- `azure`
- Add `--azure-dns` flag for specifying DNS names
- Add `--azure-storage-type` flag
- Allow using vnets from another resource group
- Add AzureGermanCloud support
- Add support for custom data
- Support Service Principal authentication
- Update base images to Ubuntu 16.04
- `digitalocean`
- Add ability to specify the private SSH key path
- `gce`
- Update base images to Ubuntu 16.04
- `virtualbox`
- Shared folder location can be specified instead of "hardcoded" to `C:\Users` or `/Users`
- `openstack`
- Add support for `OS_CACERT`
### Provisioners
- OpenSUSE provisioner refactored to use properly supported 3rd party code
## # 0.8.2 (2016-8-26)
- Update Go version to 1.7.1
## 0.8.1 (2016-8-20)
### Provisioners
- Fix issue with generated systemd service file on RedHat family distros
### Drivers
- `azure`
- Bump Ubuntu image to 16.04
- Update docs with updated default parameters
- Change logging slightly
## 0.8.0 (2016-6-14)
### General
- Fix issue with plugin heartbeat log repeating on disconnect
- Add `tcsh` support to `env --shell`
- Add `zsh` completion scripts
- Bump Go version to 1.6.2
### Drivers
- `amazonec2`
- Workaround to prevent orphaned SSH keys
- `virtualbox`
- Add option for VM UI type (`--virtualbox-ui-type`)
- `vmwarefusion`
- Fix CPU option inconsistency
- `openstack`
- Expose user data parameter (`--openstack-user-data-file`)
- `generic`
- Copy public key to created Machine directory
### Provisioners
- Add Oracle Enterprise Linux support
- Fix port binding of Swarm master
- Add ability to create a manager instance which does not get scheduled on
- Introduce `--swarm-join-opt` to pass options to agent nodes
- Various SSH-related fixes
- Fix state for upgrade path
## 0.7.0 (2016-4-13)
### General
- `DRIVER` environment variable now supported to supply value for `create --driver` flag
- Update to Go 1.6.1
- SSH client has been refactored
- RC versions of Machine will now create and upgrade to boot2docker RCs instead
of stable versions if available
### Drivers
- `azure`
- Driver has been completely re-written to use resource templates and a significantly easier-to-use authentication model
- `digitalocean`
- New `--digitalocean-ssh-key-fingerprint` for using existing SSH keys instead of creating new ones
- `virtualbox`
- Fix issue with `bootlocal.sh`
- New `--virtualbox-nictype` flag to set driver for NAT network
- More robust host-only interface collision detection
- Add support for running VirtualBox on a Windows 32 bit host
- Change default DNS passthrough handling
- `amazonec2`
- Specifying multiple security groups to use is now supported
- `exoscale`
- Add support for user-data
- `hyperv`
- Machines can now be created by a non-administrator
- `rackspace`
- New `--rackspace-active-timeout` parameter
- `vmwarefusion`
- Bind mount shared folder directory by default
- `google`
- New `--google-use-internal-ip-only` parameter
### Provisioners
- General
- Support for specifying Docker engine port in some cases
- CentOS
- Now defaults to using upstream `get.docker.com` script instead of custom RPMs.
- boot2docker
- More robust eth* interface detection
- Swarm
- Add `--swarm-experimental` parameter to enable experimental Swarm features
## 0.6.0 (2016-02-04)
+ Fix SSH wait before provisioning issue
## 0.6.0-rc4 (2016-02-03)
### General
+ `env`
+ Fix shell auto detection
### Drivers
+ `exoscale`
+ Fix configuration of exoscale endpoint
## 0.6.0-rc3 (2016-02-01)
- Exit with code 3 if error is during pre-create check
## 0.6.0-rc2 (2016-01-28)
- Fix issue creating Swarms
- Fix `ls` header issue
- Add code to wait for Docker daemon before returning from `start` / `restart`
- Start porting integration tests to Go from BATS
- Add Appveyor for Windows tests
- Update CoreOS provisioner to use `docker daemon`
- Various documentation and error message fixes
- Add ability to create GCE machine using existing VM
## 0.6.0-rc1 (2016-01-18)
### General
- Update to Go 1.5.3
- Short form of command invocations is now supported
- `docker-machine start`, `docker-machine stop` and others will now use
`default` as the machine name argument if one is not specified
- Fix issue with panics in drivers
- Machine now returns exit code 3 if the pre-create check fails.
- This is potentially useful for scripting `docker-machine`.
- `docker-machine provision` command added to allow re-running of provisioning
on instances.
- This allows users to re-run provisioning if it fails during `create`
instead of needing to completely start over.
### Provisioning
- Most provisioners now use `docker daemon` instead of `docker -d`
- Swarm masters now run with replication enabled
- If `/var/lib` is a BTRFS partition, `btrfs` will now be used as the storage
driver for the instance
### Drivers
- Amazon EC2
- Default VPC will be used automatically if none is specified
- Credentials are now be read from the conventional `~/.aws/credentials`
file automatically
- Fix a few issues such as nil pointer dereferences
- VMware Fusion
- Try to get IP from multiple DHCP lease files
- OpenStack
- Only derive tenant ID if tenant name is supplied
## 0.5.6 (2016-01-11)
### General
- `create`
- Set swarm master to advertise on port 3376
- Fix swarm restart policy
- Stop asking for ssh key passwords interactively
- `env`
- Improve documentation
- Fix bash on windows
- Automatic shell detection on Windows
- `help`
- Don't show the full path to `docker-machine.exe` on windows
- `ls`
- Allow custom format
- Improve documentation
- `restart`
- Improve documentation
- `rm`
- Improve documentation
- Better user experience when removing multiple hosts
- `version`
- Don't show the full path to `docker-machine.exe` on windows
- `start`, `stop`, `restart`, `kill`
- Better logs and homogeneous behaviour across all drivers
### Build
- Introduce CI tests for external binary compatibility
- Add amazon EC2 integration test
### Misc
- Improve BugSnags reports: better shell detection, better windows version detection
- Update DockerClient dependency
- Improve bash-completion script
- Improve documentation for bash-completion
### Drivers
- Amazon EC2
- Improve documentation
- Support optional tags
- Option to create EbsOptimized instances
- Google
- Fix remove when instance is stopped
- Openstack
- Flags to import and reuse existing nova keypairs
- VirtualBox
- Fix multiple bugs related to host-only adapters
- Retry commands when `VBoxManage` is not ready
- Reject VirtualBox versions older that 4.3
- Fail with a clear message when Hyper-v installation prevents VirtualBox from working
- Print a warning for Boot2Docker v1.9.1, which is known to have an issue with AUFS
- Vmware Fusion
- Support soft links in VM paths
### Libmachine
- Fix code sample that uses libmachine
- libmachine can be used in external applications
## 0.5.5 (2015-12-28)
### General
- `env`
- Better error message if swarm is down
- Add quotes to command if there are spaces in the path
- Fix Powershell env hints
- Default to cmd shell on windows
- Detect fish shell
- `scp`
- Ignore empty ssh key
- `stop`, `start`, `kill`
- Add feedback to the user
- `rm`
- Now works when `config.json` is not found
- `ssh`
- Disable ControlPath
- Log which SSH client is used
- `ls`
- Listing is now faster by reducing calls to the driver
- Shows if the active machine is a swarm cluster
### Build
- Automate 90% of the release process
- Upgrade to Go 1.5.2
- Don't build 32bits binaries for Linux and OSX
- Prevent makefile from defaulting to using containers
### Misc
- Update docker-machine version
- Updated the bash completion with new options added
- Bugsnag: Retrieve windows version on non-English OS
### Drivers
- Amazon EC2
- Convert API calls to official SDK
- Make DeviceName configurable
- DigitalOcean
- Custom SSH port support
- Generic
- Don't support `kill` since `stop` is not supported
- Google
- Coreos provisionning
- Hyper-V
- Lot's of code simplifications
- Pre-Check that the user is an Administrator
- Pre-Check that the virtual switch exists
- Add Environment variables for each flag
- Fix how Powershell is detected
- VSwitch name should be saved to config.json
- Add a flag to set the CPU count
- Close handle after copying boot2docker.iso into vm folder - will otherwise keep hyper-v from starting vm
- Update Boot2Docker cache in PreCreateCheck phase
- OpenStack
- Filter floating IPs by tenant ID
- VirtualBox
- Reject duplicate hostonlyifs Name/IP with clear message
- Detect when hostonlyif can't be created. Point to known working version of VirtualBox
- Don't create the VM if no hardware virtualization is available and add a flag to force create
- Add `VBox.log` to bugsnag crashreport
- Update Boot2Docker cache in PreCreateCheck phase
- Detect Incompatibility with Hyper-v
- VSphere
- Rewrite driver to work with govmomi instead of wrapping govc
- All
- Change host restart to use the driver implementation
- Fix truncated logs
- Increase heartbeat interval and timeout
### Provisioners
- Download latest Boot2Docker if it is out-of-date
- Add swarm config to coreos
- All provisioners now honor `engine-install-url`
## 0.5.4 (2015-12-28)
This is a patch release to fix a regression with STDOUT/STDERR behavior (#2587).
## 0.5.3 (2015-12-14)
With this release Machine reverts to distribution in a single binary, which is more efficient on bandwidth and hard disk space. All the core driver plugins are now included in the main binary. Delete the old driver binaries that you might have in your path.
```console
$ rm /usr/local/bin/docker-machine-driver-{amazonec2,azure,digitalocean,exoscale,generic,google,hyperv,none,openstack,rackspace,softlayer,virtualbox,vmwarefusion,vmwarevcloudair,vmwarevsphere}
```
Non-core driver plugins should still work as intended (in externally distributed binaries of the form `docker-machine-driver-name`. Report any issues you encounter them with externally loaded plugins.
### General
- Optionally report crashes to Bugsnag to help us improve docker-machine
- Fix multiple nil dereferences in `docker-machine ls` command
- Improve the build and CI
- `docker-machine env` now supports emacs
- Run Swarm containers in provisioning step using Docker API instead of SSH/shell
- Show docker daemon version in `docker-machine ls`
- `docker-machine ls` can filter by engine label
- `docker-machine ls` filters are case insensitive
- `--timeout` flag for `docker-machine ls`
- Logs use `logrus` library
- Swarm container network is now `host`
- Added advertise flag to Swarm manager template
- Fix `help` flag for `docker-machine ssh`
- Add confirmation `-y` flag to `docker-machine rm`
- Fix `docker-machine config` for fish
- Embed all core drivers in `docker-machine` binary to reduce the bundle from 120M to 15M
### Drivers
- Generic
- Support password protected ssh keys though ssh-agent
- Support DNS names
- VirtualBox
- Show a warning if virtualbox is too old
- Recognize yet another Hardware Virtualization issue pattern
- Fix Hardware Virtualization on Linux/AMD
- Add the `--virtualbox-host-dns-resolver` flag
- Allow virtualbox DNSProxy override
- Google
- Open firewall port for Swarm when needed
- VMware Fusion
- Explicitly set umask before invoking vmrun in vmwarefusion
- Activate the plugin only on OSX
- Add id/gid option to mount when using vmhgfs
- Fix for vSphere driver boot2docker ISO issues
- DigitalOcean
- Support for creating Droplets with Cloud-init User Data
- Openstack
- Sanitize keynames by replacing dots with underscores
- All
- Most base images are now set to `Ubuntu 15.10`
- Fix compatibility with drivers developed with docker-machine 0.5.0
- Better error report for broken/incompatible drivers
- Don't break `config.json` configuration when the disk is full
### Provisioners
- Increase timeout for installing boot2docker
- Support `Ubuntu 15.10`
### Misc
- Improve the documentation
- Update known drivers list
## 0.5.2 (2015-11-30)
### General
- Bash autocompletion and helpers fixed
- Remove `RawDriver` from `config.json` - Driver parameters can now be edited
directly again in this file.
- Change fish `env` variable setting to be global
- Add `docker-machine version` command
- Move back to normal `codegangsta/cli` upstream
- `--tls-san` flag for extra SANs
### Drivers
- Fix `GetURL` IPv6 compatibility
- Add documentation page for available 3rd party drivers
- VirtualBox
- Support for shared folders and virtualization detection on Linux hosts
- Improved detection of invalid host-only interface settings
- Google
- Update default images
- VMware Fusion
- Add option to disable shared folder
- Generic
- New environment variables for flags
### Provisioners
- Support for Ubuntu >=15.04. This means Ubuntu machines can be created which
work with `overlay` driver of lib network.
- Fix issue with current netstat / daemon availability checking
## 0.5.1 (2015-11-16)
- Fixed boot2docker VM import regression
- Fix regression breaking `docker-machine env -u` to unset environment variables
- Enhanced virtualization capability detection and `VBoxManage` path detection
- Properly lock VirtualBox access when running several commands concurrently
- Allow plugins to write to STDOUT without `--debug` enabled
- Fix Rackspace driver regression
- Support colons in `docker-machine scp` filepaths
- Pass environment variables for provisioned Engines to Swarm as well
- Various enhancements around boot2docker ISO upgrade (progress bar, increased timeout)
## 0.5.0 (2015-11-1)
### General
- Add pluggable driver model
- Clean up code to be more modular and reusable in `libmachine`
- Add `--github-api-token` for situations where users are getting rate limited
by GitHub attempting to get the current `boot2docker.iso` version
- Various enhancements around the Makefile and build toolchain (still an active WIP)
- Disable SSH multiplex explicitly in commands run with the "External" client
- Show "-" for "inactive" machines instead of nothing
- Make daemon status detection more robust
### Provisioners
- New CoreOS, SUSE, and Arch Linux provisioners
- Fixes around package installation / upgrade code on Debian and Ubuntu
### CLI
- Support for regular expression pattern matching and matching by names in `ls --filter`
- `--no-proxy` flag for `env` (sets `NO_PROXY` in addition to other environment variables)
### Drivers
- `openstack`
- `--openstack-ip-version` parameter
- `--openstack-active-timeout` parameter
- `google`
- fix destructive behavior of `start` / `stop`
- `hyperv`
- fix issues with PowerShell
- `vmwarefusion`
- some issues with shared folders fixed
- `--vmwarefusion-configdrive-url` option for configuration via `cloud-init`
- `amazonec2`
- `--amazonec2-use-private-address` option to use private networking
- `virtualbox`
- Enhancements around robustness of the created host-only network
- Fix IPv6 network mask prefix parsing
- `--virtualbox-no-share` option to disable the automatic home directory mount
- `--virtualbox-hostonly-nictype` and `--virtualbox-hostonly-nicpromisc` for controlling settings around the created hostonly NIC
## 0.4.1 (2015-08)
- Fixes `upgrade` functionality on Debian based systems
- Fixes `upgrade` functionality on Ubuntu based systems
## 0.4.0 (2015-08-11)
### Updates
- HTTP Proxy support for Docker Engine
- RedHat distros now use Docker Yum repositories
- Ability to set environment variables in the Docker Engine
- Internal libmachine updates for stability
### Drivers
- Google:
- Preemptible instances
- Static IP support
### Fixes
- Swarm Discovery Flag is verified
- Timeout added to `ls` command to prevent hangups
- SSH command failure now reports information about error
- Configuration migration updates
## 0.3.0 (2015-06-18)
### Features
- Engine option configuration (ability to configure all engine options)
- Swarm option configuration (ability to configure all swarm options)
- New Provisioning system to allow for greater flexibility and stability for installing and configuring Docker
- New Provisioners
- Rancher OS
- RedHat Enterprise Linux 7.0+ (experimental)
- Fedora 21+ (experimental)
- Debian 8+ (experimental)
- PowerShell support (configure Windows Docker CLI)
- Command Prompt (cmd.exe) support (configure Windows Docker CLI)
- Filter command help by driver
- Ability to import Boot2Docker instances
- Boot2Docker CLI migration guide (experimental)
- Format option for `inspect` command
- New logging output format to improve readability and display across platforms
- Updated "active" machine concept - now is implicit according to `DOCKER_HOST` environment variable. Note: this removes the implicit "active" machine and can no longer be specified with the `active` command. You change the "active" host by using the `env` command instead.
- Specify Swarm version (`--swarm-image` flag)
### Drivers
- New: Exoscale Driver
- New: Generic Driver (provision any host with supported base OS and SSH)
- Amazon EC2
- SSH user is configurable
- Support for Spot instances
- Add option to use private address only
- Base AMI updated to 20150417
- Google
- Support custom disk types
- Updated base image to v20150316
- Openstack
- Support for Keystone v3 domains
- Rackspace
- Misc fixes including environment variable for Flavor Id and stability
- Softlayer
- Enable local disk as provisioning option
- Fixes for SSH access errors
- Fixed bug where public IP would always be returned when requesting private
- Add support for specifying public and private VLAN IDs
- VirtualBox
- Use Intel network interface driver (adds great stability)
- Stability fixes for NAT access
- Use DNS pass through
- Default CPU to single core for improved performance
- Enable shared folder support for Windows hosts
- VMware Fusion
- Boot2Docker ISO updated
- Shared folder support
### Fixes
- Provisioning improvements to ensure Docker is available
- SSH improvements for provisioning stability
- Fixed SSH key generation bug on Windows
- Help formatting for improved readability
### Breaking Changes
- "Short-Form" name reference no longer supported Instead of "docker-machine " implying the active host you must now use docker-machine
- VMware shared folders require Boot2Docker 1.7
### Special Thanks
We would like to thank all contributors. Machine would not be where it is
without you. We would also like to give special thanks to the following
contributors for outstanding contributions to the project:
- @frapposelli for VMware updates and fixes
- @hairyhenderson for several improvements to Softlayer driver, inspect formatting and lots of fixes
- @ibuildthecloud for rancher os provisioning
- @sthulb for portable SSH library
- @vincentbernat for exoscale
- @zchee for Amazon updates and great doc updates
## 0.2.0 (2015-04-16)
Core Stability and Driver Updates
### Core
- Support for system proxy environment
- New command to regenerate TLS certificates
- Note: this will restart the Docker engine to apply
- Updates to driver operations (create, start, stop, etc) for better reliability
- New internal `libmachine` package for internal api (not ready for public usage)
- Updated Driver Interface
- [Driver Spec](https://github.com/docker/machine/blob/master/docs/DRIVER_SPEC.md)
- Removed host provisioning from Drivers to enable a more consistent install
- Removed SSH commands from each Driver for more consistent operations
- Swarm: machine now uses Swarm default binpacking strategy
### Driver Updates
- All drivers updated to new Driver interface
- Amazon EC2
- Better checking for subnets on creation
- Support for using Private IPs in VPC
- Fixed bug with duplicate security group authorization with Swarm
- Support for IAM instance profile
- Fixed bug where IP was not properly detected upon stop
- DigitalOcean
- IPv6 support
- Backup option
- Private Networking
- Openstack / Rackspace
- Gophercloud updated to latest version
- New insecure flag to disable TLS (use with caution)
- Google
- Google source image updated
- Ability to specify auth token via file
- VMware Fusion
- Paravirtualized driver for disk (pvscsi)
- Enhanced paravirtualized NIC (vmxnet3)
- Power option updates
- SSH keys persistent across reboots
- Stop now gracefully stops VM
- vCPUs now match host CPUs
- SoftLayer
- Fixed provision bug where `curl` was not present
- VirtualBox
- Correct power operations with Saved VM state
- Fixed bug where image option was ignored
### CLI
- Auto-regeneration of TLS certificates when TLS error is detected
- Note: this will restart the Docker engine to apply
- Minor UI updates including improved sorting and updated command docs
- Bug with `config` and `env` with spaces fixed
- Note: you now must use `eval $(docker-machine env machine)` to load environment settings
- Updates to better support `fish` shell
- Use `--tlsverify` for both `config` and `env` commands
- Commands now use eval for better interoperability with shell
### Testing
- New integration test framework (bats)
## 0.1.0 (2015-02-26)
Initial beta release.
- Provision Docker Engines using multiple drivers
- Provide light management for the machines
- Create, Start, Stop, Restart, Kill, Remove, SSH
- Configure the Docker Engine for secure communication (TLS)
- Easily switch target machine for fast configuration of Docker Engine client
- Provision Swarm clusters (experimental)
### Included drivers
- Amazon EC2
- DigitalOcean
- Google
- Microsoft Azure
- Microsoft Hyper-V
- Openstack
- Rackspace
- VirtualBox
- VMware Fusion
- VMware vCloud Air
- VMware vSphere

4
samples/wordpress.md
View File

@ -125,10 +125,6 @@ administrator.
because the containers are still being initialized and may take a couple of
minutes before the first load.
If you are using [Docker Machine](../machine/index.md), you can run the command
`docker-machine ip MACHINE_VM` to get the machine address, and then open
`http://MACHINE_VM_IP:8000` in a web browser.
If you are using Docker Desktop for Mac or Docker Desktop for Windows, you can use
`http://localhost` as the IP address, and open `http://localhost:8000` in a web
browser.

5
toolbox/index.md
View File

@ -16,11 +16,12 @@ toc_min: 1
toc_max: 2
---
>**Deprecated**
> **Deprecated**
>
> Docker Toolbox has been deprecated and is no longer in active development. Please
> use Docker Desktop instead. See [Docker Desktop for Mac](../desktop/mac/index.md)
> and [Docker Desktop for Windows](../desktop/windows/index.md).
{: .warning }
The source code for Toolbox has been archived, but [can be found on GitHub](https://github.com/docker-archive/toolbox){:target="_blank" rel="noopener" class="_"}.
The source code for Toolbox has been archived, You can find the source code
on [GitHub](https://github.com/docker-archive/toolbox){:target="_blank" rel="noopener" class="_"}.