Course Introduction

Welcome to the Prometheus Certified Associate course. Observability is essential in modern cloud-native environments, and Prometheus is the industry standard for metrics-based monitoring and alerting. Organizations such as Google, Red Hat, and GitLab rely on Prometheus to power their monitoring stacks, creating strong demand for Prometheus expertise. Whether you run Kubernetes, operate microservices, or design alerting workflows, this course will prepare you for both certification and production use. I’m Sanjeev, your instructor for this course. I’ll guide you through Prometheus fundamentals, instrumentation, querying, alerting, and scaling with hands-on labs and real-world examples. What makes this course different

Practical-first: each topic includes hands-on labs, CLI challenges, and real-world examples so you learn by doing.
Certification-focused: content maps to the Prometheus Certified Associate objectives.
Production-ready: examples and patterns you can apply in real environments.

Course roadmap

Observability fundamentals: SLOs, SLIs, SLAs and why they matter
Prometheus fundamentals and installation options
Metrics exposition and label design
PromQL (query language) and advanced query techniques
Visualization and dashboarding
Application instrumentation best practices
Service discovery and relabeling
Short-lived job monitoring with Pushgateway
Alerting with Alertmanager
Kubernetes monitoring and Prometheus on clusters
Scaling and long-term storage strategies

Below is a compact curriculum table for quick reference.

Module	Key topics	Example / Notes
Observability	SLI / SLO / SLA fundamentals	Why user-centric metrics matter
Prometheus fundamentals	Architecture, installation, systemd, Docker	`node_exporter` systemd unit example below
Metrics & labels	Exposition format, counters, gauges, histograms	Inspect metrics with /metrics endpoints
PromQL	Selectors, aggregation, vector matching, subqueries	See PromQL docs: https://prometheus.io/docs/prometheus/latest/querying/basics/
Visualization	Expression browser, console templates, dashboards	Grafana & console templates
Instrumentation	Client libraries, best practices	Label cardinality, buckets for histograms
Service discovery	Static, file, Kubernetes, AWS EC2, relabeling	Examples included below
Pushgateway	Short-lived jobs and push patterns	curl example included below
Alerting	Alert rules, Alertmanager routing, silences	Templates and notification examples
Kubernetes	Helm, scraping dynamic workloads	PrometheusRule example included below
Scaling & storage	Federation, remote_write, long-term stores	Strategies for retention and compliance

Observability foundations: SLO, SLI, SLA This section explains why not all internal metrics equal user experience. We’ll define SLIs (what you measure), SLOs (the target objective), and SLAs (contractual commitments) and show how to derive meaningful alerts from user-impacting signals.

A presentation slide titled "Service Level Indicator" explaining that not all metrics reflect user experience, with an illustration of a user saying "Everything looks good to me" and a server labeled "Experiencing High CPU." A small circular video thumbnail of the instructor appears in the bottom-right.

Prometheus fundamentals and installation You’ll learn Prometheus architecture and multiple installation options (system packages, systemd units, Docker containers). Example: a common systemd unit to run node_exporter:

# /etc/systemd/system/node_exporter.service
[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Configuring Prometheus also includes secure endpoints, TLS/ authentication options, and dynamic configuration reloads. Metrics and exposition format Learn how Prometheus exposes and formats metrics so you can design labels and choose correct metric types:

metric_name{label_1="value_1",label_N="value_N"} metric_value
# Example:
node_cpu_seconds_total{cpu="0",mode="idle"} 258277.86

PromQL — querying Prometheus PromQL is the core skill for extracting operational insights. This course covers:

Instant vs range vectors
Selectors and matchers
Aggregations and operators
Vector matching and joins
Subqueries for complex analysis

Reference: https://prometheus.io/docs/prometheus/latest/querying/basics/

A presentation slide titled "PromQL Data Types" that lists string and scalar types (with examples highlighted). A small circular video of the instructor appears in the bottom-right corner.

Visualization and dashboards You will practice building dashboards using:

Prometheus expression browser for quick checks
Console templates for text-based dashboards
Grafana for rich visualizations and alert panels

Application instrumentation We cover client libraries and how to expose metrics from applications. Example: a minimal Flask app exposing an HTTP endpoint (you’ll learn how to add instrumentation to this):

from flask import Flask, jsonify

app = Flask(__name__)

@app.get("/cars")
def get_cars():
    return jsonify(["toyota", "honda", "mazda", "lexus"])

if __name__ == "__main__":
    app.run(port=5001)

Service discovery and static targets Prometheus supports static and dynamic discovery methods (Kubernetes, cloud providers, file-based, DNS). Simple static scrape example:

scrape_configs:
  - job_name: "web"
    static_configs:
      - targets: ["localhost:9090"]
  - job_name: "node"
    static_configs:
      - targets: ["192.168.1.168:9100"]
  - job_name: "docker"
    static_configs:
      - targets: ["localhost:9323"]

Other topics include file-based discovery, AWS EC2 discovery, relabeling rules, and managing dynamic configurations.

Pushgateway for short-lived jobs Monitor batch and short-lived jobs using Pushgateway. You’ll learn how to deploy it, push metrics from jobs, and integrate metrics with Prometheus. Example curl push:

# Push a metric to the Pushgateway with a job label
echo "example_metric 4421" | curl --data-binary @- http://pushgateway.example.org:9091/metrics/job/db_backup

Alerting and Alertmanager Design actionable alerts and configure Alertmanager for routing, silences, and notification integrations. You will author alerting rules and learn templating for notifications.

A presentation slide explaining that Prometheus only triggers alerts and that Alertmanager handles notifications, shown with a simple diagram. A presenter’s video inset appears in the bottom-right corner.

Kubernetes monitoring This section covers deploying Prometheus in Kubernetes (Helm, operators), scraping dynamic workloads, and writing alert rules for cluster health. Example PrometheusRule resource:

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  labels:
    release: prometheus
  name: api-rules
spec:
  groups:
    - name: api
      rules:
        - alert: down
          expr: up == 0
          for: 0m
          labels:
            severity: critical
          annotations:
            summary: `{{ $labels.instance }}`

Note: The annotation uses a templated expression; it is shown above inside backticks to avoid MDX/templating evaluation issues. Scaling and long-term storage Learn strategies for scaling Prometheus in large environments:

Federation and sharding patterns
remote_write to long-term storage (TSDB, Cortex, Thanos)
Retention strategies for compliance and historical analysis

Hands-on labs accompany every topic so you can practice the concepts and build confidence with real-world scenarios.

Community and next steps At KodeKloud we believe collaborative learning accelerates mastery. Join our forums to connect with peers, ask questions, and share progress. Use the provided labs and exercises to prepare for certification and production deployments. Links and references

Prometheus documentation — https://prometheus.io/docs/
PromQL basics — https://prometheus.io/docs/prometheus/latest/querying/basics/
node_exporter repository — https://github.com/prometheus/node_exporter
Pushgateway docs — https://prometheus.io/docs/practices/pushing/
Alertmanager docs — https://prometheus.io/docs/alerting/latest/alertmanager/
Helm — https://helm.sh/

Good luck, and let’s get started building reliable, observable systems with Prometheus.

Introduction

Observability Fundamentals

Prometheus Fundamentals

PromQL

Dashboarding & Visualization

Application Instrumentation

Service Discovery

Push Gateway

Alerting

Monitoring Kubernetes

Conclusion

Scaling & Long Term Storage

Course Introduction

Watch Video