Negin.S

Posted on Sep 6

🚀 Mini Monitoring App in Go with Prometheus, Grafana & CI/CD

#cicd #monitoring #sre #devops

In this tutorial, we’ll build a tiny, production-style Go service that you can deploy, observe, and ship via CI/CD.

💡 Why this project?

Real-world skills: containerization, observability, CI/CD, and documentation.
Interview-friendly: shows us understand build → ship → monitor.
Lightweight: a small Go service with /health and /metrics that we can extend later.

🎯 What we’ll build

A Go service exposing:
GET /health : returns {"status":"OK"}
GET /metrics: Prometheus metrics (custom counter & latency histogram)
A Dockerized app pushed to DockerHub
A Prometheus + Grafana stack to scrape & visualize metrics.
A GitHub Actions pipeline to test, build, and publish the image.

⚙️ Prereqs:

Docker & Docker Compose.
GitHub account (for CI/CD).
DockerHub account (to publish the image).
Go 1.24.x

🧪 Run it now

(Replace negin007 with your DockerHub username if you fork this.)

docker pull negin007/mini-monitoring-app:latest
docker run -d -p 8080:8080 negin007/mini-monitoring-app:latest

Test it:

curl http://localhost:8080/health
curl http://localhost:8080/metrics

🧭 Project structure

mini-monitoring-app/
├─ main.go
├─ go.mod
├─ Dockerfile
├─ .dockerignore
├─ docker-compose.yml
├─ prometheus.yml
├─ .github/
│ └─ workflows/ci.yml
└─ README.md

🪜 The Steps

1. Write Go service

Minimal main.go with /health and /metrics.(Full file: main.go)

2. Instrumentation

We expose two custom metrics:

Counter health_requests_total → ever-increasing count of health checks.
Histogram response_latency_seconds → measures latency in buckets.

Why a histogram? Because you can calculate percentiles like P95 using Prometheus:

histogram_quantile(0.95,sum(rate(response_latency_seconds_bucket[1m])) by (le))

-rate(...[1m]) → per-second rate over 1 minute

-sum(... ) by (le) → aggregate all instances by bucket(le = “less or equal”)

-histogram_quantile(0.95, ...) → compute the 95th percentile latency (P95).

3. Dockerize the service

Dockerfile: (Full file: Dockerfile)

Build & run locally:

docker build -t yourname/mini-monitoring-app:local .
docker run -p 8080:8080 yourname/mini-monitoring-app:local

4. Validate endpoints locally:

We should see {"status":"UP"}.

curl http://localhost:8080/health
curl http://localhost:8080/metrics

5. Add Monitoring Stack (Prometheus + Grafana)

prometheus.yml config:

global:
  scrape_interval: 5s  

scrape_configs:
  - job_name: "mini-monitoring-app"
    static_configs:
      - targets: ["app:8080"]

docker-compose.yml spins up app + Prometheus + Grafana.
(Full files: prometheus.yml , docker-compose.yml)

Run all services:

docker-compose up -d : App → http://localhost:8080
Prometheus → http://localhost:9090 (check Status → Targets)
Grafana → http://localhost:3000 (login admin / admin)

6. Build a Grafana dashboard

Two common panel types:

Graph/Time series → trends over time (great for latency/throughput)
Gauge/Stat → current value or single number (great for “count now”)

Example panels:

Stat: health_requests_total (total health checks)
Time series (P95 latency):

histogram_quantile(0.95, sum(rate(response_latency_seconds_bucket[1m])) by (le))

7. CI/CD with GitHub Actions

Workflow .github/workflows/ci.yml:

Runs Go tests
Builds Docker image
Pushes image to DockerHub

Required secrets(Repo → Settings → Secrets → Actions):

DOCKERHUB_USERNAME → your DockerHub username
DOCKERHUB_TOKEN → DockerHub access token (Read/Write)

(Full file:ci.yml)

✅ Conclusion

This tiny monitoring app shows how a real-world service can be built, observed, and shipped with modern practices:

Go for a lightweight service
Prometheus + Grafana for observability
Docker & GitHub Actions for CI/CD automation

👉 Repo: Mini-Monitoring-App

Thank you for reading! 🍀

DEV Community