---
date: 2017-03-14
title: Consul Prometheus and Puppet
category: devops
---

Recently I've been playing around with Prometheus. For now I think it is the best open source solution for monitoring (in the same way that chlamydia is probably the best STD). Previously I was a fan of Sensu, but honestly there are just too many moving parts to go wrong with Sensu, which meant they inevitably did.

So, why do I like Prometheus? Basically, it stays pretty close to the UNIX philosophy of doing one thing and doing it well - basically it is just a time-series database. Alerting is a seperate module for example and graphing is pretty much left to Grafana. Initially I was not taken by it for one simple reason:

- All its configuration is central.

Unlike with Sensu, a node cannot announce itself to the Prometheus server and then be automatically monitored. In this day an age, that sucks. However, while browsing the docs I discovered that it supports [service discovery](https://prometheus.io/blog/2015/06/01/advanced-service-discovery/). 


So the process:

- Use Puppet to configure Prometheus
- Individual nodes announce to Consul what services they have
- Prometheus collects its endpoints from Consul

This looks something like this:

<img src="data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="561px" height="411px" version="1.1"><defs/><g transform="translate(0.5,0.5)"><rect x="0" y="80" width="120" height="100" fill="none" stroke="#000000" pointer-events="none"/><g transform="translate(46.5,87.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="26" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 26px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">stats</div></div></foreignObject><text x="13" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">stats</text></switch></g><rect x="240" y="0" width="120" height="100" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(281.5,7.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="36" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 38px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">puppet</div></div></foreignObject><text x="18" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">puppet</text></switch></g><rect x="440" y="260" width="120" height="100" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(482.5,343.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 34px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node3</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">node3</text></switch></g><rect x="240" y="310" width="120" height="100" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(282.5,393.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 34px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node2</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">node2</text></switch></g><rect x="40" y="260" width="120" height="100" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(82.5,343.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 34px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node1</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">node1</text></switch></g><path d="M 25 180 L 25 220 L 65 220 L 65 260" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 25 180 L 25 220 L 265 220 L 265 310" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 25 180 L 25 220 L 465 220 L 465 260" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 25 180 L 25 220 L 265 220 L 265 100" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="150" width="50" height="30" fill="#dae8fc" stroke="#000000" pointer-events="none"/><g transform="translate(7.5,151.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="26" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 36px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">consul<div>server</div></div></div></foreignObject><text x="17" y="19" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="240" y="70" width="50" height="30" fill="#dae8fc" stroke="#000000" pointer-events="none"/><g transform="translate(247.5,78.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 36px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">consul</div></div></foreignObject><text x="17" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul</text></switch></g><rect x="40" y="260" width="50" height="30" fill="#dae8fc" stroke="#000000" pointer-events="none"/><g transform="translate(47.5,268.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 36px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">consul</div></div></foreignObject><text x="17" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul</text></switch></g><rect x="240" y="310" width="50" height="30" fill="#dae8fc" stroke="#000000" pointer-events="none"/><g transform="translate(247.5,318.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 36px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">consul</div></div></foreignObject><text x="17" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul</text></switch></g><rect x="440" y="260" width="50" height="30" fill="#dae8fc" stroke="#000000" pointer-events="none"/><g transform="translate(447.5,268.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="34" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 36px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">consul</div></div></foreignObject><text x="17" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul</text></switch></g><path d="M 85 150 L 85 130 L 25 130 L 25 143.63" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 25 148.88 L 21.5 141.88 L 25 143.63 L 28.5 141.88 Z" fill="#7ea6e0" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(31.5,114.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="51" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;background-color:#ffffff;">consul sd</div></div></foreignObject><text x="26" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul sd</text></switch></g><path d="M 85 180 Q 85 210 105 210 Q 125 210 125 253.63" fill="none" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 125 258.88 L 121.5 251.88 L 125 253.63 L 128.5 251.88 Z" fill="#f19c99" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 165 Q 325 165 325 303.63" fill="none" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 325 308.88 L 321.5 301.88 L 325 303.63 L 328.5 301.88 Z" fill="#f19c99" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 165 Q 525 165 525 253.63" fill="none" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 525 258.88 L 521.5 251.88 L 525 253.63 L 528.5 251.88 Z" fill="#f19c99" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 165 Q 325 165 325 106.37" fill="none" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><path d="M 325 101.12 L 328.5 108.12 L 325 106.37 L 321.5 108.12 Z" fill="#f19c99" stroke="#f19c99" stroke-miterlimit="10" pointer-events="none"/><rect x="50" y="150" width="70" height="30" fill="#f8cecc" stroke="#000000" pointer-events="none"/><g transform="translate(52.5,158.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="64" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 64px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">prometheus</div></div></foreignObject><text x="32" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">prometheus</text></switch></g><path d="M 125 290 L 125 310 L 65 310 L 65 296.37" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 65 291.12 L 68.5 298.12 L 65 296.37 L 61.5 298.12 Z" fill="#7ea6e0" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(59.5,311.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="76" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;background-color:#ffffff;">consul service</div></div></foreignObject><text x="38" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul service</text></switch></g><rect x="90" y="260" width="70" height="30" fill="#f8cecc" stroke="#000000" pointer-events="none"/><g transform="translate(102.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="44" height="26" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 46px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node<div>exporter</div></div></div></foreignObject><text x="22" y="19" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="290" y="310" width="70" height="30" fill="#f8cecc" stroke="#000000" pointer-events="none"/><g transform="translate(302.5,311.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="44" height="26" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 46px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node<div>exporter</div></div></div></foreignObject><text x="22" y="19" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="490" y="260" width="70" height="30" fill="#f8cecc" stroke="#000000" pointer-events="none"/><g transform="translate(502.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="44" height="26" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 46px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node<div>exporter</div></div></div></foreignObject><text x="22" y="19" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="290" y="70" width="70" height="30" fill="#f8cecc" stroke="#000000" pointer-events="none"/><g transform="translate(302.5,71.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="44" height="26" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; width: 46px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">node<div>exporter</div></div></div></foreignObject><text x="22" y="19" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 325 340 L 325 360 L 265 360 L 265 346.37" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 265 341.12 L 268.5 348.12 L 265 346.37 L 261.5 348.12 Z" fill="#7ea6e0" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(259.5,361.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="76" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;background-color:#ffffff;">consul service</div></div></foreignObject><text x="38" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul service</text></switch></g><path d="M 520 290 L 520 310 L 460 310 L 460 296.37" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 460 291.12 L 463.5 298.12 L 460 296.37 L 456.5 298.12 Z" fill="#7ea6e0" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(454.5,311.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="76" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;background-color:#ffffff;">consul service</div></div></foreignObject><text x="38" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul service</text></switch></g><path d="M 320 70 L 320 50 L 260 50 L 260 63.63" fill="none" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 68.88 L 256.5 61.88 L 260 63.63 L 263.5 61.88 Z" fill="#7ea6e0" stroke="#7ea6e0" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(252.5,34.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="76" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(77, 77, 77); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;background-color:#ffffff;">consul service</div></div></foreignObject><text x="38" y="12" fill="#4D4D4D" text-anchor="middle" font-size="12px" font-family="Helvetica">consul service</text></switch></g></g></svg>" style="max-width:100%;" />

Here is a network of 5 machines:

- Prometheus (also the Consul server
- Puppet
- 3 that will be monitored

This is a very simple consul cluster. Normally one would have at least 3 masters (ideally more) spread accross different datacentres. It works for this demo though.

Right, let's jump straight into the Puppet code. I am using the classic 'Roles and Profiles'  pattern. You can find my control repo [here](https://gogs.chriscowley.me.uk/Puppet/controlrepo). There are a few Puppet modules necessarry, so your `Puppetfile` will contain:

```
forge 'http://forge.puppetlabs.com'

mod 'KyleAnderson/consul', '2.1.0'
mod 'puppet/archive', '1.3.0'
mod 'puppetlabs/stdlib', '4.15.0'
mod 'puppetlabs/firewall', '1.8.2'

mod 'prometheus',
    :git => 'https://github.com/voxpupuli/puppet-prometheus.git'
```

To begin with, lets install [Node Exporter](https://prometheus.io/download/#node_exporter) everywhere. This will collect basic system stats and make them available to Prometheus.

In `common.yaml`:

```
---
prometheus::node_export: 0.13.0
```

and in your `profile::base`:

```
class profile::base {
  include ::prometheus::node_exporter
  firewall {'102 node exporter':
    dport  => 9100,
    proto  => tcp,
    action => accept,
  }
}
```

Consul needs to be everywhere and you need to announce to it that the node exporter is there, so in your base profile:

```
class profile::base {
  include ::consul
  firewall { '103 Consul':
    dport  => [8400, 8500],
    proto  => tcp,
    action => accept,
  }
}
```

And in `common.yaml`:

```
---
consul::version: 0.7.4
consul::config_hash:
  data_dir: '/opt/consul'
  datacenter: 'homelab'
  log_level: 'INFO'
  node_name: "%{::hostname}"
  retry_join: 
    -  192.168.1.89
consul::services:
  node_exporter:
    address: "%{::fqdn}"
    checks:
      - http: http://localhost:9100
        interval: 10s
    port: 9100
    tags:
      - monitoring
```

Obviously modify the retry_join to suite your infrastructure. If you are doing the right thing and have a cluster, just expand the array down.

For the consul master create a profile that contains:

```
profile::consulmaster {
  firewall { '102 consul inbound':
    dport  => [8300, 8301, 8302, 8600],
    proto  => tcp,
    action => accept,
  }
}
```

You need the following in Hiera applied to that node(s):

```
---
consul::version: 0.7.4
consul::config_hash:
  bootstrap_expect: 1
  data_dir: '/opt/consul'
  datacenter: 'homelab'
  log_level: 'INFO'
  server: true
  node_name: "%{::hostname}"
```

Change `bootstrap_expect` to match what you need.

To configure the prometheus server itself create `profile::prometheus`:

```
class profile::prometheus {
  firewall { '100 Prometheus inbound':
    dport  => [9090,9093],
    proto  => tcp,
    action =>  accept,
  }
  
  class { 'prometheus':
    scrape_configs => [
      {
        'job_name'         => 'consul',
        'consul_sd_configs' => [
          {
            'server' => 'localhost:8500',
            'services' => [
              'node_exporter',
            ],
          },
        ],
      },
    ],
  }
}
```

This will create a scrape config that queries consul for all services named 'node_exporter'.

Finally, the hiera for your prometheus node will look like:

```
---
classes:
  - profile::prometheus
prometheus::version: '1.5.0'
```

That is it! 

As an aside, the basic ideas here are based on Gareth Rushgrove's excellent presentation about having 2 different speeds of configuration management. Basically, Puppet is the slow and stable speed then, in parallel, Consul gives another path that is much more reactive.

{% youtube XfSrc_sAm2c %}