ROUSSELTM LEARNING
Site map
Topics, courses and articles, all in one place.
Courses
Docker: From Discovery to Expertise
Explore ↗
- Course Overview
- Docker: From Discovery to Expertise
- Virtualization and Containerization
- Docker Building Blocks using Port Activity Terms
- Setting up the test environment
- Docker Engine Installation - Lab with Vagrant and VirtualBox
- Docker Desktop Installation
- CLI Overview - Lab with Vagrant and VirtualBox
- Docker Installation
- The Layer Concept in Docker
- Docker Hub
- Deploying Containers
- Dockerfile
- Dockerfile - Multi-stage builds
- Building an Image and Pushing to Docker Hub - Uptimerobot Exporter
- Best Practices for Building a Dockerfile - .dockerignore - multi-stage
- Creating My First Container
- Container registry: choosing and securing it
- Container Network Communication - inspect - network
- Data Persistence Within a Container
- Security with Docker Security Bench
- Managing Your Own Registry
- Getting Started with Docker Desktop - Docker Scout - Extensions
- Deploying a VMware Harbor Docker Registry - Scan - Trivy - Security
- My First Container Networking and Persistence
- My First Multi-Stage Image
- Introduction
- Should you type 'docker compose' or 'docker-compose'
- Creating a compose.yaml file
- Advanced use of labels - Traefik config - Kubernetes deployment
- My First Docker Compose File
- Introduction
- Deploying a Docker SWARM Cluster and Initial Handling
- Container Eviction - Memory - CPU - QoS Classes
- Configuration as Code - Terraform/OpenTofu - SaltStack - Ansible
- The Pillars of Observability: Logs, Traces, and Metrics
- Prometheus Exporter VM/Container Config - cAdvisor - node-exporter - Ingress
- Logs, Traces, and Metrics with Dynatrace - Docker and Kubernetes
- Project 1
- Docker cheat sheet: essential commands
- Docker best practices
- DCA
Dynatrace: From Discovery to Expertise
Explore ↗
- Training Overview
- Dynatrace: From Discovery to Expertise
- Definitions
- How to follow this course
- Dynatrace Architecture
- 🧠 Dynatrace Davis
- Setting up the test environment
- SaaS vs Managed
- What is the playground?
- Access the playground
- SaaS vs Managed interface
- Cluster / environment organization
- Getting started with the Dynatrace interface
- New page vs classic page
- Dashboard vs Classic Dashboard - Dashboards vs Dashboards classic
- How to see the state of a host, service, etc. at a glance
- All the technologies present on your cluster - Technologies and processes
- Add/remove cluster functions - extensions - extensions manager
- Dynatrace licensing: classic model and DPS
- Track your consumption - Davis Data Units (classic licensing model)
- Licensing and FinOps
- Collection methods - OneAgent - OpenTelemetry - Prometheus exporter ...
- OneAgent
- Installing the OneAgent - Hostgroup - tags - owners - properties
- Reconfiguring the OneAgent with the oneagentctl CLI or via the deployment status
- OneAgent in the Docker / Kubernetes world
- OneAgent health
- How to see the state of a host, service, etc. at a glance
- Correlation between the pillars of observability - logs, metrics and traces
- Lab - Collection
- ActiveGate and network zones
- Dynatrace Operator on Kubernetes
- OpenTelemetry and Dynatrace
- Understanding and using the different Dynatrace APIs
- Introducing Monaco
- Creating and managing tokens: example of Monaco tokens
- Creating an OAuth client if you have a SaaS subscription
- [CI/CD] Building your own Docker image for Monaco - GitHub Action
- Introducing Dynatrace Simply Smarter
- Export, create, delete... your first configuration with Monaco
- [CI/CD] Pipeline to automatically run Monaco - GitLab CI/CD
- Selecting elements in the cluster - filters - Entity selector
- Working with management zones - settings
- Lab - Creating and Using Entity Selectors
- Segments and the new platform
- Introduction
- Automatically create problems in your solutions - Issue tracking
- Find the information entered in your Kubernetes deployment - release
- Event management - API - events - release monitoring - CI/CD
- Monitoring real users without installing agents
- How to find, edit and delete a created application
- Monitoring real users of a PaaS application
- Monitoring real users via a browser extension
- How to check that instrumentation is properly in place
- Introduction to synthetic monitoring
- Create an HTTP monitor
- Edit an HTTP monitor
- Monitoring via a browser (Browser monitor)
- Monitoring via a browser (Browser monitor) - using JavaScript
- Monitoring via a browser (Browser monitor) - CSS selector
- Adding authentication to your scenarios - credential vault
- Lab - Synthetic Monitoring
- Frontend application
- Apdex (Application Performance Index) vs Core Web Vitals
- User session
- Flow between services - service flow
- Distributed traces
- Analyzing callers - Application Databases - backtrace
- Multidimensional analysis
- Actions and events - User session query language - USQL
- Build your first USQL query - SQL-like - USQL
- Understand and optimize your users' journeys - funnel - USQL
- Lab - Visualize and Analyze Your User Experience (DEM)
- Business observability
- Introduction
- Create your first graph - Data explorer
- Create your first dashboard - dashboards classic
- The Problems application
- Auto-remediation: self healing
- The content of a problem page
- Install the mobile app to receive alerts - install mobile
- Advanced Davis AI
- Advanced alerting
- Workflows and AutomationEngine
- Owners / ownerships
- Reconfiguring a OneAgent to define the machine's owner
- Maintenance Windows
- Renaming resources - host naming - process group naming - request naming
- Key requests
- Applying tags - Automatically applied tags - Manually applied tags
- Introducing SLO - SLI - SLA - SRE
- SLO management
- Smartscape topology
- Sub-applications
- Analyze your visitors' sessions as if you were there - waterfall analysis
- Display all the containers present on the cluster - containers
- View and analyze a Kubernetes cluster - kubernetes
- Browse the data collected in a subscription - Lambda Function - AWS
- Monitor network usage - Host networking
- Cloud and infrastructure
- AppEngine and custom apps
- Introducing Grail
- Browse and search your observability data - Logs and events - Grail
- Build your first DQL queries - Grail
- Enrich your DQL queries and add them to a notebook - Notebooks - Grail
- Enrich your DQL queries and add them to a dashboard - Dashboards - Grail
- Best practices for building performant DQL queries - Grail
- Lab - Advanced Analysis with Grail, DQL and Entity Selectors
- Advanced logs and OpenPipeline
- Advanced Grail and DQL
- Managing permissions: IAM, groups and policies
- Security and governance
- Data retention
- Project 1
- Project 2: RUM
- Applications to master for your analysis
- Dynatrace best practices
- Associate
- Advanced Observability Specialist
- DEM and Business Analytics Specialist
- Implementation Professional
- Administration Professional
Vagrant: From Discovery to Expertise
Explore ↗
- Course overview
- Vagrant: From Discovery to Expertise
- Installing Vagrant
- The providers: VirtualBox - Docker - VMware - Hyper-V ...
- Vagrant Cloud: public and private Boxes
- Managing boxes: vagrant box
- Building images: HashiCorp Packer
- Building images: exporting a machine - not recommended
- Initialization: vagrant init
- Building and stopping your first machine: vagrant up / down
- Defining the provider and machine specs: CPU - RAM - ...
- Naming - vagrant - VirtualBox - hostname
- Connecting to the created machine - vagrant ssh - rdp
- File synchronization
- Networking: port forward - private network - public network
- Configuring the machine: File provisioner
- Configuring the machine: Shell provisioner
- Configuring the machine: Ansible - Salt - Chef - Puppet provisioner
- Configuring the machine: Docker provisioner
- Lab: My first virtual machine with Vagrant
- Why multi-machine
- Vagrantfile: variables, conditions and loops to deploy multiple machines
- Deploying a ready-to-use Docker Swarm cluster (already joined)
- Lab: A multi-machine environment (web + database)
- Overview: providers and provisioners use cases
- Sharing a test environment: ngrok and the vagrant-share plugin
- Lab: Ansible provisioning and snapshots
- Vagrant best practices
Traefik: From Discovery to Expertise
Explore ↗
- Vue d'ensemble de Traefik
- Traefik: From Discovery to Expertise
- Load balancer - proxy - reverse proxy
- Traefik
- How to follow this course
- Promo code for our other courses
- Setting up the test environment
- Installation
- Stand-alone - classic
- Docker
- Kubernetes - Helm
- Watch out for bottlenecks - HA - SPOF - Traefik Enterprise - Traefik Hub
- Configuration methods - File (YAML) - File (TOML) - CLI - ...
- Static vs dynamic configuration
- Static configuration
- Dynamic configuration - Docker - Kubernetes - Consul - Rancher - Nomad - ...
- Setting up SSL - Let's Encrypt
- Dashboard
- Entrypoints
- Routers - HTTP - TCP - UDP
- Services
- Middlewares - securing with basicauth, forwardauth...
- Providers - Docker - Kubernetes - Nomad - Consul - etcd - Redis - HTTP ...
- Traefik as an Ingress Controller for Kubernetes
- Plugins - example with CrowdSec
- Logs
- Traces
- Metrics
- API
- Deployment strategies: blue/green - canary - rolling
- Canary deployment - Flagger
- ACME: automated SSL/TLS deployment
- Managing certificates with Let's Encrypt
- Traefik best practices
- Lab: Publish two applications with Traefik and Docker
- Lab: Middlewares, load balancing and security
Ansible: from discovery to expertise
Explore ↗
- Ansible: from discovery to expertise
- System administration
- Automation: IaC vs CaC
- Ansible
- Installation
- Connection to servers
- Setting up the test environment
- Installation
- The inventory: static, dynamic, groups and variables
- Lab: Inventory and ad-hoc commands
- Ad-Hoc commands
- Structuring your code with roles
- Lab: An nginx role with template and handler
- Dynamic files: Jinja2 and facts
- Security: Vault, SSH and privileges
- Managing infrastructure with playbooks
- A graphical interface: AWX, Semaphore and AAP
- Going further: testing, CI/CD and performance
- Ansible best practices
- RHCE
Elasticsearch: from discovery to expertise
Explore ↗
- Elasticsearch: from discovery to expertise
- Introduction
- Elastic architecture and best practices
- Installation
- NoSQL databases, indices, shards and Apache Lucene
- Index - best practices
- Kibana installation
- Setting up the test environment
- Elasticsearch installation
- Advanced distributed architecture
- Licensing: Elasticsearch license models
- Testing queries and configurations with Kibana Dev Tools
- Retrieving cluster information
- License management
- Monitoring and troubleshooting
- Performance and capacity planning
- Indices
- Templates
- Mappings and text analysis
- Ingestion and ingest pipelines
- Data streams and templates
- Index Lifecycle Management (ILM)
- Kibana spaces: hidden or disabled features
- Security: users, roles and API keys (reserved and deprecated roles)
- External users and roles: Role Mapping
- Space management
- Users and roles
- API keys
- Role mappings
- Advanced security
- Query languages: Query DSL, KQL and ES|QL
- Filter your documents
- Searching
- Advanced Query DSL and aggregations
- Advanced Kibana
- Vector search and RAG
- Change detection
- Backup and restore
- Snapshot Lifecycle Management
- Cross-cluster search and replication
- Elasticsearch on Kubernetes with ECK
- Automation and infrastructure as code
- Elasticsearch best practices
- Final project: run a simulated production Elasticsearch cluster
- ECE
Logstash: from discovery to expertise
Explore ↗
- Logstash: from discovery to expertise
- Introduction
- The pipeline concept
- Installation
- The inputs: inputs
- The filters: filters
- The filters: grok plugin
- The filters: dissect vs grok plugin
- The outputs: output
- Plugin management
- Elastic Common Schema (ECS)
- Setting up the test environment
- Logstash installation
- My first pipeline
- My second pipeline
- Logstash best practices
Prometheus: From Discovery to Expertise
Explore ↗
- Prometheus: From Discovery to Expertise
- Setting up the test environment
- Observability
- Architecture
- Introducing exporters
- Metrics - labels and values
- Installing exporters - node exporter - cAdvisor - Traefik
- OpenTelemetry as a Prometheus exporter
- Building a custom exporter
- Best practices
- Deploying exporters
- Website monitoring and HTTPS checks
- Introduction
- Installation
- Sending and deleting data - using the libraries
- Exporting a batch job's metrics
- Architecture - push - pull
- Installation
- Prometheus self-monitoring - Prometheus server exporter
- Prometheus Web UI
- Prometheus Web UI - Graph - Prometheus Query Language - PromQL
- Understanding recording rules
- Writing and naming recording rules
- Testing, deploying and monitoring rules
- Lab: Writing, testing and measuring recording rules
- Alerting with Alertmanager
- Lab: Alerting with Prometheus and Alertmanager
- Visualizing metrics with Grafana
- Lab: Visualise Prometheus in Grafana (USE and RED methods)
- Prometheus in Kubernetes: Operator and ServiceMonitor
- Lab: Monitor Kubernetes with kube-prometheus-stack
- Prometheus on Kubernetes and its web UI
- Prometheus best practices
- PCA
Cloud Computing: From Discovery to Expertise
Explore ↗
- Cloud Computing: From Discovery to Expertise
- What is Cloud Computing? The NIST definition
- Elasticity vs scalability
- What is a cloud-native application?
- IaaS, PaaS, SaaS: service models
- The shared responsibility model
- Serverless computing
- Deployment models: public, private, hybrid, multi-cloud
- Edge computing
- The 6 Rs: migration strategies
- Introduction to FinOps
- Stop moving to the Cloud, to microservices...
- CaaS: state of the art and best practices
- Cloud best practices
- Lab: Provision cloud resources without an account (LocalStack)
- Lab: Infrastructure as Code with Terraform
- Lab: Elasticity and high availability with Docker Compose
- AWS Certified Cloud Practitioner (CLF-C02)
- Microsoft Azure Fundamentals (AZ-900)
OpenTelemetry: From Discovery to Expertise
Explore ↗
- OpenTelemetry: From Discovery to Expertise
- Why OpenTelemetry?
- OpenTelemetry fundamentals
- The OTLP protocol and its specifications
- The 3 levels of OpenTelemetry architecture
- The Collector's role and pipeline architecture
- Receivers: collecting telemetry data
- Processors: transforming and filtering signals
- Exporters: routing data to backends
- Connectors, extensions and Collector observability
- Lab: Configure an OpenTelemetry Collector (receivers, processors, exporters)
- Auto-instrumentation (Java, Python, Node.js)
- Manual instrumentation with the SDK
- Context propagation
- Lab: Instrument an application and propagate context
- OpenInference: tracing AI applications
- Semantic conventions (semconv)
- Traces in depth
- Distributed tracing and context propagation
- Lab: Hand-instrument traces (spans, events, errors, links, sampling)
- Metrics in depth
- Lab: Instruments, views and exemplars with the metrics SDK
- Logs in depth
- Lab: OpenTelemetry logs correlated with traces and file collection
- Profiles, the fourth signal
- Lab: Profile an application and link profiles to traces
- Correlating traces, metrics, logs and profiles
- Lab: Correlate the four signals of two auto-instrumented services
- Deploy a complete observability pipeline with an Agent and a Gateway
- OpenTelemetry on Kubernetes
- Lab: OpenTelemetry Operator and auto-instrumentation on Kubernetes
- Capstone project: the four signals
- Capstone lab: diagnosing the OpenTelemetry Demo with the four signals
- OpenTelemetry Collector, Grafana Alloy and Bindplane
- OpenTelemetry best practices
- OTCA
- Splunk O11y Metrics User
- New Relic Verified Foundations
- New Relic APM Practitioner
Grafana: From Discovery to Expertise
Explore ↗
- Grafana: From Discovery to Expertise
- Installation
- Infrastructure as Code (IaC)
- How to make the most of the documentation
- Provisioning folder
- Grafana Provisioning: automate dashboards and data sources
- Connections
- Data sources
- Elasticsearch
- Prometheus
- Introduction
- Mistakes to avoid
- What is a dashlet
- Before you start
- Grafana Dashboard
- The role of variables
- Global variables
- Local variables
- Variables: complete guide
- Mastering queries: PromQL, LogQL, SQL and expressions
- Introduction
- Table view
- Data types
- Transformations in detail
- Introduction
- Value Mappings
- Grafana Cloud: getting started with the managed platform
- Project 1: HTTP status codes
- Project 2: Working with the Dynatrace API
- Project 3: Working with data
- Project 4: Working with Elasticsearch
- Project 5: Getting hands-on
- Grafana Assistant: AI for observability
- Grafana or Kibana?
- The LGTM stack
- Grafana best practices
DevOps: From Discovery to Expertise
Explore ↗
- Course overview
- DevOps: state of the art and best practices
- DevOps variants
- The wall of confusion
- Integrated Logistics Support
- Organising DevOps: value stream, teams and culture
- Git for DevOps
- Lab: Trunk-based development, conventional commits and versions
- CI/CD (1/5): principles and anatomy of a pipeline
- CI/CD (2/5): continuous integration, tests and quality
- Lab: A complete CI/CD pipeline
- CI/CD (3/5): artifacts, registries and environments
- CI/CD (4/5): deployment strategies and rollback
- Lab: Image promotion and blue/green deployment
- Lab: Rolling update, canary and rollback on Kubernetes
- CI/CD (5/5): GitHub Actions, GitLab CI, Jenkins and Argo CD
- Infrastructure as Code and GitOps
- Lab: Infrastructure as Code with Terraform
- Lab: GitOps with Argo CD
- The twelve-factor app
- Containers, Kubernetes and cloud native
- DevSecOps: securing the software supply chain
- Lab: Secure the pipeline: secrets, vulnerabilities, SBOM and signing
- Observability, SRE and incident management
- Measuring DevOps performance: DORA and SPACE
- Lab: Measure your DORA metrics from Git
- Platform engineering, FinOps and AI
- The dilemma: with or without AI?
- DevOps best practices
- Final project: a complete DevOps chain from commit to production
- DevOps Foundation
Beats: From Discovery to Expertise
Explore ↗
- Beats: From Discovery to Expertise
- Beats: Filebeat - Winlogbeat - Metricbeat - ...
- Beats: Configuration with or without modules
- Elastic Agent: Fleet
- OpenTelemetry
- Other Sources: Syslog - Fluent Bit - ...
- Adding a Queue: Kafka - RabbitMQ - Redis ...
- Setting up the Testing Environment
- Filebeat Installation
- Going further: security, performance, Elastic Agent and migration
- Beats best practices
- Lab: Collect nginx logs with Filebeat into Elasticsearch
Kubernetes: From Discovery to Expertise
Explore ↗
- Kubernetes: From Discovery to Expertise
- Lab Environment
- Test environment: kind
- Kubernetes architecture and components
- kubectl cheat sheet
- Pods, ReplicaSets and Deployments
- Reliability and scaling: probes, HPA, PDB
- Lab: Deploy, expose and update an application
- Kubernetes Services
- The different CNIs
- Exposing applications: Ingress and Gateway API
- ConfigMaps and Secrets
- PersistentVolumes, Claims and StorageClass
- Resource Quotas
- Package managers
- Deployment managers
- Jobs vs Serverless
- Placement strategies
- Securing your cluster: RBAC, NetworkPolicies, Pod Security
- Lab: RBAC and NetworkPolicy
- Container network security
- Kubernetes best practices
- Comparing Kubernetes offerings
- KCNA
- CKA
- CKAD
- CKS
Alloy: From Discovery to Expertise
Explore ↗
- Alloy: From Discovery to Expertise
- What is Grafana Alloy?
- The concept of 'Programmable Pipelines'
- Internal Architecture
- Installation
- Alloy's user interface
- Lab: Install Alloy with Docker and explore its UI
- Configuration Blocks
- River vs HCL
- Variables and Functions
- Secrets Management
- Environment variables and OpenTelemetry
- Lab: First pipeline - system metrics and local logs
- Discovery
- Scraping
- Remote Write
- OTLP Interoperability
- Lab: Scraping, relabeling and OTLP metrics reception
- Log Sources
- Processing Pipelines
- Dispatching
- Hands-on: Collecting and Dispatching Logs to Loki
- Lab: Parse, filter and enrich JSON logs
- Traces
- Transformation
- Lab: Ingest, transform and sample traces to Tempo
- Continuous Profiling
- Setting up profile collection
- Lab: Continuous profiling with Pyroscope
- Clustering Mode
- Lab: Build a 3-node Alloy cluster
- Alloy on Kubernetes
- Lab: Deploy Alloy on Kubernetes with Helm
- Alloy Observability
- Collection best practices
- Alloy, Grafana Agent and Promtail
- Alloy or OpenTelemetry Collector?
- Alloy or Dynatrace ActiveGate?
- OpenTelemetry Collector, Grafana Alloy and Bindplane
- Component reference
- Final Lab: Unified and modular observability pipeline
HAProxy: from discovery to expertise
Explore ↗
- HAProxy: from discovery to expertise
- Introduction to Load Balancing
- The HAProxy ecosystem: from Open Source to HAProxy One
- Installation and Service Management
- Anatomy of the configuration: Global, Frontend, Backend and Defaults
- Detailed guide to configuration directives
- HAProxy cheat sheet: essential commands
- Algorithms: Round Robin, Leastconn and Hash
- Session persistence (stickiness)
- Health checks and high availability
- Mastering ACLs
- ACLs: the complete guide
- SSL Termination and Offloading
- ACME: automated SSL/TLS
- Certificates with Let's Encrypt
- The Statistics Dashboard
- Dynamic backend addition and removal
- Visualizing your infrastructure: Topology Visualizer
- HAProxy and Docker: building a highly available load-balanced cluster
- Lab: Persistence, health checks and stats page
- Lab: SSL termination and ACL routing
- HAProxy Ingress Controller for Kubernetes
- Ingress Controller: the production guide
- HAProxy best practices
- What's new in HAProxy: OpenTelemetry, JWT, performance
Grafana Tempo: from discovery to expertise
Explore ↗
- Grafana Tempo: from discovery to expertise
- Distributed tracing with Tempo
- Tempo or Jaeger?
- Installing Tempo
- Lab: Deploy Tempo and send your first trace
- The OTLP protocol
- Instrumenting your applications
- Traces with Alloy
- Lab: Instrument a Python application with OpenTelemetry
- TraceQL
- Lab: Troubleshooting with TraceQL
- Metrics from traces
- Correlating traces, logs, metrics and profiles
- Lab: RED metrics and service graph with the metrics-generator
- Storage and scaling
- Tempo in production
- Final Lab: A tracing platform with MinIO, sampling and correlation
- Tempo best practices
Grafana Loki: from discovery to expertise
Explore ↗
- Grafana Loki: from discovery to expertise
- What is Grafana Loki?
- Loki or Elasticsearch?
- Installing Loki
- Lab: Deploy Loki and send your first logs
- Collecting logs into Loki
- Log management with Alloy
- Lab: Collect container and file logs with Alloy
- LogQL: querying logs
- LogQL: turning logs into metrics
- Lab: Mastering LogQL
- Storage, TSDB index and retention
- The Loki Ruler
- Lab: Alerting on logs with the Ruler
- Running Loki in production
- Final Lab: Log platform with MinIO, retention and multi-tenancy
- Loki best practices
Thanos: from discovery to expertise
Explore ↗
- Thanos: from discovery to expertise
- Why Thanos?
- Prometheus, VictoriaMetrics and Thanos
- Thanos, Mimir or VictoriaMetrics?
- Thanos Sidecar
- Lab: Prometheus + Thanos Sidecar + MinIO
- Thanos Query and Query Frontend
- Lab: High availability with two Prometheus instances and Thanos Query
- Store Gateway and Compactor
- Lab: Store Gateway, Compactor and downsampling
- Thanos Ruler
- Thanos Receive
- Lab: Global rules with the Ruler and remote write ingestion
- Deploying Thanos on Kubernetes
- Operating Thanos
- Final Lab: Thanos on Kubernetes
- Thanos best practices
Grafana Mimir: from discovery to expertise
Explore ↗
- Grafana Mimir: from discovery to expertise
- Why Grafana Mimir?
- The write path
- Lab: Monolithic Mimir with MinIO, Prometheus and Grafana
- Lab: Deduplicate two highly available Prometheus servers
- The read path
- Compactor, retention and object storage
- Multi-tenancy and limits
- Lab: Tenants, limits and runtime configuration
- Ruler, Alertmanager and mimirtool
- Lab: Rules and alerts with the ruler and mimirtool
- Deploying and operating Mimir on Kubernetes
- Final Lab: Mimir on Kubernetes with Helm
- Grafana Mimir best practices
Grafana Pyroscope: from discovery to expertise
Explore ↗
- Grafana Pyroscope: from discovery to expertise
- Continuous profiling
- Pyroscope architecture and deployment
- Instrumenting your applications
- Lab: Profile a Go application with the Pyroscope SDK
- Lab: Profile every container on a host with Alloy and eBPF
- Analysing profiles in Grafana
- Lab: Diagnose and validate an optimisation with comparison
- Linking traces and profiles
- Lab: From traces to profiles with Tempo and span profiles
- Pyroscope on Kubernetes
- Final Lab: Continuous profiling of a Kubernetes cluster
- Pyroscope best practices
Alertmanager and alert management: from discovery to expertise
Explore ↗
- Alertmanager and alert management: from discovery to expertise
- Alertmanager: role and lifecycle
- Lab: First Prometheus, Alertmanager and email alerting pipeline
- Writing good alerting rules
- Routing, grouping and receivers
- Lab: Routing by team, grouping and inhibition
- Silences, inhibitions and intervals
- Lab: Rule unit tests and maintenance silences
- High availability and operations
- Lab: Highly available Alertmanager and Watchdog
- Grafana Alerting and on-call
- Final Lab: Grafana alerting provisioned in YAML
- Alerting best practices
SRE in practice: SLIs, SLOs and error budgets
Explore ↗
- SRE in practice: SLIs, SLOs and error budgets
- SLIs, SLOs and SLAs
- The error budget
- Measure SLIs with Prometheus
- Lab: Define an SLI and calculate an error budget
- Alerting on burn rate
- Generating your SLOs with Sloth
- Lab: Generate SLOs and burn rate alerts with Sloth
- Managing your SLOs with Pyrra
- Lab: Track your SLOs in the Pyrra interface
- SRE best practices
- Final Lab: Error budget policy and SLO review
- Chaos engineering: principles, tools and practice
- SRE Practitioner
Observability with eBPF: from discovery to expertise
Explore ↗
- Observability with eBPF: from discovery to expertise
- eBPF explained
- Troubleshooting with bpftrace and bcc
- Lab: Troubleshoot a Linux server with bpftrace
- Zero-code instrumentation with Beyla
- Lab: RED metrics and traces without code using Beyla
- Observing the network with Hubble
- Lab: Kubernetes network flows with Cilium and Hubble
- Continuous profiling with eBPF
- Lab: Profile an entire host with Parca
- eBPF in production
- eBPF best practices
- CCA
Grafana k6: load and performance testing
Explore ↗
- Grafana k6: load and performance testing
- Why load test?
- Writing k6 scripts
- Lab: First k6 test with checks and thresholds
- Thresholds, metrics and results
- Lab: Scenarios, constant arrival rate and stress testing
- Observing a k6 test
- Lab: k6 results in Prometheus and Grafana
- Browser and synthetic monitoring
- Lab: Browser test and Core Web Vitals
- k6 in CI and on Kubernetes
- Final Lab: Blocking performance test in continuous integration
- k6 best practices
Grafana Faro: front-end observability and RUM
Explore ↗
- Grafana Faro: front-end observability and RUM
- RUM and Core Web Vitals
- Faro architecture and installation
- Lab: Collect a page's Web Vitals with Faro, Alloy and Loki
- Errors, events and sessions
- Lab: Errors, business events and sessions
- Traces from the browser to the back end
- Lab: Propagate traces from the browser to an API
- Using Faro data
- Final Lab: User experience dashboard and alert
- Case study: this site's RUM
- Faro best practices
Fluent Bit: from discovery to expertise
Explore ↗
- Fluent Bit: from discovery to expertise
- Overview of log collectors
- Fluent Bit: pipeline and configuration
- Inputs in detail
- Parsers and filters in detail
- Outputs in detail
- Lab: First Fluent Bit pipeline to Loki
- Fluent Bit on Kubernetes
- Lab: Fluent Bit on Kubernetes with metadata
- Fluent Bit or Vector?
- Log collection best practices
Kibana and Elastic Observability: from discovery to expertise
Explore ↗
- Kibana and Elastic Observability: from discovery to expertise
- Kibana: role and installation
- Lab: Install Kibana and explore logs with KQL
- Discover, KQL and ES|QL
- Lab: Analyse with ES|QL
- Lens, dashboards and saved objects
- Lab: Versioned Lens dashboard
- Elastic Observability
- Alerts, connectors and SLOs
- Lab: ES|QL alert rule and connector
- Administering Kibana
- Final Lab: Spaces and roles for two teams
- Kibana best practices
- Elastic Observability Engineer
- Elastic Certified Analyst
- Elastic SIEM Analyst
VictoriaMetrics: from discovery to expertise
Explore ↗
- VictoriaMetrics: from discovery to expertise
- Why VictoriaMetrics?
- Lab: Single-node VictoriaMetrics with Prometheus and Grafana
- Ingesting metrics
- Lab: vmagent, disk buffer and storage outage
- MetricsQL
- Lab: MetricsQL and cardinality exercises
- VictoriaMetrics in cluster mode
- Lab: Multi-tenant VictoriaMetrics cluster
- Running VictoriaMetrics
- Final Lab: Alerting with vmalert and Alertmanager
- Thanos, Mimir or VictoriaMetrics?
- VictoriaMetrics best practices
Jaeger: distributed tracing from discovery to expertise
Explore ↗
- Jaeger: distributed tracing from discovery to expertise
- Distributed tracing with Jaeger
- Installing Jaeger v2
- Lab: Jaeger all-in-one and troubleshooting with HotROD
- Instrumenting with OpenTelemetry
- Lab: Instrument a Python application for Jaeger
- Analysing traces in Jaeger
- Lab: Service Performance Monitoring (SPM)
- Jaeger in production
- Final Lab: Jaeger on Elasticsearch with tail sampling
- Tempo or Jaeger?
- Jaeger best practices
SigNoz: from discovery to expertise
Zabbix: infrastructure monitoring from discovery to expertise
Explore ↗
- Zabbix: infrastructure monitoring from discovery to expertise
- Zabbix: architecture and concepts
- Installing Zabbix
- Lab: Install Zabbix and monitor a first host
- Collecting data with Zabbix
- Lab: Custom template, items, triggers and discovery
- Lab: Collect Prometheus metrics with Zabbix
- Triggers and notifications
- Lab: Webhook notifications, escalation and maintenance
- Dashboards, Grafana and API
- Building dashboards in Zabbix
- Grafana dashboards with the Zabbix data source
- Zabbix in production
- Final Lab: Automate Zabbix with the API and display it in Grafana
- Zabbix best practices
- ZCU
- ZCS
Datadog: from discovery to expertise
Explore ↗
- Datadog: from discovery to expertise
- Datadog at a glance
- Datadog platform architecture
- Agent and integrations
- Lab: Install the Datadog agent and enable an integration
- Datadog on Kubernetes
- Lab: Monitor a Kubernetes cluster with the Datadog Operator
- Metrics and tags
- Advanced metrics and cardinality
- Lab: Custom metrics with DogStatsD and a dashboard
- Dashboards and notebooks
- Logs in Datadog
- Advanced logs: indexes, Flex and archives
- Lab: Log pipeline, facets and volume control
- APM and OpenTelemetry
- Advanced APM: sampling and profiler
- Lab: Python APM and log-trace correlation
- RUM and Synthetic Monitoring
- Lab: Synthetic tests with Terraform and CI
- Network, cloud and databases
- Security with Datadog
- Monitors, SLOs and Terraform
- Incidents and automation
- Final Lab: Monitors and SLOs in Terraform
- Costs and governance
- Datadog best practices
- Datadog Fundamentals
- Log Management Fundamentals
- APM & Distributed Tracing Fundamentals
Bindplane: OpenTelemetry telemetry pipelines from discovery to expertise
Explore ↗
- Bindplane: OpenTelemetry telemetry pipelines from discovery to expertise
- Bindplane: managing telemetry pipelines
- OpenTelemetry Collector, Grafana Alloy and Bindplane
- Installing Bindplane
- Lab: Install Bindplane and connect a first collector
- Bindplane configurations
- Lab: Build a log pipeline and observe the data
- Reduce, mask and route
- Lab: Reduce and mask logs, then measure the gain
- Fleets, gateways and rollouts
- Lab: Batched rollout, error and rollback
- Bindplane in production
- Final Lab: Production pipeline managed as code
- Bindplane best practices
Arize AI: LLM observability and evaluation from discovery to expertise
Explore ↗
- Arize AI: LLM observability and evaluation from discovery to expertise
- Arize AI: LLM observability and evaluation
- OpenInference: tracing AI applications
- Installing Phoenix and tracing an application
- Lab: Install Phoenix and trace a first LLM application
- Tracing a RAG and an agent
- Lab: Trace a RAG and sessions
- Evaluating with LLM judges
- Lab: Evaluate answers with code and an LLM judge
- Datasets, experiments and prompts
- Lab: Compare two prompts with an experiment
- Arize in production
- Final Lab: Production LLM observability with Phoenix
- Arize and OpenInference best practices
Linux administration: from discovery to expertise
Explore ↗
- Linux administration: from discovery to expertise
- Linux and Unix: distributions and essential commands
- Architecture of a Linux system
- The Bash shell and files
- Lab: Analyse logs on the command line
- Users, groups, sudo and permissions
- Lab: Accounts, team folder, sudo and ACLs
- Packages, systemd services and logs
- Lab: Create and manage a systemd service
- Disks, file systems and LVM
- Lab: LVM, fstab and online extension
- Networking, firewall and SSH
- Lab: Network troubleshooting, key-based SSH and firewall
- Processes, memory and performance
- Security and hardening
- Robust Bash scripts
- Lab: A robust, scheduled backup script
- Backup, monitoring and troubleshooting
- Final lab: Prepare a server for production and resolve an incident
- Linux best practices
- LFCS
- RHCSA
Vector: from discovery to expertise
Explore ↗
- Vector: from discovery to expertise
- Overview of log collectors
- Vector: topology and components
- Sources in detail
- Transforms in detail
- Sinks in detail
- VRL and unit tests
- Lab: Parse nginx logs with Vector and VRL
- Final Lab: Vector unit tests and masking personal data
- Fluent Bit or Vector?
- Log collection best practices
ClickStack: from discovery to expertise
AWS: from discovery to expertise
Explore ↗
- AWS: from discovery to expertise
- Understanding AWS: infrastructure, accounts, tools and pricing
- IAM: identities, roles and policies
- Networking: VPC, subnets, routing and security
- Compute: EC2, Auto Scaling, Lambda and containers
- Storage: S3, EBS, EFS and backup
- Databases: RDS, Aurora, DynamoDB
- Monitor and secure: CloudWatch, CloudTrail, KMS, GuardDuty
- AWS observability: CloudWatch, X-Ray, ADOT, Prometheus and Grafana
- Infrastructure as Code and Well-Architected
- Control your AWS costs
- Lab: S3 storage with LocalStack
- Lab: A serverless API (API Gateway, Lambda, DynamoDB) on LocalStack
- Lab: Infrastructure as Code and decoupling with SQS and SNS (Terraform on LocalStack)
- AWS best practices
- Preparation guide: Cloud Practitioner (CLF-C02)
- AWS Certified Cloud Practitioner (CLF-C02)
- Preparation guide: Solutions Architect Associate (SAA-C03)
- AWS Certified Solutions Architect – Associate (SAA-C03)
Microsoft Azure: from discovery to expertise
Explore ↗
- Microsoft Azure: from discovery to expertise
- Understanding Azure: regions, hierarchy, tools and pricing
- Entra ID, RBAC and Azure Policy
- Azure networking
- Compute: VMs, App Service, Functions and containers
- Azure storage
- Azure databases
- Monitor and protect Azure
- Azure observability: Azure Monitor, Log Analytics, Application Insights
- Bicep, Terraform and cost control
- Lab: Blob and Queue Storage with Azurite
- Lab: A queue-triggered Azure Function, locally
- Lab: Infrastructure as Code with Bicep (local validation and what-if)
- Azure best practices
- Preparation guide: AZ-900
- Microsoft Azure Fundamentals (AZ-900)
- Preparation guide: AZ-104
- Microsoft Azure Administrator Associate (AZ-104)
Google Cloud: from discovery to expertise
Explore ↗
- Google Cloud: from discovery to expertise
- Understanding Google Cloud
- IAM on Google Cloud
- Google Cloud networking
- Compute on Google Cloud
- Google Cloud storage
- Google Cloud databases
- Operating Google Cloud
- Google Cloud observability: Monitoring, Logging, Trace, Profiler
- Lab: Messaging with the Pub/Sub emulator
- Lab: An API on the Functions Framework with the Firestore emulator
- Lab: Cloud Storage locally with fake-gcs-server
- Google Cloud best practices
- Preparation guide: Cloud Digital Leader
- Google Cloud Digital Leader
- Preparation guide: Associate Cloud Engineer
- Google Associate Cloud Engineer
OVHcloud: from discovery to expertise
Explore ↗
- OVHcloud: from discovery to expertise
- Understanding OVHcloud
- Identity and access
- Public Cloud networking
- Instances and Managed Kubernetes
- OVHcloud storage
- Managed databases
- Operating OVHcloud
- Lab: S3-compatible Object Storage simulated with MinIO
- Lab: The Managed Kubernetes workflow simulated with k3d
- Lab: Terraform for OVHcloud tested with mock providers
- OVHcloud best practices
Terraform: from discovery to expertise
Explore ↗
- Terraform: from discovery to expertise
- Principles, architecture and workflow
- The HCL language
- State: backends, locking, import
- Modules
- Environments and organisation
- Test and secure
- Terraform in CI/CD
- Terraform across clouds
- Lab: First steps with Terraform on LocalStack
- Lab: Remote state, locking, import and refactoring
- Lab: A tested module (terraform test, tflint, Checkov)
- Terraform best practices
- Preparation guide: Terraform Associate
- HashiCorp Certified: Terraform Associate (004)
Articles
- Understanding the concept of score ↗
- Understanding the Elastic Common Schema (ECS) ↗
- Stop moving to the Cloud, to micro-services... ↗
- License consumption types ↗
- Package managers ↗
- Grafana Alloy: The importance of Self-Monitoring ↗
- Grafana Alloy: Understanding and exploiting the User Interface (UI) ↗
- Grafana Alloy: Introduction and Architecture ↗
- Grafana Alloy: Syntax and Configuration (Alloy Language: River) ↗
- Grafana Alloy: Metrics Collection (Prometheus & Ecosystem) ↗
- Grafana Alloy: Log Management with Loki ↗
- Grafana Alloy: Trace Management with Tempo ↗
- Grafana Alloy: Continuous Profiling with Pyroscope ↗
- Grafana Alloy: Advanced Deployment and Clustering ↗
- Grafana Assistant: AI at the service of observability ↗
- Grafana Alloy vs OpenTelemetry Collector: Which One Should You Choose? ↗
- Grafana Alloy vs Dynatrace ActiveGate: Which to choose? ↗
- Application Protection ↗
- Grafana Alloy environment variables: GOMEMLIMIT, sys.env and OTEL_RESOURCE_ATTRIBUTES ↗
- Prometheus recording rules: speeding up your queries and dashboards ↗