gitopsorg/docker-devops-http-monitor repository overview

Gatus is a health dashboard that gives you the ability to monitor your services using HTTP, ICMP, TCP, and even DNS queries as well as evaluate the result of said queries by using a list of conditions on values like the status code, the response time, the certificate expiration, the body and many others. The icing on top is that each of these health checks can be paired with alerting via Slack, PagerDuty, Discord and even Twilio.

I personally deploy it in my Kubernetes cluster and let it monitor the status of my core applications: https://status.twinnation.org/⁠

docker run -p 8080:8080 --name gatus twinproduction/gatus

⁠Table of Contents

• Why Gatus?⁠
• Features⁠
• Usage⁠
• Configuration⁠
  • Conditions⁠
    • Placeholders⁠
    • Functions⁠
  • Alerting⁠
    • Configuring Slack alerts⁠
    • Configuring Discord alerts⁠
    • Configuring PagerDuty alerts⁠
    • Configuring Twilio alerts⁠
    • Configuring Mattermost alerts⁠
    • Configuring Messagebird alerts⁠
    • Configuring Telegram alerts⁠
    • Configuring custom alerts⁠
  • Kubernetes (ALPHA)⁠
    • Auto Discovery⁠
• Deployment⁠
  • Docker⁠
  • Helm Chart⁠
• Running the tests⁠
• Using in Production⁠
• FAQ⁠
  • Sending a GraphQL request⁠
  • Recommended interval⁠
  • Default timeouts⁠
  • Monitoring a TCP service⁠
  • Monitoring a service using ICMP⁠
  • Monitoring a service using DNS queries⁠
  • Monitoring a service using STARTTLS⁠
  • Basic authentication⁠
  • disable-monitoring-lock⁠
  • Reloading configuration on the fly⁠
  • Service groups⁠
  • Exposing Gatus on a custom port⁠
  • Uptime Badges (ALPHA)⁠
  • API⁠

⁠Why Gatus?

Before getting into the specifics, I want to address the most common question:

Neither of these can tell you that there’s a problem if there are no clients actively calling the endpoint. In other words, it's because monitoring metrics mostly rely on existing traffic, which effectively means that unless your clients are already experiencing a problem, you won't be notified.

Gatus, on the other hand, allows you to configure health checks for each of your features, which in turn allows it to monitor these features and potentially alert you before any clients are impacted.

A sign you may want to look into Gatus is by simply asking yourself whether you'd receive an alert if your load balancer was to go down right now. Will any of your existing alerts by triggered? Your metrics won’t report an increase in errors if there’s no traffic that makes it to your applications. This puts you in a situation where your clients are the ones that will notify you about the degradation of your services rather than you reassuring them that you're working on fixing the issue before they even know about it.

⁠Features

The main features of Gatus are:

• Highly flexible health check conditions: While checking the response status may be enough for some use cases, Gatus goes much further and allows you to add conditions on the response time, the response body and even the IP address.
• Ability to use Gatus for user acceptance tests: Thanks to the point above, you can leverage this application to create automated user acceptance tests.
• Very easy to configure: Not only is the configuration designed to be as readable as possible, it's also extremely easy to add a new service or a new endpoint to monitor.
• Alerting: While having a pretty visual dashboard is useful to keep track of the state of your application(s), you probably don't want to stare at it all day. Thus, notifications via Slack, Mattermost, Messagebird, PagerDuty and Twilio are supported out of the box with the ability to configure a custom alerting provider for any needs you might have, whether it be a different provider or a custom application that manages automated rollbacks.
• Metrics
• Low resource consumption: As with most Go applications, the resource footprint that this application requires is negligibly small.
• GitHub uptime badges:

⁠Usage

By default, the configuration file is expected to be at config/config.yaml.

You can specify a custom path by setting the GATUS_CONFIG_FILE environment variable.

Here's a simple example:

metrics: true         # Whether to expose metrics at /metrics
services:
  - name: twinnation  # Name of your service, can be anything
    url: "https://twinnation.org/health"
    interval: 30s     # Duration to wait between every status check (default: 60s)
    conditions:
      - "[STATUS] == 200"         # Status must be 200
      - "[BODY].status == UP"     # The json path "$.status" must be equal to UP
      - "[RESPONSE_TIME] < 300"   # Response time must be under 300ms
  - name: example
    url: "https://example.org/"
    interval: 5m
    conditions:
      - "[STATUS] == 200"

This example would look like this:

Note that you can also use environment variables in the configuration file (e.g. $DOMAIN, ${DOMAIN})

If you want to test it locally, see Docker⁠.

⁠Configuration

• For Kubernetes configuration, see Kubernetes⁠.
• For alerting configuration, see Alerting⁠.

⁠Conditions

Here are some examples of conditions you can use:

⁠Placeholders

⁠Functions

NOTE: Use pat only when you need to. [STATUS] == pat(2*) is a lot more expensive than [STATUS] < 300.

⁠Alerting

Gatus supports multiple alerting providers, such as Slack and PagerDuty, and supports different alerts for each individual services with configurable descriptions and thresholds.

Note that if an alerting provider is not configured properly, all alerts configured with the provider's type will be ignored.

⁠Configuring Slack alerts

alerting:
  slack: 
    webhook-url: "https://hooks.slack.com/services/**********/**********/**********"

services:
  - name: twinnation
    url: "https://twinnation.org/health"
    interval: 30s
    alerts:
      - type: slack
        enabled: true
        description: "healthcheck failed 3 times in a row"
        send-on-resolved: true
      - type: slack
        enabled: true
        failure-threshold: 5
        description: "healthcheck failed 5 times in a row"
        send-on-resolved: true
    conditions:
      - "[STATUS] == 200"
      - "[BODY].status == UP"
      - "[RESPONSE_TIME] < 300"

Here's an example of what the notifications look like:

⁠Configuring Discord alerts

alerting:
  discord: 
    webhook-url: "https://discord.com/api/webhooks/**********/**********"

services:
  - name: twinnation
    url: "https://twinnation.org/health"
    interval: 30s
    alerts:
      - type: discord
        enabled: true
        description: "healthcheck failed"
        send-on-resolved: true
    conditions:
      - "[STATUS] == 200"
      - "[BODY].status == UP"
      - "[RESPONSE_TIME] < 300"

⁠Configuring PagerDuty alerts

It is highly recommended to set services[].alerts[].send-on-resolved to true for alerts of type pagerduty, because unlike other alerts, the operation resulting from setting said parameter to true will not create another incident, but mark the incident as resolved on PagerDuty instead.

alerting:
  pagerduty: 
    integration-key: "********************************"

services:
  - name: twinnation
    url: "https://twinnation.org/health"
    interval: 30s
    alerts:
      - type: pagerduty
        enabled: true
        failure-threshold: 3