Node definitions

Node definitions create an anonymous scope that can override variables and defaults from top scope.

Although you can use node definitions in conjunction with an ENC, it's simpler to choose one method or the other. If you do use them together, Puppet merges their data as follows:

• Variables from an ENC are set at top scope and can be overridden by variables in a node definition.

• Classes from an ENC are declared at node scope, so they are affected by any variables set in the node definition.

Node definitions look like class definitions. The general form of a node definition is:

• The node keyword.

• The node definition name: a quoted string, a regular expression, or default.

• An opening curly brace.

• Any mixture of class declarations, variables, resource declarations, collectors, conditional statements, chaining relationships, and functions.

• A closing curly brace.

In the following example, only www1.example.com receives the apache and squid classes, and only db1.example.com receives the mysql class:

# <ENVIRONMENTS DIRECTORY>/<ENVIRONMENT>/manifests/site.pp
node 'www1.example.com' {
  include common
  include apache
  include squid
}
node 'db1.example.com' {
  include common
  include mysql
}

A node definition name must be one of the following:

• A quoted string containing only letters, numbers, underscores (_), hyphens (-), and periods (.).

• A regular expression.

• The bare word default. If no other node definition matches a given node, the default node definition will be used for that node.

You can use a comma-separated list of names to match a group of nodes with a single node definition:

node 'www1.example.com', 'www2.example.com', 'www3.example.com' {
  include common
  include apache, squid
}

If you use a regular expression for a node definition name, it also has the potential to match multiple nodes. For example, the following node definition matches www1, www13, and any other node whose name consists of www and one or more digits:

node /^www\d+$/ {
  include common
}

The following example of a regex node definition name matches one.example.com and two.example.com, but no other nodes:

node /^(one|two)\.example\.com$/ {
  include common
}

You can use regex capture variables by enclosing parts of your regex node definition name in parentheses (), and then referencing them in order as $1, $2 and so on, as variables within the body of the node definition. For example:

node /^www(\d+)$/ {
  $wwwnumber = $1  #assigns the value of the (\d+) from a regex match to the variable $wwwnumber
}

A given node gets the contents of only one node definition, even if multiple node definitions could match its name. Puppet does the following checks, in this order, until it finds one that matches:

1. If there is a node definition with the node's exact name, Puppet uses it.

2. If there is a regular expression node definition that matches the node's name, Puppet uses it. If more than one regex node matches, Puppet uses one of them, but we can't predict which. Make your node definition name regexes non-overlapping to avoid this problem.

3. If the node's name looks like a fully qualified domain name (it has multiple period-separated groups of letters, numbers, underscores, and dashes), Puppet chops off the final group and start again at step 1.

   You can turn off this fuzzy name checking by changing the master's strict_hostname_checking configuration setting to true. This causes Puppet to skip this looping step and use only the node’s full name before resorting to default.

4. Puppet uses the default node.

For example, when compiling a catalog for a node with certname www01.example.com, with fuzzy checking, Puppet looks for a node definition with the following name, in this order:

• www01.example.com

• A regex that matches www01.example.com

• www01.example

• A regex that matches www01.example

• www01

• A regex that matches www01

• default

If it doesn't find one, catalog compilation fails. It's a good idea to always have a default node definition.