179 lines
30 KiB
Markdown
179 lines
30 KiB
Markdown
---
|
|
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 %}
|