Manage Hyperping with Terraform: Community Provider by Develeap

If you manage more than a handful of monitors, you have probably wanted to define them in code rather than clicking through a dashboard. Terraform is the standard tool for that in the infrastructure world, and now there is a Terraform provider for Hyperping.

Develeap, a DevOps consultancy, built this provider while managing monitoring for 57 tenants at scale. They needed infrastructure as code for monitors, status pages, and incidents, so they built it, tested it in production, and open-sourced it. The provider is published on the Terraform Registry and currently at version 1.0.8.

Key takeaways

• Define Hyperping monitors, status pages, incidents, healthchecks, and maintenance windows in HCL
• Published on the Terraform Registry, install with terraform init
• Import existing resources from the Hyperping dashboard into Terraform state
• Built on Develeap's hyperping-go client library, with production-grade rate limiting and retry logic
• Part of a broader developer toolkit including a Python SDK and Prometheus exporter

Why monitoring as code matters

Manual monitor configuration works when you have 5 or 10 monitors. It breaks down at 50 or 500. Common problems:

• No audit trail for who changed what and when
• No way to replicate a monitoring setup across staging and production environments
• Drift between what you think is monitored and what actually is
• Onboarding a new service means clicking through forms instead of copying a Terraform module

With the Hyperping Terraform provider, your monitoring configuration lives in version control alongside your infrastructure. Changes go through pull requests. Rollbacks are a terraform apply away.

What the provider covers

The provider maps Hyperping's API into Terraform resources:

Each resource supports the full lifecycle: create, read, update, delete, and import.

Getting started

Add the provider to your Terraform configuration:

terraform {
  required_providers {
    hyperping = {
      source  = "develeap/hyperping"
      version = "~> 1.0"
    }
  }
}

provider "hyperping" {
  api_key = var.hyperping_api_key
}

Then define your monitors:

resource "hyperping_monitor" "api" {
  name                 = "API Health Check"
  url                  = "https://api.example.com/health"
  protocol             = "http"
  check_frequency      = 60
  expected_status_code = "200"
  regions              = ["london", "virginia", "singapore"]
}

resource "hyperping_statuspage" "main" {
  name      = "Service Status"
  subdomain = "status-example"
  theme     = "dark"
}

Run terraform init and terraform apply. Your monitors are now managed as code.

Importing existing monitors

If you already have monitors set up in the Hyperping dashboard, you can bring them under Terraform management:

terraform import hyperping_monitor.api <monitor-id>

Find monitor IDs in the dashboard URL or via the List Monitors API.

Under the hood

The Terraform provider is built on hyperping-go, Develeap's open-source Go client library for the Hyperping API. The same client also powers their Prometheus exporter. This shared foundation means bug fixes and API coverage improvements propagate across all three projects.

The provider handles rate limiting, retries, and error handling at the client level, so you do not have to worry about API throttling during large terraform apply runs.

Links

• Terraform Registry
• GitHub: develeap/terraform-provider-hyperping
• Documentation: Terraform Provider setup
• Full developer toolkit announcement