Prometheus MasterClass: Infra Monitoring & Alerting

Discover how Prometheus excels at monitoring and alerting by scraping metrics from Linux, Windows, and applications via exporters and client libraries, using a simple http endpoint.

Explore Prometheus metric types, including counter and gauge, and how Prometheus scrapes data from http endpoints into a time series database, using rate calculations, histogram and summary metrics for alerts.

Explore Prometheus metric types, focusing on histogram and summary for quantiles and latency distributions, with summary delivering count and sum, and histogram using buckets.

Discover Prometheus installation options, focusing on precompiled binaries for Linux, with Docker, Kubernetes Helm charts, and configuration management. Set up a cloud Ubuntu server on DigitalOcean for production-like testing.

create a DigitalOcean cloud machine for Prometheus installation using a 100$ new-user credit, choosing Ubuntu 24.4 LTS droplets in Amsterdam with SSH key or password access.

Download the official Prometheus binary tarball from prometheus.io on a unix/linux machine, extract it, rename the binary, and verify the installed version.

Explore the Prometheus user interface, start the server on port 9090, and navigate alerts, graphs, status, and time-series data to monitor your Prometheus setup.

Explore the Prometheus default configuration in prometheus.yaml, covering global and job-level settings like scrape interval, evaluation interval, and scrape timeout, plus alerting, rule files, and targets such as localhost 9090.

Run Prometheus in a background process with nohup, logging to prometheus.log so it stays up. Access metrics at port 9090 and stop with kill -9.

Learn how Prometheus exporters extend existing systems by translating their metrics into Prometheus format, install and configure the node exporter, and configure Prometheus jobs to scrape data.

Set up node exporter on Linux targets to collect system metrics and feed them to Prometheus via port 9100, then configure a Prometheus scrape job and restart Prometheus.

Install and configure the node exporter on Linux machine, then add a node exporter job to Prometheus.yaml with localhost:9100 as target and reload Prometheus to start scraping metrics like boot_time_seconds.

Install node exporter on a new node, configure Prometheus to scrape it, and verify both targets are up. Automate deployment with Ansible, Puppet, or Chef to scale node exporters.

Explore the WMI exporter for Windows, a Prometheus exporter to fetch OS data from Windows machines, with guidance on downloading the exe, installing it, and scraping metrics.

Learn how to monitor a MySQL database with Prometheus by installing and configuring the MySQL server exporter, scraping database metrics, and updating Prometheus with a new job and target.

Learn to install and configure the MySQL exporter to scrape data for Prometheus, including downloading, extracting, creating a replication-enabled exporter user, and setting credentials via env vars or CNF file.

Learn how to reload Prometheus configuration on the fly without restarting, by enabling the web life cycle API and issuing a curl post to /reload.

Watch this demo as we install the MySQL exporter on a Prometheus-based setup, including downloading, extracting, moving to /usr/local/bin, creating a MySQL exporter user, and configuring system service for Prometheus.

Configure the MySQL exporter as a system service and connect it to Prometheus. Add a MySQL exporter job in Prometheus, then reload config and verify the target on port 9104.

Learn how the black box exporter enables Prometheus to monitor network endpoints by probing HTTP, HTTPS, DNS, and ICMP using modular configurations to measure uptime, latency, and health.

Download and configure the black box exporter for Prometheus, extract the tar, run the exporter in the background, and verify metrics at the /metrics endpoint.

Learn how the Prometheus MasterClass black box exporter's HTTP module probes a target with a module, revealing DNS lookup time and probe success, plus debugging tips.

Learn to run http probes over IPv4 by creating a module in the black box exporter, updating the YAML, and reloading Prometheus to view status codes, DNS lookups, and redirects.

Explore the http probe in the black box exporter, validate page content with regex, monitor ssl expiry timestamps, and configure targets like facebook.com to generate actionable Prometheus metrics.

Learn the tcp probe module in Prometheus' black box exporter: it validates a tcp connection and closes on success, without SSL verification, with similar behavior to http probes.

Define a dns_sample module in the black box exporter, configure tcp and ipv4, query google.com at 8.8.8.8, reload, and verify probe results and debug data.

Configure Prometheus to scrape targets via the black box exporter by updating prometheus.yaml with a black box job, using /probe and module HTTP_IPv4, and learn relabeling.

Learn how relabeling in Prometheus enables scraping data from the Prometheus IO black box exporter by configuring source and target labels, replacements, and updating targets via service discovery.

Learn how to access Prometheus installed on a Kubernetes cluster by port forwarding, exposing via node port or load balancer, and retrieving the Prometheus server URL.

Explore Prometheus metrics for Kubernetes, including native metrics and pod, service, and node information. Learn how to use Promql later and visualize data with Grafana.

Discover how to instrument your application with Prometheus client libraries, and understand the four core metric types—counter, gauge, histogram, and summary—and how they report to Prometheus.

Set up a basic Python 3 http server and instrument it with the Prometheus client library to enable metrics collection on port 5000.

Install the Prometheus python client and instrument your Python app by starting an http server to expose metrics on a chosen port, verifying local exposure on ports 5000 and 5001.

Configure Prometheus monitoring by running the Python app on the Prometheus server and exposing metrics. Add the app as a target in prometheus.yaml, restart Prometheus, and verify metrics.

Expose the counter metric in your custom application and surface app request count on Prometheus, enabling tracking of total HTTP request count and the time of the last request creation.

Learn how to attach labels to metrics in a Prometheus instrumented app, enabling granular endpoint tracking and per-URI request counts through labeled counter metrics.

Expose gauge metrics in Prometheus to monitor live in-progress requests and the last served time. Define a gauge metric named 'request in progress' and use increment, decrement, and set.

Expose and monitor request latency using the Prometheus summary metric by implementing a summary in code, measuring start and end times, and observing latency for Prometheus.

Expose histogram metrics in Prometheus and compare them with summary metrics using decorators to measure request latency. Understand histogram buckets, latency data, and when to customize buckets for granular insights.

Set up a Linux machine on Digital Ocean, install the Docker engine on Ubuntu 20.04, and verify the Docker setup to run a Python Flask web app for Prometheus monitoring.

Learn to instrument a Docker application using Python and Flask, add a Prometheus client counter metric, expose a metrics endpoint, and build a Docker image for monitoring.

build a docker image and run a container for a python web app, correctly name the dockerfile and expose port 5001; access metrics at /metrics.

Configure Prometheus to monitor the docker app by adding a custom docker app job and metrics path /metrics. Generate traffic with a python flask app and curl to increase app_request_counter_total.

Explore instrumenting a Go application with a gorilla mux http server, handling /user routes, go mod init, and running on port 8000 for real-time name echoes.

Expose a counter metric in a Go app using Prometheus client libraries, expose the /metrics endpoint, and increment the counter to track http requests.

Expose gauge metrics in a Go app by swapping to a gauge, tracking in-progress requests with increment and decrement at start and end, and validating with a delay for Prometheus.

Learn to expose a summary metric in a Go application by replacing gauge with a summary vector, capturing per-path latency and counts, and exporting metrics to Prometheus.

Instrument a Go app with a histogram metric using Prometheus metrics, replacing the summary and updating the path to measure per request latency across routes.