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

Merge pull request #390 from sthulb/rename 

Change binary name to docker-machine
This commit is contained in:
Evan Hazlett 2015-01-22 16:19:00 -05:00
parent 29c1eb9080 cdeaeb7896
commit badf0bffcd
9 changed files with 146 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.dockerignore
View File

@ -1,2 +1,2 @@
machine*
docker-machine*
.git

2
.gitignore vendored
View File

@ -1 +1 @@
machine*
docker-machine*

2
Dockerfile
View File

@ -4,6 +4,6 @@ RUN go get github.com/mitchellh/gox
RUN go get github.com/aktau/github-release
RUN go get github.com/tools/godep
ENV GOPATH /go/src/github.com/docker/machine/Godeps/_workspace:/go
ENV MACHINE_BINARY /go/src/github.com/docker/machine/machine
ENV MACHINE_BINARY /go/src/github.com/docker/machine/docker-machine
WORKDIR /go/src/github.com/docker/machine
ADD . /go/src/github.com/docker/machine

18
README.md
View File

@ -5,7 +5,7 @@ Machine makes it really easy to create Docker hosts on local hypervisors and clo
It works a bit like this:
```console
$ machine create -d virtualbox dev
$ docker-machine create -d virtualbox dev
[info] Downloading boot2docker...
[info] Creating SSH key...
[info] Creating VirtualBox VM...
@ -13,11 +13,11 @@ $ machine create -d virtualbox dev
[info] Waiting for VM to start...
[info] "dev" has been created and is now the active host. Docker commands will now run against that host.
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.100:2375
$ docker $(machine config dev) run busybox echo hello world
$ docker $(docker-machine config dev) run busybox echo hello world
Unable to find image 'busybox' locally
Pulling repository busybox
e72ac664f4f0: Download complete
@ -26,19 +26,19 @@ df7546f9f060: Download complete
e433a6c5b276: Download complete
hello world
$ machine create -d digitalocean --digitalocean-access-token=... staging
$ docker-machine create -d digitalocean --digitalocean-access-token=... staging
[info] Creating SSH key...
[info] Creating Digital Ocean droplet...
[info] Waiting for SSH...
[info] "staging" has been created and is now the active host. Docker commands will now run against that host.
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev virtualbox Running tcp://192.168.99.108:2376
staging * digitalocean Running tcp://104.236.37.134:2376
```
Machine creates Docker hosts that are secure by default. The connection between the client and daemon is encrypted and authenticated using TLS security. To get the Docker arguments for a machine use the command: `machine config <machine-name>` i.e. `machine config dev`.
Machine creates Docker hosts that are secure by default. The connection between the client and daemon is encrypted and authenticated using TLS security. To get the Docker arguments for a machine use the command: `docker-machine config <machine-name>` i.e. `docker-machine config dev`.
## Try it out
@ -58,7 +58,7 @@ Options:
### Digital Ocean
Creates machines on [Digital Ocean](https://www.digitalocean.com/). You need to create a personal access token under "Apps & API" in the Digital Ocean Control Panel and pass that to `machine create` with the `--digitalocean-access-token` option.
Creates machines on [Digital Ocean](https://www.digitalocean.com/). You need to create a personal access token under "Apps & API" in the Digital Ocean Control Panel and pass that to `docker-machine create` with the `--digitalocean-access-token` option.
Options:
@ -79,9 +79,9 @@ You need to create a subscription with a cert. Run these commands:
Go to the Azure portal, go to the "Settings" page, then "Manage Certificates" and upload `mycert.cer`.
Grab your subscription ID from the portal, then run `machine create` with these details:
Grab your subscription ID from the portal, then run `docker-machine create` with these details:
$ machine create -d azure --azure-subscription-id="SUB_ID" --azure-subscription-cert="mycert.pem"
$ docker-machine create -d azure --azure-subscription-id="SUB_ID" --azure-subscription-cert="mycert.pem"
Options:

4
ROADMAP.md
View File

@ -19,6 +19,6 @@ There are two main areas for future development:
- **Swarm integration:** Machine should be able to create and manage [Swarm](https://github.com/docker/swarm) clusters. Perhaps it's even the default. Imagine this:
$ machine create -d digitalocean production
$ machine scale production=100
$ docker-machine create -d digitalocean production
$ docker-machine scale production=100

2
commands.go
View File

@ -203,7 +203,7 @@ func cmdCreate(c *cli.Context) {
log.Infof("%q has been created and is now the active machine", name)
// TODO @ehazlett: this will likely change but at least show how to connect for now
log.Infof("To connect: docker $(machine config %s) ps", name)
log.Infof("To connect: docker $(%s config %s) ps", c.App.Name, name)
}
func cmdConfig(c *cli.Context) {

148
docs/dockermachine.md
View File

@ -22,9 +22,9 @@ yourself, manually install Docker, etc.) and therefore tedious and error-prone
- with existing automation technologies, which usually entail a quite high skill
threshold
Docker's [`machine`](https://github.com/docker/machine) is a tool for making the
Docker's [`docker-machine`](https://github.com/docker/machine) is a tool for making the
process of creating and managing those machines (and running Docker commands
against them) much faster and easier for users. `machine` allows users to
against them) much faster and easier for users. `docker-machine` allows users to
quickly create running instances of the Docker daemon on local virtualization
platforms (e.g. Virtualbox) or on cloud providers (e.g. AWS EC2) that they can
connect to and control from their local Docker client binary.
@ -42,31 +42,31 @@ correct place in your `PATH`:
- [OSX - i386]()
- [Linux - i386]()
Now you should be able to check the version with `machine -v`:
Now you should be able to check the version with `docker-machine -v`:
```
$ machine -v
$ docker-machine -v
machine version 0.0.3
```
## Getting started with Docker Machine using a local VM
Let's take a look at using `machine` to creating, using, and managing a Docker
Let's take a look at using `docker-machine` to creating, using, and managing a Docker
host inside of [VirtualBox](ihttps://www.virtualbox.org/).
First, ensure that
[VirtualBox 4.3.20](https://www.virtualbox.org/wiki/Downloads) is correctly
installed on your system.
If you run the `machine ls` command to show all available machines, you will see
If you run the `docker-machine ls` command to show all available machines, you will see
that none have been created so far.
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
```
To create one, we run the `machine create` command, passing the string
To create one, we run the `docker-machine create` command, passing the string
`virtualbox` to the `--driver` flag. The final argument we pass is the name of
the machine - in this case, we will name our machine "dev".
@ -76,41 +76,41 @@ daemon installed, and will create and start a VirtualBox VM with Docker running.
```
$ machine create --driver virtualbox dev
$ docker-machine create --driver virtualbox dev
INFO[0000] Creating SSH key...
INFO[0000] Creating VirtualBox VM...
INFO[0007] Starting VirtualBox VM...
INFO[0007] Waiting for VM to start...
INFO[0038] "dev" has been created and is now the active machine
INFO[0038] To connect: docker $(machine config dev) ps
INFO[0038] To connect: docker $(docker-machine config dev) ps
```
You can see the machine you have created by running the `machine ls` command
You can see the machine you have created by running the `docker-machine ls` command
again:
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.100:2375
```
The `*` next to `dev` indicates that it is the active host.
Next, as noted in the output of the `machine create` command, we have to tell
Docker to talk to that machine. You can do this with the `machine config`
Next, as noted in the output of the `docker-machine create` command, we have to tell
Docker to talk to that machine. You can do this with the `docker-machine config`
command. For example,
```
$ docker $(machine config dev) ps
$ docker $(docker-machine config dev) ps
```
This will pass arguments to the Docker client that specify the TLS settings.
To see what will be passed, run `machine config dev`.
To see what will be passed, run `docker-machine config dev`.
You can now run Docker commands on this host:
```
$ docker $(machine config dev) run busybox echo hello world
$ docker $(docker-machine config dev) run busybox echo hello world
Unable to find image 'busybox' locally
Pulling repository busybox
e72ac664f4f0: Download complete
@ -121,46 +121,46 @@ hello world
```
Any exposed ports are available on the Docker host’s IP address, which you can
get using the `machine ip` command:
get using the `docker-machine ip` command:
```
$ machine ip
$ docker-machine ip
192.168.99.100
```
Now you can manage as many local VMs running Docker as you please- just run
`machine create` again.
`docker-machine create` again.
If you are finished using a host, you can stop it with `docker stop` and start
it again with `docker start`:
```
$ machine stop
$ machine start
$ docker-machine stop
$ docker-machine start
```
If they aren't passed any arguments, commands such as `machine stop` will run
If they aren't passed any arguments, commands such as `docker-machine stop` will run
against the active host (in this case, the VirtualBox VM). You can also specify
a host to run a command against as an argument. For instance, you could also
have written:
```
$ machine stop dev
$ machine start dev
$ docker-machine stop dev
$ docker-machine start dev
```
## Using Docker Machine with a cloud provider
One of the nice things about `machine` is that it provides several “drivers”
One of the nice things about `docker-machine` is that it provides several “drivers”
which let you use the same interface to create hosts on many different cloud
platforms. This is accomplished by using the `machine create` command with the
platforms. This is accomplished by using the `docker-machine create` command with the
`--driver` flag. Here we will be demonstrating the
[Digital Ocean](https://digitalocean.com) driver (called `digitalocean`), but
there are drivers included for several providers including Amazon Web Services,
Google Compute Engine, and Microsoft Azure.
Usually it is required that you pass account verification credentials for these
providers as flags to `machine create`. These flags are unique for each driver.
providers as flags to `docker-machine create`. These flags are unique for each driver.
For instance, to pass a Digital Ocean access token you use the
`--digitalocean-access-token` flag.
@ -175,13 +175,13 @@ the side panel.
is checked, and click on "Generate Token".
4. Grab the big long hex string that is generated (this is your token) and store it somehwere safe.
Now, run `machine create` with the `digitalocean` driver and pass your key to
Now, run `docker-machine create` with the `digitalocean` driver and pass your key to
the `--digitalocean-access-token` flag.
Example:
```
$ machine create \
$ docker-machine create \
--driver digitalocean \
--digitalocean-access-token 0ab77166d407f479c6701652cee3a46830fef88b8199722b87821621736ab2d4 \
staging
@ -189,52 +189,52 @@ INFO[0000] Creating SSH key...
INFO[0000] Creating Digital Ocean droplet...
INFO[0002] Waiting for SSH...
INFO[0085] "staging" has been created and is now the active machine
INFO[0085] To connect: docker $(machine config dev) staging
INFO[0085] To connect: docker $(docker-machine config dev) staging
```
For convenience, `machine` will use sensible defaults for choosing settings such
For convenience, `docker-machine` will use sensible defaults for choosing settings such
as the image that the VPS is based on, but they can also be overridden using
their respective flags (e.g. `--digitalocean-image`). This is useful if, for
instance, you want to create a nice large instance with a lot of memory and CPUs
(by default `machine` creates a small VPS). For a full list of the
(by default `docker-machine` creates a small VPS). For a full list of the
flags/settings available and their defaults, see the output of
`machine create -h`.
`docker-machine create -h`.
When the creation of a host is initiated, a unique SSH key for accessing the
host (initially for provisioning, then directly later if the user runs the
`machine ssh` command) will be created automatically and stored in the client's
`docker-machine ssh` command) will be created automatically and stored in the client's
directory in `~/.docker/machines`. After the creation of the SSH key, Docker
will be installed on the remote machine and the daemon will be configured to
accept remote connections over TCP using TLS for authentication. Once this
is finished, the host is ready for connection.
And then from this point, the remote host behaves much like the local host we
created in the last section. If we look at `machine`, we’ll see it is now the
created in the last section. If we look at `docker-machine`, we’ll see it is now the
active host:
```
$ machine active dev
$ machine ls
$ docker-machine active dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev virtualbox Running tcp://192.168.99.103:2375
staging * digitalocean Running tcp://104.236.50.118:2375
```
To select an active host, you can use the `machine active` command.
To select an active host, you can use the `docker-machine active` command.
```
$ machine active dev
$ machine ls
$ docker-machine active dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.103:2375
staging digitalocean Running tcp://104.236.50.118:2375
```
To remove a host and all of its containers and images, use `machine rm`:
To remove a host and all of its containers and images, use `docker-machine rm`:
```
$ machine rm dev staging
$ machine ls
$ docker-machine rm dev staging
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
```
@ -245,8 +245,8 @@ can be used an alias for an existing host so you don’t have to type out the UR
every time you run a Docker command.
```
$ machine create --url=tcp://50.134.234.20:2376 custombox
$ machine ls
$ docker-machine create --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
```
@ -258,12 +258,12 @@ custombox * none Running tcp://50.134.234.20:2376
Get or set the active machine.
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev virtualbox Running tcp://192.168.99.103:2375
staging * digitalocean Running tcp://104.236.50.118:2375
$ machine active dev
$ machine ls
$ docker-machine active dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.103:2375
staging digitalocean Running tcp://104.236.50.118:2375
@ -274,12 +274,12 @@ staging digitalocean Running tcp://104.236.50.118:2375
Create a machine.
```
$ machine create --driver virtualbox dev
$ docker-machine create --driver virtualbox dev
INFO[0000] Creating SSH key...
INFO[0000] Creating VirtualBox VM...
INFO[0007] Starting VirtualBox VM...
INFO[0007] Waiting for VM to start...
INFO[0038] "dev" has been created and is now the active machine. To point Docker at this machine, run: export DOCKER_HOST=$(machine url) DOCKER_AUTH=identity
INFO[0038] "dev" has been created and is now the active machine. To point Docker at this machine, run: export DOCKER_HOST=$(docker-machine url) DOCKER_AUTH=identity
```
#### config
@ -287,7 +287,7 @@ INFO[0038] "dev" has been created and is now the active machine. To point Docker
Show the Docker client configuration for a machine.
```
$ machine config dev
$ docker-machine config dev
--tls --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
```
@ -296,7 +296,7 @@ $ machine config dev
Inspect information about a machine.
```
$ machine inspect dev
$ docker-machine inspect dev
{
"DriverName": "virtualbox",
"Driver": {
@ -318,7 +318,7 @@ Show help text.
Get the IP address of a machine.
```
$ machine ip
$ docker-machine ip
192.168.99.104
```
@ -327,11 +327,11 @@ $ machine ip
Kill (abruptly force stop) a machine.
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.104:2376
$ machine kill dev
$ machine ls
$ docker-machine kill dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Stopped
```
@ -341,7 +341,7 @@ dev * virtualbox Stopped
List machines.
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev virtualbox Stopped
foo0 virtualbox Running tcp://192.168.99.105:2376
@ -354,10 +354,10 @@ foo4 * virtualbox Running tcp://192.168.99.109:2376
#### restart
Restart a machine. Oftentimes this is equivalent to
`machine stop; machine start`.
`docker-machine stop; machine start`.
```
$ machine restart
$ docker-machine restart
INFO[0005] Waiting for VM to start...
```
@ -367,12 +367,12 @@ Remove a machine. This will remove the local reference as well as delete it
on the cloud provider or virtualization management platform.
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
foo0 virtualbox Running tcp://192.168.99.105:2376
foo1 virtualbox Running tcp://192.168.99.106:2376
$ machine rm foo1
$ machine ls
$ docker-machine rm foo1
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
foo0 virtualbox Running tcp://192.168.99.105:2376
```
@ -382,9 +382,9 @@ foo0 virtualbox Running tcp://192.168.99.105:2376
Log into or run a command on a machine using SSH.
```
$ machine ssh -c "echo this process ran on a remote machine"
$ docker-machine ssh -c "echo this process ran on a remote machine"
this process ran on a remote machine
$ machine ssh
$ docker-machine ssh
## .
## ## ## ==
## ## ## ## ===
@ -409,7 +409,7 @@ bin/ etc/ init linuxrc opt/ root/ sbin/ tmp var/
Gracefully start a machine.
```
$ machine restart
$ docker-machine restart
INFO[0005] Waiting for VM to start...
```
@ -418,11 +418,11 @@ INFO[0005] Waiting for VM to start...
Gracefully stop a machine.
```
$ machine ls
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Running tcp://192.168.99.104:2376
$ machine stop dev
$ machine ls
$ docker-machine stop dev
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL
dev * virtualbox Stopped
```
@ -432,7 +432,7 @@ dev * virtualbox Stopped
Upgrade a machine to the latest version of Docker.
```
$ machine upgrade dev
$ docker-machine upgrade dev
```
#### url
@ -440,7 +440,7 @@ $ machine upgrade dev
Get the URL of a host
```
$ machine url
$ docker-machine url
tcp://192.168.99.109:2376
```
@ -465,7 +465,7 @@ Options:
- `--amazonec2-zone`: The AWS zone launch the instance in (i.e. one of a,b,c,d,e).
#### Digital Ocean
Creates machines on [Digital Ocean](https://www.digitalocean.com/). You need to create a personal access token under "Apps & API" in the Digital Ocean Control Panel and pass that to `machine create` with the `--digitalocean-access-token` option.
Creates machines on [Digital Ocean](https://www.digitalocean.com/). You need to create a personal access token under "Apps & API" in the Digital Ocean Control Panel and pass that to `docker-machine create` with the `--digitalocean-access-token` option.
Options:
@ -521,9 +521,9 @@ You need to create a subscription with a cert. Run these commands:
Go to the Azure portal, go to the "Settings" page, then "Manage Certificates" and upload `mycert.cer`.
Grab your subscription ID from the portal, then run `machine create` with these details:
Grab your subscription ID from the portal, then run `docker-machine create` with these details:
$ machine create -d azure --azure-subscription-id="SUB_ID" --azure-subscription-cert="mycert.pem"
$ docker-machine create -d azure --azure-subscription-id="SUB_ID" --azure-subscription-cert="mycert.pem"
Options:

4
script/build
View File

@ -7,6 +7,6 @@ else
OS_ARCH_ARG=($1)
fi
rm -f machine_*
rm -f docker-machine*
docker build -t docker-machine .
exec docker run --rm -v `pwd`:/go/src/github.com/docker/machine docker-machine gox "${OS_ARCH_ARG[@]}"
exec docker run --rm -v `pwd`:/go/src/github.com/docker/machine docker-machine gox "${OS_ARCH_ARG[@]}" -output="docker-machine_{{.OS}}-{{.Arch}}"

2
script/release
View File

@ -20,7 +20,7 @@ docker run --rm -e GITHUB_TOKEN docker-machine github-release release \
--name $VERSION \
--description "" \
--pre-release \
for BINARY in machine_*; do
for BINARY in docker-machine_*; do
docker run --rm -e GITHUB_TOKEN -v `pwd`:/go/src/github.com/docker/machine \
docker-machine github-release upload \
--user docker \