group Stanza

The group stanza defines a series of tasks that should be co-located on the same Nomad client. Any task within a group will be placed on the same client.

job "docs" {
  group "example" {
    # ...
  }
}

group Parameters

• constraint (Constraint: nil) - This can be provided multiple times to define additional constraints.

• affinity (Affinity: nil) - This can be provided multiple times to define preferred placement criteria.

• spread (Spread: nil) - This can be provided multiple times to define criteria for spreading allocations across a node attribute or metadata. See the Nomad spread reference for more details.

• count (int) - Specifies the number of instances that should be running under for this group. This value must be non-negative. This defaults to the min value specified in the scaling block, if present; otherwise, this defaults to 1.

• ephemeral_disk (EphemeralDisk: nil) - Specifies the ephemeral disk requirements of the group. Ephemeral disks can be marked as sticky and support live data migrations.

• meta (Meta: nil) - Specifies a key-value map that annotates with user-defined metadata.

• migrate (Migrate: nil) - Specifies the group strategy for migrating off of draining nodes. Only service jobs with a count greater than 1 support migrate stanzas.

• network (Network: <optional>) - Specifies the network requirements and configuration, including static and dynamic port allocations, for the group.

• reschedule (Reschedule: nil) - Allows to specify a rescheduling strategy. Nomad will then attempt to schedule the task on another node if any of the group allocation statuses become "failed".

• restart (Restart: nil) - Specifies the restart policy for all tasks in this group. If omitted, a default policy exists for each job type, which can be found in the restart stanza documentation.

• service (Service: nil) - Specifies integrations with Consul for service discovery. Nomad automatically registers each service when an allocation is started and de-registers them when the allocation is destroyed.

• shutdown_delay (string: "0s") - Specifies the duration to wait when stopping a group's tasks. The delay occurs between Consul deregistration and sending each task a shutdown signal. Ideally, services would fail healthchecks once they receive a shutdown signal. Alternatively shutdown_delay may be set to give in-flight requests time to complete before shutting down. A group level shutdown_delay will run regardless if there are any defined group services. In addition, tasks may have their own shutdown_delay which waits between deregistering task services and stopping the task.

• stop_after_client_disconnect (string: "") - Specifies a duration after which a Nomad client that cannot communicate with the servers will stop allocations based on this task group. By default, a client will not stop an allocation until explicitly told to by a server. A client that fails to heartbeat to a server within the heartbeat_grace window and any allocations running on it will be marked "lost" and Nomad will schedule replacement allocations. However, these replaced allocations will continue to run on the non-responsive client; an operator may desire that these replaced allocations are also stopped in this case — for example, allocations requiring exclusive access to an external resource. When specified, the Nomad client will stop them after this duration. The Nomad client process must be running for this to occur.

• task (Task: <required>) - Specifies one or more tasks to run within this group. This can be specified multiple times, to add a task as part of the group.

• vault (Vault: nil) - Specifies the set of Vault policies required by all tasks in this group. Overrides a vault block set at the job level.

• volume (Volume: nil) - Specifies the volumes that are required by tasks within the group.

group Examples

The following examples only show the group stanzas. Remember that the group stanza is only valid in the placements listed above.

Specifying Count

This example specifies that 5 instances of the tasks within this group should be running:

group "example" {
  count = 5
}

Tasks with Constraint

This example shows two abbreviated tasks with a constraint on the group. This will restrict the tasks to 64-bit operating systems.

group "example" {
  constraint {
    attribute = "${attr.cpu.arch}"
    value     = "amd64"
  }

  task "cache" {
    # ...
  }

  task "server" {
    # ...
  }
}

Metadata

This example show arbitrary user-defined metadata on the group:

group "example" {
  meta {
    my-key = "my-value"
  }
}

Network

This example shows network constraints as specified in the network stanza which uses the bridge networking mode, dynamically allocates two ports, and statically allocates one port:

group "example" {
  network {
    mode = "bridge"
    port "http" {}
    port "https" {}
    port "lb" {
      static = "8889"
    }
  }
}

Service Discovery

This example creates a service in Consul. To read more about service discovery in Nomad, please see the Nomad service discovery documentation.

group "example" {
  network {
    port "api" {}
  }

  service {
    name = "example"
    port = "api"
    tags = ["default"]

    check {
      type     = "tcp"
      interval = "10s"
      timeout  = "2s"
    }
  }

  task "api" { ... }
}

Stop After Client Disconnect

This example shows how stop_after_client_disconnect interacts with other stanzas. For the first group, after the default 10 second heartbeat_grace window expires and 90 more seconds passes, the server will reschedule the allocation. The client will wait 90 seconds before sending a stop signal (SIGTERM) to the first-task task. After 15 more seconds because of the task's kill_timeout, the client will send SIGKILL. The second group does not have stop_after_client_disconnect, so the server will reschedule the allocation after the 10 second heartbeat_grace expires. It will not be stopped on the client, regardless of how long the client is out of touch.

Note that if the server's clocks are not closely synchronized with each other, the server may reschedule the group before the client has stopped the allocation. Operators should ensure that clock drift between servers is as small as possible.

Note also that a group using this feature will be stopped on the client if the Nomad server cluster fails, since the client will be unable to contact any server in that case. Groups opting in to this feature are therefore exposed to an additional runtime dependency and potential point of failure.

group "first" {
  stop_after_client_disconnect = "90s"

  task "first-task" {
    kill_timeout = "15s"
  }
}

group "second" {

  task "second-task" {
    kill_timeout = "5s"
  }
}