@@ -1,7 +1,7 @@

 <!--[metadata]>

 +++

-title = "Swarm overview"

-description = "Docker Swarm overview"

+title = "Swarm mode overview"

+description = "Docker Engine swarm mode overview"

 keywords = ["docker, container, cluster, swarm"]

 advisory = "rc"

 [menu.main]

@@ -10,16 +10,16 @@ parent="engine_swarm"

 weight="1"

 +++

 <![end-metadata]-->

-# Docker Swarm overview

+# Swarm mode overview

-To use this version of Swarm, install the Docker Engine `v1.12.0-rc1` or later

-from the [Docker releases GitHub

+To use Docker Engine in swarm mode, install the Docker Engine `v1.12.0-rc1` or

+later from the [Docker releases GitHub

 repository](https://github.com/docker/docker/releases). Alternatively, install

 the latest Docker for Mac or Docker for Windows Beta.

-Docker Engine 1.12 includes Docker Swarm for natively managing a cluster of

-Docker Engines called a Swarm. Use the Docker CLI to create a Swarm, deploy

-application services to the Swarm, and manage the Swarm behavior.

+Docker Engine 1.12 includes swarm mode for natively managing a cluster of

+Docker Engines called a Swarm. Use the Docker CLI to create a swarm, deploy

+application services to a swarm, and manage swarm behavior.

 If you’re using a Docker version prior to `v1.12.0-rc1`, see [Docker

@@ -33,47 +33,52 @@ services. You don't need additional orchestration software to create or manage

 a Swarm.

 * **Decentralized design:** Instead of handling differentiation between node

-roles at deployment time, Swarm handles any specialization at runtime. You can

-deploy both kinds of nodes, managers and workers, using the Docker Engine.

-This means you can build an entire Swarm from a single disk image.

-

-* **Declarative service model:** Swarm uses a declarative syntax to let you

-define the desired state of the various services in your application stack.

-For example, you might describe an application comprised of a web front end

-service with message queueing services and a database backend.

-

-* **Desired state reconciliation:** Swarm constantly monitors the cluster state

-and reconciles any differences between the actual state your expressed desired

-state.

+roles at deployment time, the Docker Engine handles any specialization at

+runtime. You can deploy both kinds of nodes, managers and workers, using the

+Docker Engine. This means you can build an entire Swarm from a single disk

+image.

+

+* **Declarative service model:** Docker Engine uses a declarative approach to

+let you define the desired state of the various services in your application

+stack. For example, you might describe an application comprised of a web front

+end service with message queueing services and a database backend.

+

+* **Scaling:** For each service, you can declare the number of tasks you want to

+run. When you scale up or down, the swarm manager automatically adapts by

+adding or removing tasks to maintain the desired state.

+

+* **Desired state reconciliation:** The swarm manager node constantly monitors

+the cluster state and reconciles any differences between the actual state your

+expressed desired state. For example, if you set up a service to run 10

+replicas of a container, and a worker machine hosting two of those replicas

+crashes, the manager will create two new replicas to replace the ones that

+crashed. The swarm manager assigns the new replicas to workers that are

+running and available.

 * **Multi-host networking:** You can specify an overlay network for your

-application. Swarm automatically assigns addresses to the containers on the

-overlay network when it initializes or updates the application.

+services. The swarm manager automatically assigns addresses to the containers

+on the overlay network when it initializes or updates the application.

-* **Service discovery:** Swarm assigns each service a unique DNS name and load

-balances running containers. Each Swarm has an internal DNS server that can

-query every container in the cluster using DNS.

+* **Service discovery:** Swarm manager nodes assign each service in the swarm a

+unique DNS name and load balances running containers. You can query every

+container running in the swarm through a DNS server embedded in the swarm.

-* **Load balancing:** Using Swarm, you can expose the ports for services to an

-external load balancer. Internally, Swarm lets you specify how to distribute

+* **Load balancing:** You can expose the ports for services to an

+external load balancer. Internally, the swarm lets you specify how to distribute

 service containers between nodes.

-* **Secure by default:** Each node in the Swarm enforces TLS mutual

+* **Secure by default:** Each node in the swarm enforces TLS mutual

 authentication and encryption to secure communications between itself and all

 other nodes. You have the option to use self-signed root certificates or

 certificates from a custom root CA.

-* **Scaling:** For each service, you can declare the number of instances you

-want to run. When you scale up or down, Swarm automatically adapts by adding

-or removing instances of the service to maintain the desired state.

-

 * **Rolling updates:** At rollout time you can apply service updates to nodes

-incrementally. Swarm lets you control the delay between service deployment to

-different sets of nodes. If anything goes wrong, you can roll-back an instance

-of a service.

+incrementally. The swarm manager lets you control the delay between service

+deployment to different sets of nodes. If anything goes wrong, you can

+roll-back a task to a previous version of the service.

 ## What's next?

-* Learn Swarm [key concepts](key-concepts.md).

-* Get started with the [Swarm tutorial](swarm-tutorial/index.md).

+* Learn swarm mode [key concepts](key-concepts.md).

+* Get started with the [swarm mode tutorial](swarm-tutorial/index.md).

 <p style="margin-bottom:300px">&nbsp;</p>

@@ -1,86 +1,93 @@

 <!--[metadata]>

 +++

-title = "Swarm key concepts"

-description = "Introducing key concepts for Docker Swarm"

-keywords = ["docker, container, cluster, swarm"]

+title = "Swarm mode key concepts"

+description = "Introducing key concepts for Docker Engine swarm mode"

+keywords = ["docker, container, cluster, swarm mode"]

 advisory = "rc"

 [menu.main]

-identifier="swarm-concepts"

+identifier="swarm-mode-concepts"

 parent="engine_swarm"

 weight="2"

 +++

 <![end-metadata]-->

-# Docker Swarm key concepts

+# Swarm mode key concepts

-Building upon the core features of Docker Engine, Docker Swarm enables you to

-create a Swarm of Docker Engines and orchestrate services to run in the Swarm.

-This topic describes key concepts to help you begin using Docker Swarm.

+This topic introduces some of the concepts unique to the cluster management and

+orchestration features of Docker Engine 1.12.

 ## Swarm

-**Docker Swarm** is the name for the cluster management and orchestration

-features embedded in the Docker Engine. Engines that are participating in a

-cluster are running in **Swarm mode**.

+The cluster management and orchestration features embedded in the Docker Engine

+are built using **SwarmKit**. Engines participating in a cluster are

+running in **swarm mode**. You enable swarm mode for the Engine by either

+initializing a swarm or joining an existing swarm.

-A **Swarm** is a cluster of Docker Engines where you deploy a set of application

-services. When you deploy an application to a Swarm, you specify the desired

-state of the services, such as which services to run and how many instances of

-those services. The Swarm takes care of all orchestration duties required to

-keep the services running in the desired state.

+A **swarm** is a self-organizing cluster of Docker Engines where you deploy

+[services](#Services-and-tasks). The Docker Engine CLI includes the commands for

+swarm management, such as adding and removing nodes. The CLI also includes the

+commands you need to deploy services to the swarm and manage service

+orchestration.

-## Node

+When you run Docker Engine outside of swarm mode, you execute container

+commands. When you run the Engine in swarm mode, you orchestrate services.

-A **node** is an active instance of the Docker Engine in the Swarm.

+## Node

-When you deploy your application to a Swarm, **manager nodes** accept the

-service definition that describes the Swarm's desired state. Manager nodes also

-perform the orchestration and cluster management functions required to maintain

-the desired state of the Swarm. For example, when a manager node receives notice

-to deploy a web server, it dispatches the service tasks to worker nodes.

+A **node** is an instance of the Docker Engine participating in the swarm.

-By default the Docker Engine starts one manager node for a Swarm, but as you

-scale you can add more managers to make the cluster more fault-tolerant. If you

-require high availability Swarm management, Docker recommends three or five

-Managers in your cluster.

+To deploy your application to a swarm, you submit a service definition to a

+**manager node**. The manager node dispatches units of work called

+[tasks](#Services-and-tasks) to worker nodes.

-Because Swarm manager nodes share data using Raft, there must be an odd number

-of managers. The Swarm cluster can continue functioning in the face of up to

-`N/2` failures where `N` is the number of manager nodes.  More than five

-managers is likely to degrade cluster performance and is not recommended.

+Manager nodes also perform the orchestration and cluster management functions

+required to maintain the desired state of the swarm. Manager nodes elect a single leader to conduct orchestration tasks.

 **Worker nodes** receive and execute tasks dispatched from manager nodes. By

 default manager nodes are also worker nodes, but you can configure managers to

-be manager-only nodes.

+be manager-only nodes. The agent notifies the manager node of the current

+state of its assigned tasks so the manager can maintain the desired state.

 ## Services and tasks

-A **service** is the definition of how to run the various tasks that make up

-your application. For example, you may create a service that deploys a Redis

-image in your Swarm.

-

-A **task** is the atomic scheduling unit of Swarm. For example a task may be to

-schedule a Redis container to run on a worker node.

+A **service** is the definition of the tasks to execute on the worker nodes. It

+is the central structure of the swarm system and the primary root of user

+interaction with the swarm.

+When you create a service, you specify which container image to use and which

+commands to execute inside running containers.

-## Service types

+In the **replicated services** model, the swarm manager distributes a specific

+number of replica tasks among the nodes based upon the scale you set in the

+desired state.

-For **replicated services**, Swarm deploys a specific number of replica tasks

-based upon the scale you set in the desired state.

+For **global services**, the swarm runs one task for the service on every

+available node in the cluster.

-For **global services**, Swarm runs one task for the service on every available

-node in the cluster.

+A **task** carries a Docker container and the commands to run inside the

+container. It is the atomic scheduling unit of swarm. Manager nodes assign tasks

+to worker nodes according to the number of replicas set in the service scale.

+Once a task is assigned to a node, it cannot move to another node. It can only

+run on the assigned node or fail.

 ## Load balancing

-Swarm uses **ingress load balancing** to expose the services you want to make

-available externally to the Swarm. Swarm can automatically assign the service a

-**PublishedPort** or you can configure a PublishedPort for the service in the

-30000-32767 range. External components, such as cloud load balancers, can access

-the service on the PublishedPort of any node in the cluster, even if the node is

-not currently running the service.

+The swarm manager uses **ingress load balancing** to expose the services you

+want to make available externally to the swarm. The swarm manager can

+automatically assign the service a **PublishedPort** or you can configure a

+PublishedPort for the service in the 30000-32767 range.

+

+External components, such as cloud load balancers, can access the service on the

+PublishedPort of any node in the cluster whether or not the node is currently

+running the task for the service.  All nodes in the swarm cluster route ingress

+connections to a running task instance.

+

+Swarm mode has an internal DNS component that automatically assigns each service

+in the swarm DNS entry. The swarm manager uses **internal load balancing**

+distribute requests among services within the cluster based upon the DNS name of

+the service.

-Swarm has an internal DNS component that automatically assigns each service in

-the Swarm DNS entry. Swarm uses **internal load balancing** distribute requests

-among services within the cluster based upon the services' DNS name.

+## What's next?

+* Read the [swarm mode overview](index.md).

+* Get started with the [swarm mode tutorial](swarm-tutorial/index.md).

 <p style="margin-bottom:300px">&nbsp;</p>

@@ -16,6 +16,6 @@ weight = 0

 This section contains the following topics:

-* [Docker Swarm overview](index.md)

-* [Docker Swarm key concepts](key-concepts.md)

-* [Getting Started with Docker Swarm](swarm-tutorial/index.md)

+* [Docker swarm mode overview](index.md)

+* [Docker swarm mode key concepts](key-concepts.md)

+* [Getting Started with Docker swarm mode](swarm-tutorial/index.md)

@@ -1,7 +1,7 @@

 <!--[metadata]>

 +++

-title = "Add nodes to the Swarm"

-description = "Add nodes to the Swarm"

+title = "Add nodes to the swarm"

+description = "Add nodes to the swarm"

 keywords = ["tutorial, cluster management, swarm"]

 advisory = "rc"

 [menu.main]

@@ -11,16 +11,16 @@ weight=13

 +++

 <![end-metadata]-->

-# Add nodes to the Swarm

+# Add nodes to the swarm

-Once you've [created a Swarm](create-swarm.md) with a manager node, you're ready

+Once you've [created a swarm](create-swarm.md) with a manager node, you're ready

 to add worker nodes.

 1. Open a terminal and ssh into the machine where you want to run a worker node.

 This tutorial uses the name `worker1`.

 2. Run the following command to create a worker node joined to

-the existing Swarm:

+the existing swarm:

     ```

     docker swarm join <MANAGER-IP>:<PORT>

@@ -29,7 +29,7 @@ the existing Swarm:

     Replace `<MANAGER-IP>` with the address of the manager node and `<PORT>`

     with the port where the manager listens.

-    In the tutorial, the following command joins `worker1` to the Swarm on `manager1`:

+    In the tutorial, the following command joins `worker1` to the swarm on `manager1`:

     ```

     $ docker swarm join 192.168.99.100:2377

@@ -50,15 +50,13 @@ the existing Swarm.

 the `docker node ls` command to see the worker nodes:

     ```bash

-    $ docker node ls

-

-    ID              NAME      MEMBERSHIP  STATUS  AVAILABILITY  MANAGER STATUS  LEADER

-09fm6su6c24q *  manager1  Accepted    Ready   Active        Reachable       Yes

-32ljq6xijzb9    worker1   Accepted    Ready   Active

-38fsncz6fal9    worker2   Accepted    Ready   Active

+    ID                           NAME      MEMBERSHIP  STATUS  AVAILABILITY  MANAGER STATUS  LEADER

+    03g1y59jwfg7cf99w4lt0f662    worker2   Accepted    Ready   Active

+    9j68exjopxe7wfl6yuxml7a7j    worker1   Accepted    Ready   Active

+    dxn1zf6l61qsb1josjja83ngz *  manager1  Accepted    Ready   Active        Reachable       Yes

     ```

-    The `MANAGER` column identifies the manager nodes in the Swarm. The empty

+    The `MANAGER` column identifies the manager nodes in the swarm. The empty

     status in this column for `worker1` and `worker2` identifies them as worker nodes.

     Swarm management commands like `docker node ls` only work on manager nodes.

@@ -66,7 +64,7 @@ the `docker node ls` command to see the worker nodes:

 ## What's next?

-Now your Swarm consists of a manager and two worker nodes. In the next step of

-the tutorial, you [deploy a service](deploy-service.md) to the Swarm.

+Now your swarm consists of a manager and two worker nodes. In the next step of

+the tutorial, you [deploy a service](deploy-service.md) to the swarm.

 <p style="margin-bottom:300px">&nbsp;</p>

@@ -1,8 +1,8 @@

 <!--[metadata]>

 +++

-title = "Create a Swarm"

-description = "Initialize the Swarm"

-keywords = ["tutorial, cluster management, swarm"]

+title = "Create a swarm"

+description = "Initialize the swarm"

+keywords = ["tutorial, cluster management, swarm mode"]

 advisory = "rc"

 [menu.main]

 identifier="initialize-swarm"

@@ -11,34 +11,34 @@ weight=12

 +++

 <![end-metadata]-->

-# Create a Swarm

+# Create a swarm

 After you complete the [tutorial setup](index.md) steps, you're ready

-to create a Swarm. Make sure the Docker Engine daemon is started on the host

+to create a swarm. Make sure the Docker Engine daemon is started on the host

 machines.

 1. Open a terminal and ssh into the machine where you want to run your manager

 node. For example, the tutorial uses a machine named `manager1`.

-2. Run the following command to create a new Swarm:

+2. Run the following command to create a new swarm:

     ```

     docker swarm init --listen-addr <MANAGER-IP>:<PORT>

     ```

-    In the tutorial, the following command creates a Swarm on the `manager1` machine:

+    In the tutorial, the following command creates a swarm on the `manager1` machine:

     ```

     $ docker swarm init --listen-addr 192.168.99.100:2377

-    Swarm initialized: current node (09fm6su6c24qn) is now a manager.

+    Swarm initialized: current node (dxn1zf6l61qsb1josjja83ngz) is now a manager.

     ```

     The `--listen-addr` flag configures the manager node to listen on port

-    `2377`. The other nodes in the Swarm must be able to access the manager at

+    `2377`. The other nodes in the swarm must be able to access the manager at

     the IP address.

-3. Run `docker info` to view the current state of the Swarm:

+3. Run `docker info` to view the current state of the swarm:

      ```

      $ docker info

@@ -48,11 +48,12 @@ node. For example, the tutorial uses a machine named `manager1`.

       Paused: 0

       Stopped: 2

      ...snip...

-     Swarm:

-      NodeID: 09fm6su6c24qn

-      IsManager: YES

+     Swarm: active

+      NodeID: dxn1zf6l61qsb1josjja83ngz

+      IsManager: Yes

       Managers: 1

       Nodes: 1

+      CACertHash: sha256:b7986d3baeff2f5664dfe350eec32e2383539ec1a802ba541c4eb829056b5f61

      ...snip...

      ```

@@ -61,16 +62,16 @@ node. For example, the tutorial uses a machine named `manager1`.

     ```

     $ docker node ls

-    ID              NAME      MEMBERSHIP  STATUS  AVAILABILITY  MANAGER STATUS  LEADER

-09fm6su6c24q *  manager1  Accepted    Ready   Active        Reachable       Yes

+    ID                           NAME      MEMBERSHIP  STATUS  AVAILABILITY  MANAGER STATUS  LEADER

+    dxn1zf6l61qsb1josjja83ngz *  manager1  Accepted    Ready   Active        Reachable       Yes

     ```

      The `*` next to the node id, indicates that you're currently connected on

      this node.

-     Docker Swarm automatically names the node for the machine host name. The

-     tutorial covers other columns in later steps.

+     Docker Engine swarm mode automatically names the node for the machine host

+     name. The tutorial covers other columns in later steps.

 ## What's next?

@@ -1,7 +1,7 @@

 <!--[metadata]>

 +++

 title = "Delete the service"

-description = "Remove the service on the Swarm"

+description = "Remove the service from the swarm"

 keywords = ["tutorial, cluster management, swarm, service"]

 advisory = "rc"

 [menu.main]

@@ -11,10 +11,10 @@ weight=19

 +++

 <![end-metadata]-->

-# Delete the service running on the Swarm

+# Delete the service running on the swarm

 The remaining steps in the tutorial don't use the `helloworld` service, so now

-you can delete the service from the Swarm.

+you can delete the service from the swarm.

 1. If you haven't already, open a terminal and ssh into the machine where you

 run your manager node. For example, the tutorial uses a machine named

@@ -24,11 +24,12 @@ run your manager node. For example, the tutorial uses a machine named

     ```

     $ docker service rm helloworld

+

     helloworld

     ```

-3. Run `docker service inspect <SERVICE-ID>` to veriy that Swarm removed the

-service. The CLI returns a message that the service is not found:

+3. Run `docker service inspect <SERVICE-ID>` to veriy that the swarm manager

+removed the service. The CLI returns a message that the service is not found:

     ```

     $ docker service inspect helloworld

@@ -1,8 +1,8 @@

 <!--[metadata]>

 +++

 title = "Deploy a service"

-description = "Deploy the application"

-keywords = ["tutorial, cluster management, swarm"]

+description = "Deploy a service to the swarm"

+keywords = ["tutorial, cluster management, swarm mode"]

 advisory = "rc"

 [menu.main]

 identifier="deploy-application"

@@ -11,10 +11,10 @@ weight=16

 +++

 <![end-metadata]-->

-# Deploy a service to the Swarm

+# Deploy a service to the swarm

-After you [create a Swarm](create-swarm.md), you can deploy a service to the

-Swarm. For this tutorial, you also [added worker nodes](add-nodes.md), but that

+After you [create a swarm](create-swarm.md), you can deploy a service to the

+swarm. For this tutorial, you also [added worker nodes](add-nodes.md), but that

 is not a requirement to deploy a service.

 1. Open a terminal and ssh into the machine where you run your manager node. For

@@ -25,7 +25,7 @@ example, the tutorial uses a machine named `manager1`.

     ```bash

     $ docker service create --replicas 1 --name helloworld alpine ping docker.com

-    2zs4helqu64f3k3iuwywbk49w

+    9uk4639qpg7npwf3fn2aasksr

     ```

     * The `docker service create` command creates the service.

@@ -39,12 +39,12 @@ example, the tutorial uses a machine named `manager1`.

     ```

     $ docker service ls

-    ID            NAME        REPLICAS  IMAGE   COMMAND

-    2zs4helqu64f  helloworld  1         alpine  ping docker.com

+    ID            NAME        SCALE  IMAGE   COMMAND

+    9uk4639qpg7n  helloworld  1/1    alpine  ping docker.com

     ```

 ## What's next?

-Now you've deployed a service to the Swarm, you're ready to [inspect the service](inspect-service.md).

+Now you've deployed a service to the swarm, you're ready to [inspect the service](inspect-service.md).

 <p style="margin-bottom:300px">&nbsp;</p>

@@ -3,7 +3,7 @@

 title = "Drain a node"

 description = "Drain nodes on the Swarm"

 keywords = ["tutorial, cluster management, swarm, service, drain"]

-advisory = "rc"

+advisory="rc"

 [menu.main]

 identifier="swarm-tutorial-drain-node"

 parent="swarm-tutorial"

@@ -11,15 +11,15 @@ weight=21

 +++

 <![end-metadata]-->

-# Drain a node on the Swarm

+# Drain a node on the swarm

 In earlier steps of the tutorial, all the nodes have been running with `ACTIVE`

-availability. The Swarm manager can assign tasks to any `ACTIVE` node, so all

-nodes have been available to receive tasks.

+availability. The swarm manager can assign tasks to any `ACTIVE` node, so up to

+now all nodes have been available to receive tasks.

 Sometimes, such as planned maintenance times, you need to set a node to `DRAIN`

-availabilty. `DRAIN` availabilty  prevents a node from receiving new tasks

-from the Swarm manager. It also means the manager stops tasks running on the

+availability. `DRAIN` availability  prevents a node from receiving new tasks

+from the swarm manager. It also means the manager stops tasks running on the

 node and launches replica tasks on a node with `ACTIVE` availability.

 1. If you haven't already, open a terminal and ssh into the machine where you

@@ -28,13 +28,13 @@ run your manager node. For example, the tutorial uses a machine named

 2. Verify that all your nodes are actively available.

-    ```

+    ```bash

     $ docker node ls

-    ID               NAME      MEMBERSHIP  STATUS  AVAILABILITY  MANAGER STATUS  LEADER

-    1x2bldyhie1cj    worker1   Accepted    Ready   Active

-    1y3zuia1z224i    worker2   Accepted    Ready   Active

-    2p5bfd34mx4op *  manager1  Accepted    Ready   Active        Reachable       Yes

+    ID                           NAME      MEMBERSHIP  STATUS  AVAILABILITY     MANAGER STATUS  LEADER

+    1bcef6utixb0l0ca7gxuivsj0    worker2   Accepted    Ready   Active

+    38ciaotwjuritcdtn9npbnkuz    worker1   Accepted    Ready   Active

+    e216jshn25ckzbvmwlnh5jr3g *  manager1  Accepted    Ready   Active        Reachable       Yes

     ```

 2. If you aren't still running the `redis` service from the [rolling

@@ -43,22 +43,22 @@ update](rolling-update.md) tutorial, start it now:

     ```bash

     $ docker service create --replicas 3 --name redis --update-delay 10s --update-parallelism 1 redis:3.0.6

-    69uh57k8o03jtqj9uvmteodbb

+    c5uo6kdmzpon37mgj9mwglcfw

     ```

 3. Run `docker service tasks redis` to see how the Swarm manager assigned the

 tasks to different nodes:

-    ```

+    ```bash

     $ docker service tasks redis

     ID                         NAME     SERVICE  IMAGE        LAST STATE          DESIRED STATE  NODE

-    3wfqsgxecktpwoyj2zjcrcn4r  redis.1  redis    redis:3.0.6  RUNNING 13 minutes  RUNNING        worker2

-    8lcm041z3v80w0gdkczbot0gg  redis.2  redis    redis:3.0.6  RUNNING 13 minutes  RUNNING        worker1

-    d48skceeph9lkz4nbttig1z4a  redis.3  redis    redis:3.0.6  RUNNING 12 minutes  RUNNING        manager1

+    7q92v0nr1hcgts2amcjyqg3pq  redis.1  redis    redis:3.0.6  Running 26 seconds  Running        manager1

+    7h2l8h3q3wqy5f66hlv9ddmi6  redis.2  redis    redis:3.0.6  Running 26 seconds  Running        worker1

+    9bg7cezvedmkgg6c8yzvbhwsd  redis.3  redis    redis:3.0.6  Running 26 seconds  Running        worker2

     ```

-    In this case the Swarm manager distributed one task to each node. You may

+    In this case the swarm manager distributed one task to each node. You may

     see the tasks distributed differently among the nodes in your environment.

 4. Run `docker node update --availability drain <NODE-ID>` to drain a node that

@@ -66,18 +66,20 @@ had a task assigned to it:

     ```bash

     docker node update --availability drain worker1

+

     worker1

     ```

 5. Inspect the node to check its availability:

-    ```

+    ```bash

     $ docker node inspect --pretty worker1

-    ID:			1x2bldyhie1cj

+

+    ID:			38ciaotwjuritcdtn9npbnkuz

     Hostname:		worker1

     Status:

-     State:			READY

-     Availability:		DRAIN

+     State:			Ready

+     Availability:		Drain

     ...snip...

     ```

@@ -86,11 +88,13 @@ had a task assigned to it:

 6. Run `docker service tasks redis` to see how the Swarm manager updated the

 task assignments for the `redis` service:

-    ```

-    ID                         NAME     SERVICE  IMAGE        LAST STATE          DESIRED STATE  NODE

-    3wfqsgxecktpwoyj2zjcrcn4r  redis.1  redis    redis:3.0.6  RUNNING 26 minutes  RUNNING        worker2

-    ah7o4u5upostw3up1ns9vbqtc  redis.2  redis    redis:3.0.6  RUNNING 9 minutes   RUNNING        manager1

-    d48skceeph9lkz4nbttig1z4a  redis.3  redis    redis:3.0.6  RUNNING 26 minutes  RUNNING        manager1

+    ```bash

+    $ docker service tasks redis

+

+    ID                         NAME     SERVICE  IMAGE        LAST STATE              DESIRED STATE  NODE

+    7q92v0nr1hcgts2amcjyqg3pq  redis.1  redis    redis:3.0.6  Running 4 minutes       Running        manager1

+    b4hovzed7id8irg1to42egue8  redis.2  redis    redis:3.0.6  Running About a minute  Running        worker2

+    9bg7cezvedmkgg6c8yzvbhwsd  redis.3  redis    redis:3.0.6  Running 4 minutes       Running        worker2

     ```

     The Swarm manager maintains the desired state by ending the task on a node

@@ -102,18 +106,20 @@ drained node to an active state:

     ```bash

     $ docker node update --availability active worker1

+

     worker1

     ```

 8. Inspect the node to see the updated state:

-   ```

+   ```bash

    $ docker node inspect --pretty worker1

-   ID:			1x2bldyhie1cj

+

+   ID:			38ciaotwjuritcdtn9npbnkuz

    Hostname:		worker1

    Status:

-    State:			READY

-    Availability:		ACTIVE

+    State:			Ready

+    Availability:		Active

   ...snip...

   ```

@@ -1,8 +1,8 @@

 <!--[metadata]>

 +++

 title = "Set up for the tutorial"

-description = "Getting Started tutorial for Docker Swarm"

-keywords = ["tutorial, cluster management, swarm"]

+description = "Getting Started tutorial for Docker Engine swarm mode"

+keywords = ["tutorial, cluster management, swarm mode"]

 advisory = "rc"

 [menu.main]

 identifier="tutorial-setup"

@@ -11,15 +11,18 @@ weight=11

 +++

 <![end-metadata]-->

-# Getting Started with Docker Swarm

+# Getting started with swarm mode

-This tutorial introduces you to the key features of Docker Swarm. It guides you

-through the following activities:

+This tutorial introduces you to the features of Docker Engine Swarm mode. You

+may want to familiarize yourself with the [key concepts](../key-concepts.md)

+before you begin.

-* initializing a cluster of Docker Engines called a Swarm

-* adding nodes to the Swarm

-* deploying application services to the Swarm

-* managing the Swarm once you have everything running

+The tutorial guides you through the following activities:

+

+* initializing a cluster of Docker Engines in swarm mode

+* adding nodes to the swarm

+* deploying application services to the swarm

+* managing the swarm once you have everything running

 This tutorial uses Docker Engine CLI commands entered on the command line of a

 terminal window. You should be able to install Docker on networked machines and

@@ -28,6 +31,7 @@ be comfortable running commands in the shell of your choice.

 If you’re brand new to Docker, see [About Docker Engine](../../index.md).

 ## Set up

+

 To run this tutorial, you need the following:

 * [three networked host machines](#three-networked-host-machines)

@@ -37,7 +41,7 @@ To run this tutorial, you need the following:

 ### Three networked host machines

-The tutorial uses three networked host machines as nodes in the Swarm. These can

+The tutorial uses three networked host machines as nodes in the swarm. These can

 be virtual machines on your PC, in a data center, or on a cloud service

 provider. This tutorial uses the following machine names:

@@ -47,10 +51,13 @@ provider. This tutorial uses the following machine names:

 ###  Docker Engine 1.12 or later

-You must install Docker Engine on each one of the host machines. To use this

-version of Swarm, install the Docker Engine `v1.12.0-rc1` or later from the

-[Docker releases GitHub repository](https://github.com/docker/docker/releases).

-Alternatively, install the latest Docker for Mac or Docker for Windows Beta.

+You must install Docker Engine on each one of the host machines. To use swarm

+mode, install the Docker Engine `v1.12.0-rc1` or later from the [Docker releases

+GitHub repository](https://github.com/docker/docker/releases). Alternatively,

+install the latest Docker for Mac or Docker for Windows Beta.

+

+>**Advisory**: Some multi-node features may not work for Docker for Mac Beta and

+Docker for Windows Beta. We're working on the multi-node features for GA.

 Verify that the Docker Engine daemon is running on each of the machines.

@@ -64,9 +71,9 @@ Verify that the Docker Engine daemon is running on each of the machines.

 ### The IP address of the manager machine

 The IP address must be assigned to an a network interface available to the host

-operating system. All nodes in the Swarm must be able to access the manager at the IP address.

+operating system. All nodes in the swarm must be able to access the manager at the IP address.

->**Tip**: You can run `ifconfig` on Linux or Mac OSX to see a list of the

+>**Tip**: You can run `ifconfig` on Linux or Mac OS X to see a list of the

 available network interfaces.

 The tutorial uses `manager1` : `192.168.99.100`.

@@ -82,6 +89,6 @@ The tutorial uses `manager1` : `192.168.99.100`.

 ## What's next?

-After you have set up your environment, you're ready to [create a Swarm](create-swarm.md).

+After you have set up your environment, you're ready to [create a swarm](create-swarm.md).

 <p style="margin-bottom:300px">&nbsp;</p>

@@ -2,7 +2,7 @@

 +++

 title = "Inspect the service"

 description = "Inspect the application"

-keywords = ["tutorial, cluster management, swarm"]

+keywords = ["tutorial, cluster management, swarm mode"]

 advisory = "rc"

 [menu.main]

 identifier="inspect-application"

@@ -11,10 +11,10 @@ weight=17

 +++

 <![end-metadata]-->

-# Inspect a service on the Swarm

+# Inspect a service on the swarm

-When you have [deployed a service](deploy-service.md) to your Swarm, you can use

-the Docker CLI to see details about the service running in the Swarm.

+When you have [deployed a service](deploy-service.md) to your swarm, you can use

+the Docker CLI to see details about the service running in the swarm.

 1. If you haven't already, open a terminal and ssh into the machine where you

 run your manager node. For example, the tutorial uses a machine named

@@ -28,17 +28,17 @@ about a service in an easily readable format.

     ```

     $ docker service inspect --pretty helloworld

-    ID:		2zs4helqu64f3k3iuwywbk49w

+    ID:		9uk4639qpg7npwf3fn2aasksr

     Name:		helloworld

     Mode:		REPLICATED

-     Scale:	1

+     Replicas:		1

     Placement:

      Strategy:	SPREAD

     UpdateConfig:

      Parallelism:	1

     ContainerSpec:

      Image:		alpine

-     Command:	ping docker.com

+     Args:	ping docker.com

     ```

     >**Tip**: To return the service details in json format, run the same command

@@ -48,36 +48,43 @@ about a service in an easily readable format.

     $ docker service inspect helloworld

     [

     {

-        "ID": "2zs4helqu64f3k3iuwywbk49w",

+        "ID": "9uk4639qpg7npwf3fn2aasksr",

         "Version": {

-            "Index": 16264

+            "Index": 418

         },

-        "CreatedAt": "2016-06-06T17:41:11.509146705Z",

-        "UpdatedAt": "2016-06-06T17:41:11.510426385Z",

+        "CreatedAt": "2016-06-16T21:57:11.622222327Z",

+        "UpdatedAt": "2016-06-16T21:57:11.622222327Z",

         "Spec": {

             "Name": "helloworld",

-            "ContainerSpec": {

-                "Image": "alpine",

-                "Command": [

-                    "ping",

-                    "docker.com"

-                ],

+            "TaskTemplate": {

+                "ContainerSpec": {

+                    "Image": "alpine",

+                    "Args": [

+                        "ping",

+                        "docker.com"

+                    ]

+                },

                 "Resources": {

                     "Limits": {},

                     "Reservations": {}

-                }

+                },

+                "RestartPolicy": {

+                    "Condition": "any",

+                    "MaxAttempts": 0

+                },

+                "Placement": {}

             },

             "Mode": {

                 "Replicated": {

-                    "Instances": 1

+                    "Replicas": 1

                 }

             },

-            "RestartPolicy": {},

-            "Placement": {},

             "UpdateConfig": {

                 "Parallelism": 1

             },

-            "EndpointSpec": {}

+            "EndpointSpec": {

+                "Mode": "vip"

+            }

         },

         "Endpoint": {

             "Spec": {}

@@ -92,20 +99,20 @@ service:

     ```

     $ docker service tasks helloworld

-    ID                         NAME          SERVICE     IMAGE   DESIRED STATE  LAST STATE          NODE

-    1n6wif51j0w840udalgw6hphg  helloworld.1  helloworld  alpine  RUNNING        RUNNING 19 minutes  manager1

+    ID                         NAME          SERVICE     IMAGE   LAST STATE         DESIRED STATE  NODE

+    8p1vev3fq5zm0mi8g0as41w35  helloworld.1  helloworld  alpine  Running 3 minutes  Running        worker2

     ```

     In this case, the one instance of the `helloworld` service is running on the

-    `manager1` node. Manager nodes in a Swarm can execute tasks just like worker

-    nodes.

+    `worker2` node. You may see the service running on your manager node. By

+    default, manager nodes in a Swarm can execute tasks just like worker nodes.

     Swarm also shows you the `DESIRED STATE` and `LAST STATE` of the service

     task so you can see if tasks are running according to the service

     definition.