ROUSSELTM LEARNING
Plan du site
Tous les domaines, les formations et les articles, réunis au même endroit.
Formations
Docker : de la découverte à l'expertise
Explorer ↗
- Vue d'ensemble de la formation
- Docker : de la découverte à l'expertise
- Virtualisation et conteneurisation
- Les briques de Docker avec les termes des activités portuaires
- Mise en place de l'environnement de test
- Installation Docker engine - Moteur Docker - TP avec vagrant et virtualbox
- Installation Docker desktop
- Présentation CLI - TP avec vagrant et virtualbox
- Installation Docker
- Le concept de couche dans Docker
- Docker hub
- Déploiement de conteneurs
- Dockerfile
- Dockerfile - Multi-stage builds
- Construction d'une image et transfert vers docker hub - uptimerobot exporter
- Les bonnes pratiques pour construire un Dockerfile - .dockerignore - multi-stage
- Création de mon premier conteneur
- Container registry : choisir et sécuriser son registre
- La communication réseau d'un conteneur - inspect - network
- La persistance des données au sein d'un conteneur
- La sécurité avec docker security bench
- Gérer son propre registry
- Prise en main de Docker Desktop - Docker Scout - extensions
- Déployer un registry docker harbor de VMware - scan - trivy - security
- Ma première mise en réseau et persistence d'un conteneur
- Ma première image multi-stage
- Introduction
- Faut-il saisir 'docker compose' ou 'docker-compose'
- Création d'un fichier compose.yaml
- Utilisation avancée des labels - config traefik - deployment kubernetes
- Mon premier fichier docker compose
- Introduction
- Déployer Cluster Docker SWARM et premières manipulations
- Eviction des conteneurs - Memory - CPU - QoS Classes
- Configuration as code - Terraform/Opentofu - saltstack - Ansible
- Les piliers de l'observabilité : logs, traces et métriques
- Configuration exporter prometheus VM/conteneur-cadvisor- node-exporter - ingress
- Les logs, traces et métriques avec Dynatrace - Docker et kubernetes
- Projet 1
- Aide-mémoire Docker : les commandes essentielles
- Bonnes pratiques Docker
- DCA
Dynatrace : de la découverte à l’expertise
Explorer ↗
- Vue d’ensemble de la formation
- Dynatrace : de la découverte à l’expertise
- Définitions
- Comment suivre la formation
- Architecture Dynatrace
- 🧠 Dynatrace Davis
- Mise en place de l’environnement de test
- SaaS vs Managed
- C’est quoi le playground ?
- Accéder au playground
- Interface SaaS vs Managed
- Organisation du cluster / environnement
- Prise en main de l’interface Dynatrace
- Nouvelle page vs page classique
- Tableau de bord vs Tableau de bord classique - Dashboards vs Dashboards classic
- Comment connaître en un coup d’œil l’état d’un host, service ...
- Ensemble des technologies présentes sur votre cluster-Technologies and processes
- Ajouter/supprimer des fonctions au cluster - extensions -extensions manager
- Licences Dynatrace : modèle classique et DPS
- Suivre votre consommation DDU - Davis Data Units (modèle de licence classique)
- Licensing et FinOps
- Les méthodes de collecte - oneagent - opentelemetry - exporter Prometheus ...
- Oneagent
- Installation du oneagent - Hostgroup - tags - owners - properties
- Reconfigurer le oneagent avec la cli oneagentctl ou via le deployment status
- Oneagent dans le monde docker / kubernetes
- Oneagent health
- Comment connaître en un coup d’œil l’état d’un host, service ...
- La corrélation entre piliers de l’observabilité - logs, métriques et traces
- TP - la collecte
- ActiveGate et network zones
- Dynatrace Operator sur Kubernetes
- OpenTelemetry et Dynatrace
- Comprendre et manipuler les différentes API dynatrace
- Présentation de Monaco
- Créer et manipuler les tokens : exemple de tokens Monaco
- Créer un client OAuth si vous avez une souscription SaaS
- [CI/CD] Builder votre propre image Docker pour Monaco - Github action
- Présentation de dynatrace simply smarter
- Exporter, Créer, supprimer... votre première configuration avec Monaco
- [CI/CD] Pipeline pour exécuter automatiquement Monaco - Gitlab CI/CD
- Sélections des élements dans le cluster - filtres - Entity selector
- Manipuler les zones de gestion - management zones - settings
- TP - Création et utilisation des Entity Selectors
- Segments et nouvelle plateforme
- Introduction
- Créez automatiquement des problèmes dans vos solutions - Issue tracking
- Retrouvez les informations saisies dans votre déploiement kubernetes - release
- Gestion des événements - API - events - release monitoring - CI/CD
- Surveillance des utilisateurs réels sans installation des agents
- Comment retrouver, modifier et supprimer une application créée
- Surveillance des utilisateurs réels d’une application PaaS
- Surveillance des utilisateurs réels via une extension du navigateur
- Comment vérifier si l’instrumentation est bien en place
- Introduction au synthetic
- Créer une surveillance en HTTP (HTTP monitor)
- Modifier une surveillance en HTTP (HTTP monitor)
- Surveillance via navigateur (Browser monitor)
- Surveillance via navigateur (Browser monitor) - utilisation du javascripts
- Surveillance via navigateur (Browser monitor) - CSS selector
- Ajouter de l’authentification dans vos scénarios - credential vault
- TP - Le Synthetic Monitoring
- Application frontend
- Apdex (Application Performance Index) vs Core Web Vitals
- User session
- flux entre service - service flow
- Traces distribuées - distributed traces
- Analyser les appelants - Application Databases - backtrace
- Analyse multidimensionnelle - multidimensional analysis
- Actions et évènements - User session query language - USQL
- Construisez votre première requête USQL - SQL like - USQL
- Comprendre et optimiser les parcours de vos utilisateurs - funnel - USQL
- TP - Visualisez et analysez votre expérience utilisateur (DEM)
- Business observability
- Introduction
- Créez votre premier graphe - Data explorer
- Créer votre premier tableau de bord - dashboards classic
- L’application problèmes (Problems)
- Auto-remediation : self healing
- Le contenu d’une page problème
- Installer l’application mobile pour recevoir les alertes - install mobile
- Davis AI avancé
- Alerting avancé
- Workflows et AutomationEngine
- Les propriétaires (owners / ownerships)
- Reconfigurer un oneagent pour définir le propriétaire de la machine
- Fenêtres de maintenace - Maintenance Windows
- Renommage de ressources - host naming - process group naming - request naming
- Requêtes clés (key requests)
- Appliquer les tags - Automatically applied tags - Manually applied tags
- Présentation SLO - SLI - SLA - SRE
- Gestion des SLO
- Smartscape topology
- Les sous applications
- Analysez la session de vos visiteurs comme si vous y étiez - waterfall analysis
- Afficher l’ensembles des containers présents sur le cluster - containers
- Voir et analyser un cluster kubernetes - kubernetes
- Parcourir les données collectées dans une souscription - Lambda Function - AWS
- Surveille l’utilisation réseau - Host networking
- Cloud et infrastructure
- AppEngine et applications personnalisées
- Présentation de Grail
- Parcourez et recherchez vos donnés d’observabilité - Logs and events - Grail
- Construisez vos premières requêtes DQL - Grail
- Enrichissez vos requêtes DQL et ajoutez les à un carnet de note- Notebooks - Grail
- Enrichissez vos requêtes DQL-ajoutez les à un tableau de bord- Dashboards - Grail
- Les bonnes pratiques pour construire des requêtes DQL performantes - Grail
- TP - Analyse avancée avec Grail, DQL et Entity Selectors
- Logs avancés et OpenPipeline
- Grail et DQL avancés
- Gérer les permissions : IAM, groupes et politiques
- Sécurité et gouvernance
- La rétention des données
- Projet 1
- Projet 2 : RUM
- Les applications à maîtriser pour son analyse
- Bonnes pratiques Dynatrace
- Associate
- Advanced Observability Specialist
- DEM and Business Analytics Specialist
- Implementation Professional
- Administration Professional
Vagrant : de la découverte à l'expertise
Explorer ↗
- Vue d'ensemble de la formation
- Vagrant : de la découverte à l'expertise
- Installation de vagrant
- Les providers : virtualbox - Docker - VMware - Hyperv-V ...
- Vagrant Cloud : Boxes public et privé
- La gestion des boxes : vagrant box
- Construction d'images : Hashicorp Packer
- Construction d'images : Export d'une machine - Non recommandée
- initialisation : vagrant init
- Construire et arrêter sa première machine : vagrant up / down
- Définition du provider et des caractéristiques de la machine : CPU - RAM - ...
- Le nommage - vagrant - virtualbox - hostname
- Connexion à la machine crée - vagrant ssh - rdp
- La synchronisation des fichiers
- Le réseau : port forward - private network - public betwork
- Configuration de la machine : Provisioner file
- Configuration de la machine : Provisioner SHELL
- Configuration de la machine : Provisioner Ansible - Salt - Chef - Puppet
- Configuration de la machine : Provisioner Docker
- TP : Ma première machine virtuelle avec Vagrant
- Pourquoi le multi-machine
- Vagrantfile : variables, conditions et boucles pour déployer plusieurs machines
- Déployer un cluster Docker SWARM prêt à l'emploi (jointure déjà faites)
- TP : Un environnement multi-machines (web + base de données)
- Présentation : cas des providers et des provisioners
- Le partage d'environnement de test : ngrok et le plugin vagrant-share
- TP : Provisioning Ansible et snapshots
- Bonnes pratiques Vagrant
Traefik : de la découverte à l'expertise
Explorer ↗
- Vue d'ensemble de Traefik
- Traefik : de la découverte à l'expertise
- Load balancer - proxy - reverse proxy
- Traefik
- Comment suivre cette formation
- Code promo pour nos autres formations
- Mise en place environnement de test
- Installation
- Stand alone - classique
- Docker
- Kubernetes - helm
- Attention aux goulots d'étranglement - HA -SPOF - traefik enterprise-traefik hub
- Les méthodes de configuration - Fichier (YAML) - Fichier (TOML) - CLI - ...
- La configuration statique vs dynamique
- Configuration statique
- Configuration dynamique - docker - kubernetes - consul - rancher - Nomad - ...
- Mise en place du SSL - letsencrypt
- Tableau de bord
- Entrypoints
- Routers - HTTP - TCP - UDP
- Services
- Middlewares - mise en place de la sécurité avec basicauth, forwardauth...
- Providers - docker - kubernetes - Nomad - consul - etcd - redis - http ...
- Traefik comme ingress controllers pour kubernetes
- Les plugins - exemple avec crowdsec
- Les logs
- Les traces
- Les métriques
- API
- Stratégies de deploiement : blue/green - canary - rolling
- Canary deployment - flagger
- ACME : le déploiement SSL/TLS automatisé
- Gérer ses certificats avec Let's Encrypt
- Bonnes pratiques Traefik
- TP : Publier deux applications avec Traefik et Docker
- TP : Middlewares, load balancing et sécurité
Ansible : de la découverte à l'expertise
Explorer ↗
- Ansible : de la découverte à l'expertise
- Administration système
- Automatisation : IaC vs CaC
- Ansible
- Installation
- Connexion aux serveurs
- Mise en place environnement de test
- Installation
- L'inventaire : statique, dynamique, groupes et variables
- TP : Inventaire et commandes ad-hoc
- Les commandes Ad-Hoc
- Structurer son code avec les rôles
- TP : Un rôle nginx avec template et handler
- Fichiers dynamiques : Jinja2 et facts
- Sécurité : Vault, SSH et privilèges
- Gérer son infrastructure avec des playbooks
- Une interface graphique : AWX, Semaphore et AAP
- Aller plus loin : tests, CI/CD et performances
- Bonnes pratiques Ansible
- RHCE
Elasticsearch : de la découverte à l'expertise
Explorer ↗
- Elasticsearch : de la découverte à l'expertise
- Introduction
- Architecture Elastic et bonnes pratiques
- Installation
- Bases de données NoSQL, index, shards et Apache Lucene
- Index - les bonnes pratiques
- Installation Kibana
- Mise en place de l'environnement de test
- Installation Elasticsearch
- Architecture distribuée avancée
- Licensing : modèles de licence Elasticsearch
- Tester les requêtes et configurations avec Kibana Dev Tools
- Récupérer les informations du cluster
- Gestion des licences
- Monitoring et troubleshooting
- Performance et capacity planning
- Les index
- Les templates
- Mappings et analyse de texte
- Ingestion et ingest pipelines
- Data streams et templates
- Index Lifecycle Management (ILM)
- Espaces Kibana : fonctionnalités masquées ou désactivées
- Sécurité : utilisateurs, rôles et clés API (rôles réservés et dépréciés)
- Utilisateurs et rôles externes : Role Mapping
- Gestion des espaces
- Utilisateurs et rôles
- API keys
- Role mappings
- Sécurité avancée
- Langages de requête : Query DSL, KQL et ES|QL
- Filtrez vos documents
- La recherche
- Query DSL et agrégations avancées
- Kibana avancé
- Recherche vectorielle et RAG
- Détection des changements
- Sauvegarde et restauration
- Snapshot Lifecycle Management
- Cross-cluster search et replication
- Elasticsearch sur Kubernetes avec ECK
- Automatisation et infrastructure as code
- Bonnes pratiques Elasticsearch
- Projet final : exploiter un cluster Elasticsearch de production simulée
- ECE
Logstash : de la découverte à l'expertise
Explorer ↗
- Logstash : de la découverte à l'expertise
- Introduction
- Le concept de pipeline
- Installation
- Les entrées : inputs
- Les filtres : filters
- Les filtres : plugin grok
- Les filtres : plugin dissect vs grok
- Les sorties : output
- La gestion des plugins
- Elastic Common Schema (ECS)
- Mise en place de l'environnement de test
- Installation logstash
- Mon premier pipeline
- Mon second pipeline
- Bonnes pratiques Logstash
Prometheus : de la découverte à l'expertise
Explorer ↗
- Prometheus : de la découverte à l'expertise
- Mise en place de l'environnement de test
- L'observabilité
- Architecture
- Présentation des exporters
- Les metrics - les labels et les valeurs
- Installation des exporteurs - exporter - node exporter - cadvisor - traefik
- Opentelemetry comme exporter prometheus
- Construction d'un exporter personnalisé
- Les bonnes pratiques
- Déploiement d'exporteurs
- Monitoring de site web et surveillance HTTPS
- Introduction
- Installation
- Envoi et suppression des données - utilisation des librairies
- Exporter les métriques d'un Batch
- Architecture - push - pull
- Installation
- Auto-surveillance de prometheus - exporter prometheus server
- Prometheus Web UI
- Prometheus Web UI - Graph - Prometheus Query Language - PromQL
- Alerter avec Alertmanager
- TP : Alerter avec Prometheus et Alertmanager
- Visualiser ses métriques avec Grafana
- TP : Visualiser Prometheus dans Grafana (méthodes USE et RED)
- Prometheus dans Kubernetes : Operator et ServiceMonitor
- TP : Superviser Kubernetes avec kube-prometheus-stack
- Prometheus sur Kubernetes et interface web
- Bonnes pratiques Prometheus
- PCA
Cloud Computing : de la découverte à l'expertise
Explorer ↗
- Cloud Computing : de la découverte à l'expertise
- Qu'est-ce que le Cloud Computing ? La définition du NIST
- Élasticité vs scalabilité
- Qu'est-ce qu'une application cloud native ?
- IaaS, PaaS, SaaS : les modèles de service
- Le modèle de responsabilité partagée
- Le serverless
- Les modèles de déploiement : public, privé, hybride, multi-cloud
- Edge computing
- Les 6 R : stratégies de migration
- Introduction au FinOps
- Arrêtez de passer au Cloud, au micro-service...
- CaaS : état de l'art et bonnes pratiques
- Bonnes pratiques Cloud
- TP : Provisionner des ressources cloud sans compte (LocalStack)
- TP : Infrastructure as Code avec Terraform
- TP : Élasticité et haute disponibilité avec Docker Compose
- AWS Certified Cloud Practitioner (CLF-C02)
- Microsoft Azure Fundamentals (AZ-900)
Opentelemetry : de la découverte à l'expertise
Explorer ↗
- OpenTelemetry : de la découverte à l'expertise
- Pourquoi OpenTelemetry ?
- Les concepts fondamentaux d'OpenTelemetry
- Le protocole OTLP et les spécifications
- Les 3 niveaux d'architecture OpenTelemetry
- Le rôle du Collector et l'architecture du pipeline
- Les Receivers : Collecter la donnée de télémétrie
- Les Processors : Transformer et filtrer les signaux
- Les Exporters : Router la donnée vers les backends
- Connecteurs, extensions et observabilité du Collector
- TP : Configurer un Collector OpenTelemetry (receivers, processors, exporters)
- Auto-instrumentation (Java, Python, Node.js)
- Instrumentation manuelle avec le SDK
- Propagation de contexte
- TP : Instrumenter une application et propager le contexte
- OpenInference : tracer les applications d'IA
- Les conventions sémantiques (semconv)
- Les traces en profondeur
- Tracing distribué et contexte de propagation
- TP : Instrumenter des traces à la main (spans, événements, erreurs, liens, échantillonnage)
- Les métriques en profondeur
- TP : Instruments, vues et exemplars avec le SDK métriques
- Les logs en profondeur
- TP : Logs OpenTelemetry corrélés aux traces et collecte de fichiers
- Les profils, le quatrième signal
- TP : Profiler une application et relier profils et traces
- Corréler traces, métriques, logs et profils
- TP : Corréler les quatre signaux de deux services auto-instrumentés
- Déployer un pipeline d'observabilité complet avec Agent et Gateway
- OpenTelemetry sur Kubernetes
- TP : OpenTelemetry Operator et auto-instrumentation sur Kubernetes
- Projet fil rouge : les quatre signaux
- TP fil rouge : diagnostiquer l'OpenTelemetry Demo avec les quatre signaux
- OpenTelemetry Collector, Grafana Alloy et Bindplane
- Bonnes pratiques OpenTelemetry
- OTCA
- Splunk O11y Metrics User
- New Relic Verified Foundations
- New Relic APM Practitioner
Grafana : de la découverte à l'expertise
Explorer ↗
- Grafana : de la découverte à l'expertise
- Installation
- Infrastructure as Code (IaC)
- Comment bien exploiter la documentation
- Dossier provisionning
- Grafana Provisioning : automatiser les dashboards et sources
- Les connections
- Les sources de données
- Elasticsearch
- Prometheus
- Introduction
- Les erreurs à éviter
- C'est quoi une dashlet
- Avant de vous lancer
- Grafana Dashboard
- Le rôle des variables
- Les variables globales
- Les variables locales
- Les variables : guide complet
- Maîtriser les requêtes : PromQL, LogQL, SQL et expressions
- Introduction
- Table view
- Types des données
- Les transformations en détail
- Introduction
- Value Mappings
- Grafana Cloud : démarrer avec la plateforme managée
- Projet 1 : Codes retour HTTP
- Projet 2 : Manipulation de l'API Dynatrace
- Projet 3 : Manipulation de la donnée
- Projet 4 : Exploitation d'Elasticsearch
- Projet 5 : Prise en main
- Grafana Assistant : l'IA au service de l'observabilité
- Grafana ou Kibana ?
- La stack LGTM
- Bonnes pratiques Grafana
DevOps : de la découverte à l'expertise
Explorer ↗
- Vue d'ensemble de la formation
- DevOps : Etat de l'art et bonnes pratiques
- Les variantes du DevOps
- Le mur de la confusion
- Le Soutien Logistique Intégré
- Organiser le DevOps : flux de valeur, équipes et culture
- Git pour le DevOps
- TP : Trunk-based development, commits conventionnels et versions
- CI/CD (1/5) : principes et anatomie d'un pipeline
- CI/CD (2/5) : intégration continue, tests et qualité
- TP : Un pipeline CI/CD complet
- CI/CD (3/5) : artefacts, registres et environnements
- CI/CD (4/5) : stratégies de déploiement et retour arrière
- TP : Promotion d'une image et déploiement blue/green
- TP : Rolling update, canary et retour arrière sur Kubernetes
- CI/CD (5/5) : GitHub Actions, GitLab CI, Jenkins et Argo CD
- Infrastructure as Code et GitOps
- TP : Infrastructure as Code avec Terraform
- TP : GitOps avec Argo CD
- L'application 12 facteurs
- Conteneurs, Kubernetes et cloud native
- DevSecOps : sécuriser la chaîne logicielle
- TP : Sécuriser le pipeline : secrets, vulnérabilités, SBOM et signature
- Observabilité, SRE et gestion des incidents
- Mesurer la performance DevOps : DORA et SPACE
- TP : Mesurer ses métriques DORA à partir de Git
- Platform engineering, FinOps et IA
- Les dilemmes : Avec ou sans IA ?
- Bonnes pratiques DevOps
- Projet final : une chaîne DevOps complète du commit à la production
- DevOps Foundation
Beats : de la découverte à l'expertise
Explorer ↗
- Beats : de la découverte à l'expertise
- Beats : Filebeat - Winlogbeat - Metricbeat - ...
- Beats : La configuration avec ou sans module
- Elastic agent : fleet
- Opentelemetry
- Les autres sources : syslog - fluentbit - ...
- Et si on ajoutait une file d'attente : kafka - rabbitmq - redis ...
- Mise en place de l'environnement de test
- Installation Filebeat
- Aller plus loin : sécurité, performances, Elastic Agent et migration
- Bonnes pratiques Beats
- TP : Collecter des logs nginx avec Filebeat vers Elasticsearch
Kubernetes : de la découverte à l'expertise
Explorer ↗
- Kubernetes : de la découverte à l'expertise
- Environnement de test
- Environnement de test : kind
- Architecture et composants de Kubernetes
- Aide-mémoire kubectl
- Pods, ReplicaSets et Deployments
- Fiabilité et mise à l'échelle : probes, HPA, PDB
- TP : Déployer, exposer et mettre à jour une application
- Les Services Kubernetes
- Les différents CNI
- Exposer ses applications : Ingress et Gateway API
- ConfigMaps et Secrets
- PersistentVolumes, Claims et StorageClass
- Resource Quotas
- Gestionnaires de packages
- Gestionnaires de déploiement
- Jobs vs Serverless
- Stratégies de placement
- Sécuriser son cluster : RBAC, NetworkPolicies, Pod Security
- TP : RBAC et NetworkPolicy
- Sécurité réseau des conteneurs
- Bonnes pratiques Kubernetes
- Comparaison des offres Kubernetes
- KCNA
- CKA
- CKAD
- CKS
Alloy : de la découverte à l'expertise
Explorer ↗
- Alloy : de la découverte à l'expertise
- Qu'est-ce que Grafana Alloy ?
- Le concept de "Programmable Pipelines"
- Architecture interne
- Installation
- Alloy, Grafana Agent et Promtail
- Alloy ou OpenTelemetry Collector ?
- Alloy ou Dynatrace ActiveGate ?
- TP : Installer Alloy avec Docker et explorer son interface
- OpenTelemetry Collector, Grafana Alloy et Bindplane
- Les blocs de configuration
- River vs HCL
- Variables et Fonctions
- Gestion des Secrets
- Observabilité d'Alloy
- L'interface utilisateur d'Alloy
- TP : Premier pipeline - métriques système et logs locaux
- Discovery
- Scraping
- Remote Write
- Interopérabilité OTLP
- TP : Scraping, relabeling et réception OTLP des métriques
- Sources de logs
- Pipelines de traitement
- Expédition
- TP : Collecte et Expédition des Logs vers Loki
- TP : Parser, filtrer et enrichir des logs JSON
- Traces
- Transformation
- TP : Ingérer, transformer et échantillonner des traces vers Tempo
- Continuous Profiling
- Mise en place de la collecte de profils
- TP : Profilage continu avec Pyroscope
- Le mode Clustering
- TP : Monter un cluster Alloy à 3 nœuds
- Alloy sur Kubernetes
- TP : Déployer Alloy sur Kubernetes avec Helm
- Bonnes pratiques de collecte
- Référence des composants
- TP Final : Pipeline d'observabilité unifié et modulaire
HAProxy : de la découverte à l'expertise
Explorer ↗
- HAProxy : de la découverte à l'expertise
- Introduction à la répartition de charge (Load Balancing)
- L'écosystème HAProxy : de l'Open Source à HAProxy One
- Installation et Gestion du service
- Anatomie de la configuration: Global, Frontend, Backend et Defaults
- Guide détaillé des directives de configuration
- Aide-mémoire HAProxy : les commandes essentielles
- Algorithmes : Round Robin, Leastconn et Hash
- Persistance de session (stickiness)
- Health checks et haute disponibilité
- Maîtriser les ACL
- Les ACL : le guide complet
- Terminaison SSL et Offloading
- ACME : SSL/TLS automatisé
- Certificats avec Let's Encrypt
- Le tableau de bord des statistiques
- Ajout et suppression dynamique de backends
- Visualiser son infrastructure : Topology Visualizer
- HAProxy et Docker : construire un cluster load balancé de haute disponibilité
- TP : Persistance, health checks et page de statistiques
- TP : Terminaison SSL et routage par ACL
- HAProxy Ingress Controller pour Kubernetes
- Ingress Controller : le guide de production
- Bonnes pratiques HAProxy
- Nouveautés HAProxy : OpenTelemetry, JWT, performances
Grafana Tempo : de la découverte à l'expertise
Explorer ↗
- Grafana Tempo : de la découverte à l'expertise
- Le tracing distribué avec Tempo
- Tempo ou Jaeger ?
- Installation de Tempo
- TP : Déployer Tempo et envoyer sa première trace
- Le protocole OTLP
- Instrumenter ses applications
- Traces avec Alloy
- TP : Instrumenter une application Python avec OpenTelemetry
- TraceQL
- TP : Diagnostiquer avec TraceQL
- Métriques à partir des traces
- Corréler traces, logs, métriques et profils
- TP : Métriques RED et service graph avec le metrics-generator
- Stockage et passage à l'échelle
- Tempo en production
- TP Final : Une plateforme de tracing avec MinIO, échantillonnage et corrélation
- Bonnes pratiques Tempo
Grafana Loki : de la découverte à l'expertise
Explorer ↗
- Grafana Loki : de la découverte à l'expertise
- Qu'est-ce que Grafana Loki ?
- Loki ou Elasticsearch ?
- Installation de Loki
- TP : Déployer Loki et envoyer ses premiers logs
- Collecter les logs vers Loki
- Gestion des logs avec Alloy
- TP : Collecter les logs de conteneurs et de fichiers avec Alloy
- LogQL : requêter les logs
- LogQL : transformer les logs en métriques
- TP : Maîtriser LogQL
- Stockage, index TSDB et rétention
- Le Ruler de Loki
- TP : Alerter sur les logs avec le Ruler
- Exploiter Loki en production
- TP Final : Plateforme de logs avec MinIO, rétention et multi-tenant
- Bonnes pratiques Loki
Thanos : de la découverte à l'expertise
Explorer ↗
- Thanos : de la découverte à l'expertise
- Pourquoi Thanos ?
- Prometheus, VictoriaMetrics et Thanos
- Thanos, Mimir ou VictoriaMetrics ?
- Thanos Sidecar
- TP : Prometheus + Thanos Sidecar + MinIO
- Thanos Query et Query Frontend
- TP : Haute disponibilité avec deux Prometheus et Thanos Query
- Store Gateway et Compactor
- TP : Store Gateway, Compactor et downsampling
- Thanos Ruler
- Thanos Receive
- TP : Règles globales avec le Ruler et réception en remote write
- Déployer Thanos sur Kubernetes
- Exploiter Thanos
- TP Final : Thanos sur Kubernetes
- Bonnes pratiques Thanos
Grafana Mimir : de la découverte à l'expertise
Explorer ↗
- Grafana Mimir : de la découverte à l'expertise
- Pourquoi Grafana Mimir ?
- Le chemin d'écriture
- TP : Mimir monolithique avec MinIO, Prometheus et Grafana
- TP : Dédupliquer deux Prometheus en haute disponibilité
- Le chemin de lecture
- Compactor, rétention et stockage objet
- Multi-tenant et limites
- TP : Tenants, limites et configuration d'exécution
- Ruler, Alertmanager et mimirtool
- TP : Règles et alertes avec le ruler et mimirtool
- Déployer et exploiter Mimir sur Kubernetes
- TP Final : Mimir sur Kubernetes avec Helm
- Bonnes pratiques Grafana Mimir
Grafana Pyroscope : de la découverte à l'expertise
Explorer ↗
- Grafana Pyroscope : de la découverte à l'expertise
- Le profiling continu
- Architecture et déploiement de Pyroscope
- Instrumenter ses applications
- TP : Profiler une application Go avec le SDK Pyroscope
- TP : Profiler tous les conteneurs d'un hôte avec Alloy et eBPF
- Analyser les profils dans Grafana
- TP : Diagnostiquer et valider une optimisation avec la comparaison
- Relier traces et profils
- TP : Des traces aux profils avec Tempo et les span profiles
- Pyroscope sur Kubernetes
- TP Final : Profiling continu d'un cluster Kubernetes
- Bonnes pratiques Pyroscope
Alertmanager et gestion des alertes : de la découverte à l'expertise
Explorer ↗
- Alertmanager et gestion des alertes : de la découverte à l'expertise
- Alertmanager : rôle et cycle de vie
- TP : Première chaîne d'alerte Prometheus, Alertmanager et e-mail
- Écrire de bonnes règles d'alerte
- Routage, regroupement et récepteurs
- TP : Routage par équipe, regroupement et inhibition
- Silences, inhibitions et intervalles
- TP : Tests unitaires de règles et silences de maintenance
- Haute disponibilité et exploitation
- TP : Alertmanager hautement disponible et Watchdog
- Grafana Alerting et astreintes
- TP Final : Alerting Grafana provisionné en YAML
- Bonnes pratiques d'alerting
SRE en pratique : SLI, SLO et budgets d'erreur
Explorer ↗
- SRE en pratique : SLI, SLO et budgets d'erreur
- SLI, SLO et SLA
- Le budget d'erreur
- Mesurer des SLI avec Prometheus
- TP : Définir un SLI et calculer un budget d'erreur
- Alertes sur le burn rate
- Générer ses SLO avec Sloth
- TP : Générer SLO et alertes burn rate avec Sloth
- Piloter ses SLO avec Pyrra
- TP : Suivre ses SLO dans l'interface de Pyrra
- Bonnes pratiques SRE
- TP Final : Politique de budget d'erreur et revue de SLO
- Chaos engineering : principes, outils et mise en pratique
- SRE Practitioner
Observabilité avec eBPF : de la découverte à l'expertise
Explorer ↗
- Observabilité avec eBPF : de la découverte à l'expertise
- eBPF expliqué
- Diagnostiquer avec bpftrace et bcc
- TP : Diagnostiquer un serveur Linux avec bpftrace
- Instrumenter sans code avec Beyla
- TP : Métriques RED et traces sans code avec Beyla
- Observer le réseau avec Hubble
- TP : Flux réseau Kubernetes avec Cilium et Hubble
- Profiling continu avec eBPF
- TP : Profiler tout un hôte avec Parca
- eBPF en production
- Bonnes pratiques eBPF
- CCA
Grafana k6 : tests de charge et de performance
Explorer ↗
- Grafana k6 : tests de charge et de performance
- Pourquoi tester la charge ?
- Écrire des scripts k6
- TP : Premier test k6 avec vérifications et seuils
- Seuils, métriques et résultats
- TP : Scénarios, débit constant et test de stress
- Observer un test k6
- TP : Résultats k6 dans Prometheus et Grafana
- Navigateur et monitoring synthétique
- TP : Test navigateur et Core Web Vitals
- k6 en CI et sur Kubernetes
- TP Final : Test de performance bloquant en intégration continue
- Bonnes pratiques k6
Grafana Faro : observabilité front-end et RUM
Explorer ↗
- Grafana Faro : observabilité front-end et RUM
- RUM et Core Web Vitals
- Architecture et installation de Faro
- TP : Collecter les Web Vitals d'une page avec Faro, Alloy et Loki
- Erreurs, événements et sessions
- TP : Erreurs, événements métier et sessions
- Traces du navigateur vers le back-end
- TP : Propager les traces du navigateur vers une API
- Exploiter les données Faro
- TP Final : Dashboard d'expérience utilisateur et alerte
- Étude de cas : le RUM de ce site
- Bonnes pratiques Faro
Fluent Bit : de la découverte à l'expertise
Explorer ↗
- Fluent Bit : de la découverte à l'expertise
- Panorama des collecteurs de logs
- Fluent Bit : pipeline et configuration
- Les inputs (entrées) en détail
- Parsers et filters en détail
- Les outputs (sorties) en détail
- TP : Premier pipeline Fluent Bit vers Loki
- Fluent Bit sur Kubernetes
- TP : Fluent Bit sur Kubernetes avec métadonnées
- Fluent Bit ou Vector ?
- Bonnes pratiques de collecte
Kibana et Elastic Observability : de la découverte à l'expertise
Explorer ↗
- Kibana et Elastic Observability : de la découverte à l'expertise
- Kibana : rôle et installation
- TP : Installer Kibana et explorer des logs avec KQL
- Discover, KQL et ES|QL
- TP : Analyser avec ES|QL
- Lens, dashboards et objets enregistrés
- TP : Dashboard Lens versionné
- Elastic Observability
- Alertes, connecteurs et SLO
- TP : Règle d'alerte ES|QL et connecteur
- Administrer Kibana
- TP Final : Espaces et rôles pour deux équipes
- Bonnes pratiques Kibana
- Elastic Observability Engineer
- Elastic Certified Analyst
- Elastic SIEM Analyst
VictoriaMetrics : de la découverte à l'expertise
Explorer ↗
- VictoriaMetrics : de la découverte à l'expertise
- Pourquoi VictoriaMetrics ?
- TP : VictoriaMetrics single-node avec Prometheus et Grafana
- Ingérer des métriques
- TP : vmagent, tampon disque et panne du stockage
- MetricsQL
- TP : Exercices MetricsQL et cardinalité
- VictoriaMetrics en cluster
- TP : Cluster VictoriaMetrics multi-tenant
- Exploiter VictoriaMetrics
- TP Final : Alertes avec vmalert et Alertmanager
- Thanos, Mimir ou VictoriaMetrics ?
- Bonnes pratiques VictoriaMetrics
Jaeger : tracing distribué de la découverte à l'expertise
Explorer ↗
- Jaeger : tracing distribué de la découverte à l'expertise
- Le tracing distribué avec Jaeger
- Installer Jaeger v2
- TP : Jaeger all-in-one et diagnostic avec HotROD
- Instrumenter avec OpenTelemetry
- TP : Instrumenter une application Python vers Jaeger
- Analyser des traces dans Jaeger
- TP : Monitoring de performance des services (SPM)
- Jaeger en production
- TP Final : Jaeger sur Elasticsearch avec tail sampling
- Tempo ou Jaeger ?
- Bonnes pratiques Jaeger
SigNoz : de la découverte à l'expertise
Zabbix : supervision d'infrastructure de la découverte à l'expertise
Explorer ↗
- Zabbix : supervision d'infrastructure de la découverte à l'expertise
- Zabbix : architecture et concepts
- Installer Zabbix
- TP : Installer Zabbix et superviser un premier hôte
- Collecter avec Zabbix
- TP : Modèle maison, éléments, déclencheurs et découverte
- TP : Collecter des métriques Prometheus avec Zabbix
- Déclencheurs et notifications
- TP : Notifications par webhook, escalade et maintenance
- Dashboards, Grafana et API
- Créer des tableaux de bord dans Zabbix
- Tableaux de bord Grafana avec la source Zabbix
- Zabbix en production
- TP Final : Automatiser Zabbix avec l'API et l'afficher dans Grafana
- Bonnes pratiques Zabbix
- ZCU
- ZCS
Datadog : de la découverte à l'expertise
Explorer ↗
- Datadog : de la découverte à l'expertise
- Datadog en un coup d'œil
- Architecture de la plateforme Datadog
- Agent et intégrations
- TP : Installer l'agent Datadog et activer une intégration
- Datadog sur Kubernetes
- TP : Superviser un cluster Kubernetes avec le Datadog Operator
- Métriques et tags
- Métriques avancées et cardinalité
- TP : Métriques personnalisées avec DogStatsD et dashboard
- Dashboards et notebooks
- Logs dans Datadog
- Logs avancés : index, Flex et archives
- TP : Pipeline de logs, facettes et maîtrise du volume
- APM et OpenTelemetry
- APM avancé : échantillonnage et profiler
- TP : APM Python et corrélation logs-traces
- RUM et Synthetic Monitoring
- TP : Tests Synthetics en Terraform et en CI
- Réseau, cloud et bases de données
- La sécurité avec Datadog
- Monitors, SLO et Terraform
- Incidents et automatisation
- TP Final : Monitors et SLO en Terraform
- Coûts et gouvernance
- Bonnes pratiques Datadog
- Datadog Fundamentals
- Log Management Fundamentals
- APM & Distributed Tracing Fundamentals
Bindplane : pipelines de télémétrie OpenTelemetry de la découverte à l'expertise
Explorer ↗
- Bindplane : pipelines de télémétrie OpenTelemetry de la découverte à l'expertise
- Bindplane : gérer ses pipelines de télémétrie
- OpenTelemetry Collector, Grafana Alloy et Bindplane
- Installer Bindplane
- TP : Installer Bindplane et connecter un premier collecteur
- Configurations Bindplane
- TP : Construire un pipeline de logs et observer les données
- Réduire, masquer et router
- TP : Réduire et masquer les logs, puis mesurer le gain
- Fleets, gateways et rollouts
- TP : Rollout par lots, erreur et retour arrière
- Bindplane en production
- TP Final : Pipeline de production géré comme du code
- Bonnes pratiques Bindplane
Arize AI : observabilité et évaluation des LLM de la découverte à l'expertise
Explorer ↗
- Arize AI : observabilité et évaluation des LLM de la découverte à l'expertise
- Arize AI : observabilité et évaluation des LLM
- OpenInference : tracer les applications d'IA
- Installer Phoenix et tracer une application
- TP : Installer Phoenix et tracer une première application LLM
- Tracer un RAG et un agent
- TP : Tracer un RAG et des sessions
- Évaluer avec des LLM juges
- TP : Évaluer les réponses avec du code et un LLM juge
- Datasets, expériences et prompts
- TP : Comparer deux prompts par une expérience
- Arize en production
- TP Final : Observabilité LLM de production avec Phoenix
- Bonnes pratiques Arize et OpenInference
Administration Linux : de la découverte à l'expertise
Explorer ↗
- Administration Linux : de la découverte à l'expertise
- Linux et Unix : distributions et commandes essentielles
- Architecture d'un système Linux
- Le shell Bash et les fichiers
- TP : Analyser des journaux en ligne de commande
- Utilisateurs, groupes, sudo et permissions
- TP : Comptes, dossier d'équipe, sudo et ACL
- Paquets, services systemd et journaux
- TP : Créer et piloter un service systemd
- Disques, systèmes de fichiers et LVM
- TP : LVM, fstab et extension à chaud
- Réseau, pare-feu et SSH
- TP : Diagnostic réseau, SSH par clé et pare-feu
- Processus, mémoire et performance
- Sécurité et durcissement
- Scripts Bash robustes
- TP : Un script de sauvegarde robuste et planifié
- Sauvegarde, supervision et dépannage
- TP Final : Préparer un serveur pour la production et résoudre un incident
- Bonnes pratiques Linux
- LFCS
- RHCSA
Vector : de la découverte à l'expertise
Explorer ↗
- Vector : de la découverte à l'expertise
- Panorama des collecteurs de logs
- Vector : topologie et composants
- Les sources en détail
- Les transforms en détail
- Les sinks en détail
- VRL et tests unitaires
- TP : Analyser des logs nginx avec Vector et VRL
- TP Final : Tests unitaires Vector et masquage des données personnelles
- Fluent Bit ou Vector ?
- Bonnes pratiques de collecte
ClickStack : de la découverte à l'expertise
AWS : de la découverte à l'expertise
Explorer ↗
- AWS : de la découverte à l'expertise
- Comprendre AWS : infrastructure, comptes, outils et tarifs
- IAM : identités, rôles et politiques
- Le réseau : VPC, sous-réseaux, routage et sécurité
- Le calcul : EC2, Auto Scaling, Lambda et conteneurs
- Le stockage : S3, EBS, EFS et sauvegarde
- Les bases de données : RDS, Aurora, DynamoDB
- Superviser et sécuriser : CloudWatch, CloudTrail, KMS, GuardDuty
- Observabilité AWS : CloudWatch, X-Ray, ADOT, Prometheus et Grafana
- Infrastructure as Code et Well-Architected
- Maîtriser ses coûts AWS
- TP : Stockage S3 avec LocalStack
- TP : Une API serverless (API Gateway, Lambda, DynamoDB) sur LocalStack
- TP : Infrastructure as Code et découplage avec SQS et SNS (Terraform sur LocalStack)
- Bonnes pratiques AWS
- Guide de préparation : Cloud Practitioner (CLF-C02)
- AWS Certified Cloud Practitioner (CLF-C02)
- Guide de préparation : Solutions Architect Associate (SAA-C03)
- AWS Certified Solutions Architect – Associate (SAA-C03)
Microsoft Azure : de la découverte à l'expertise
Explorer ↗
- Microsoft Azure : de la découverte à l'expertise
- Comprendre Azure : régions, hiérarchie, outils et tarifs
- Entra ID, RBAC et Azure Policy
- Le réseau Azure
- Le calcul : VM, App Service, Functions et conteneurs
- Le stockage Azure
- Les bases de données Azure
- Superviser et protéger Azure
- Observabilité Azure : Azure Monitor, Log Analytics, Application Insights
- Bicep, Terraform et maîtrise des coûts
- TP : Blob et Queue Storage avec Azurite
- TP : Une Azure Function déclenchée par une file, en local
- TP : Infrastructure as Code avec Bicep (validation locale et what-if)
- Bonnes pratiques Azure
- Guide de préparation : AZ-900
- Microsoft Azure Fundamentals (AZ-900)
- Guide de préparation : AZ-104
- Microsoft Azure Administrator Associate (AZ-104)
Google Cloud : de la découverte à l'expertise
Explorer ↗
- Google Cloud : de la découverte à l'expertise
- Comprendre Google Cloud
- IAM sur Google Cloud
- Le réseau Google Cloud
- Le calcul sur Google Cloud
- Le stockage Google Cloud
- Les bases de données Google Cloud
- Exploiter Google Cloud
- Observabilité Google Cloud : Monitoring, Logging, Trace, Profiler
- TP : Messagerie avec l'émulateur Pub/Sub
- TP : Une API sur le Functions Framework avec l'émulateur Firestore
- TP : Cloud Storage en local avec fake-gcs-server
- Bonnes pratiques Google Cloud
- Guide de préparation : Cloud Digital Leader
- Google Cloud Digital Leader
- Guide de préparation : Associate Cloud Engineer
- Google Associate Cloud Engineer
OVHcloud : de la découverte à l'expertise
Explorer ↗
- OVHcloud : de la découverte à l'expertise
- Comprendre OVHcloud
- Identités et accès
- Le réseau Public Cloud
- Instances et Managed Kubernetes
- Le stockage OVHcloud
- Les bases de données managées
- Exploiter OVHcloud
- TP : Object Storage compatible S3 simulé avec MinIO
- TP : Le parcours Managed Kubernetes simulé avec k3d
- TP : Terraform pour OVHcloud testé avec des fournisseurs simulés
- Bonnes pratiques OVHcloud
Terraform : de la découverte à l'expertise
Explorer ↗
- Terraform : de la découverte à l'expertise
- Principes, architecture et flux de travail
- Le langage HCL
- L'état : backends, verrouillage, import
- Les modules
- Environnements et organisation
- Tester et sécuriser
- Terraform en CI/CD
- Terraform sur plusieurs clouds
- TP : Premiers pas avec Terraform sur LocalStack
- TP : État distant, verrouillage, import et refactorisation
- TP : Un module testé (terraform test, tflint, Checkov)
- Bonnes pratiques Terraform
- Guide de préparation : Terraform Associate
- HashiCorp Certified: Terraform Associate (004)
Articles
- Comprendre la notion de score ↗
- Elastic Common Schema (ECS) : le format standard des données Elastic et son rôle dans Elastic SIEM ↗
- Grail : Dynatrace Data Lakehouse ↗
- C'est quoi l'observabilité ↗
- Arrêtez de passer au Cloud, au micro-service... ↗
- Mur de la confusion ↗
- Soutien Logistique Intégré ↗
- CaaS état de l'art et bonnes pratiques ↗
- Les types de transactions dans les base de données ↗
- Différences entre Technologies et Services dans Dynatrace ↗
- Dynatrace : Différences entre SQL Modifications, SQL Queries or Procedures, et SQL Transactions ↗
- Licences Dynatrace : modèle par unités et consumption-based licensing (DPS) ↗
- Les Types de Services Dynatrace : Comprendre et Optimiser Votre Surveillance Applicative ↗
- Les SLO Dynatrace : Comprendre et Gérer les Objectifs de Niveau de Service ↗
- Apdex vs Core Web Vitals ↗
- Bonnes Pratiques Kubernetes ↗
- Comparaison Offres Kubernetes ↗
- Application 12 Facteurs ↗
- Stratégies de placement Kubernetes ↗
- CNI Kubernetes : Flannel, Calico et Cilium comparés ↗
- Gestionnaires de packages ↗
- Gestionnaires de déploiement ↗
- Jobs vs Serverless ↗
- PersistentVolume, PersistentVolumeClaim et StorageClass dans Kubernetes ↗
- Pourquoi collecter des métriques ↗
- Resource Quota Kubernetes ↗
- ConfigMaps et Secrets ↗
- Services Kubernetes : ClusterIP, NodePort, LoadBalancer et ExternalName ↗
- Les types de métriques dans Prometheus ↗
- PromQL : introduction au langage de requête de Prometheus ↗
- Dynatrace OneAgent : tags, props, vars CLI ↗
- Grafana Alloy : Collecte et Transformation de Télémétrie ↗
- Grafana Alloy : Collecter les métriques système et les logs locaux ↗
- Grafana Alloy : L'importance de l'auto-supervision (Self-Monitoring) ↗
- Grafana Alloy : Comprendre et exploiter l'Interface Utilisateur (UI) ↗
- OTLP expliqué : comprendre le protocole OpenTelemetry ↗
- Grafana Alloy : Guide complet pour collecter métriques, logs et traces ↗
- Configuration de Grafana Alloy : syntaxe, ports et premiers composants ↗
- Grafana Alloy et Prometheus : collecter et envoyer des métriques ↗
- Grafana Alloy et les logs : collecter et envoyer vers Loki ↗
- Grafana Alloy et les traces : OTLP, Jaeger et Zipkin vers Tempo ↗
- Grafana Alloy : Profilage Continu avec Pyroscope ↗
- Grafana Alloy : Déploiement Avancé et Clustering ↗
- Grafana Assistant : L'IA au service de l'observabilité ↗
- Grafana Alloy vs OpenTelemetry Collector : Lequel choisir ? ↗
- Grafana Alloy vs Dynatrace ActiveGate : Lequel choisir ? ↗
- Grafana Alloy vs Grafana Agent vs Promtail : Lequel choisir ? ↗
- Référence des Composants Grafana Alloy ↗
- Dynatrace : Maîtriser les Entity Selectors pour une observabilité à grande échelle ↗
- Dynatrace : Gestion du RGPD et protection de la vie privée (Data Privacy) ↗
- Dynatrace Synthetic Monitoring : Guide complet et bonnes pratiques ↗
- Dynatrace Credential Vault : Sécuriser et gérer vos secrets ↗
- Le framework CALMS : Les 5 piliers du DevOps ↗
- Les variantes du DevOps : Comprendre l'évolution de la culture de l'ingénierie ↗
- Dynatrace vs Datadog : Le duel des leaders de l'APM ↗
- Grafana vs Kibana : Quel outil de visualisation choisir ? ↗
- Grafana Loki vs Elasticsearch : La bataille du stockage de logs ↗
- Prometheus vs VictoriaMetrics : Scalabilité des métriques ↗
- OpenTelemetry vs Dynatrace OneAgent : Standard ouvert ou magie propriétaire ? ↗
- XLA : Pourquoi l'Expérience Utilisateur est le nouveau standard de l'Observabilité ↗
- Dynatrace : Management Zones vs Segments ↗
- Exploiter l'API Dynatrace v2 : Guide Complet de l'Automatisation ↗
- Le Load Balancing : Principes, Algorithmes et Cas d'usage ↗
- Anatomie de la configuration HAProxy, Clustering et Haute Disponibilité ↗
- Maîtriser les ACLs dans HAProxy ↗
- HAProxy et SSL : terminaison TLS, SSL passthrough et sécurisation ↗
- Monitoring et Statistiques dans HAProxy ↗
- Persistance de session (Stickiness) ↗
- Health Checks et Haute Disponibilité ↗
- Installation de HAProxy ↗
- L'écosystème HAProxy : Open Source, Enterprise, HAProxy Fusion, Edge et HAProxy One ↗
- Qu'est-ce que le Cloud Computing ? La définition du NIST ↗
- IaaS, PaaS, SaaS : différences et exemples des modèles de service cloud ↗
- Cloud Public, Privé ou Hybride : Quel déploiement choisir ? ↗
- Le modèle de responsabilité partagée en sécurité ↗
- Élasticité vs Scalabilité : Les clés de la performance ↗
- Introduction au FinOps : Maîtriser sa facture Cloud ↗
- Informatique serverless : définition, FaaS et cas d'usage ↗
- Edge computing : définition, solutions et datacenters modulaires ↗
- Cloud native : définition et principes d'une application cloud native ↗
- Les 6 Rs : Stratégies de migration vers le Cloud ↗
- Synthetic Monitoring as Code : Industrialisez la gestion des scénarios synthétiques ↗
- Grafana Provisioning : Automatisez la gestion de vos tableaux de bord et sources de données ↗
- Les Data Sources dans Grafana : Connectez et unifiez vos données ↗
- Maîtriser les Transformations dans Grafana : Manipulez vos données avec agilité ↗
- Maîtriser les Variables dans Grafana : Dynamisez vos Tableaux de Bord ↗
- Bonnes Pratiques HAProxy : Optimisation, Sécurité et Haute Disponibilité ↗
- Guide des Bonnes Pratiques Dynatrace : Vers une Observabilité Mature ↗
- Bonnes Pratiques OpenTelemetry (OTel) : Le Guide de l'Observabilité Moderne ↗
- Protection des Applications ↗
- Haute Disponibilité ↗
- Bonnes Pratiques Grafana Alloy : Optimiser sa Collecte de Télémétrie ↗
- Architecture OpenTelemetry : Comprendre les 3 niveaux ↗
- Aide-mémoire HAProxy : Les commandes essentielles ↗
- Aide-mémoire Docker : Les commandes essentielles ↗
- HAProxy : Ajout et suppression dynamique de backends ↗
- Protocole ACME : serveur ACME, challenges http-01 et dns-01, automatisation TLS ↗
- HAProxy : Guide détaillé des directives de configuration ↗
- Visualiser votre infrastructure avec HAProxy Topology Visualizer ↗
- HAProxy dans Kubernetes : L'Ingress Controller Haute Performance ↗
- Gestion des certificats SSL/TLS avec Let's Encrypt et ACME ↗
- Maîtriser les ACLs dans HAProxy : Le Guide Complet ↗
- HAProxy comme Ingress Controller Kubernetes : Le Guide de Production ↗
- Nouveautés HAProxy : OpenTelemetry, JWT Natif, et Optimisations de Performance ↗
- OpenTelemetry : Instrumentation Automatique vs Manuelle ↗
- Linux vs Unix : Le Guide Complet des Commandes et Distributions ↗
- Ansible : l'inventaire (statique, dynamique, groupes et variables) ↗
- Ansible : les commandes Ad-Hoc ↗
- Ansible : structurer son code avec les rôles ↗
- Ansible : générer des fichiers dynamiques avec Jinja2 et les facts ↗
- Ansible : gérer la sécurité (Vault, SSH, privilèges et secrets) ↗
- Ansible : gérer son infrastructure avec des playbooks (Infrastructure as Code) ↗
- Ansible : piloter ses automatisations avec une interface graphique (AWX, Semaphore, AAP) ↗
- Ansible : aller plus loin (tests, qualité, CI/CD et performance) ↗
- Prometheus : alerter avec Alertmanager (règles, routage, silences) ↗
- Prometheus : visualiser ses métriques (UI, Grafana et dashboards) ↗
- Prometheus dans le monde Kubernetes (Operator, ServiceMonitor, kube-prometheus-stack) ↗
- Les modèles de déploiement Cloud : public, privé, hybride, communautaire et multi-cloud ↗
- Grafana : maîtriser les requêtes (PromQL, LogQL, SQL et expressions) ↗
- Grafana Cloud : démarrer avec la plateforme managée (Mimir, Loki, Tempo, Alloy) ↗
- Kubernetes : architecture et composants (control plane, nœuds, objets) ↗
- Aide-mémoire kubectl : les commandes essentielles ↗
- Kubernetes : Pods, ReplicaSets et Deployments (déployer et mettre à jour) ↗
- Kubernetes : exposer ses applications (Services, Ingress et Gateway API) ↗
- Sécuriser Kubernetes : RBAC, NetworkPolicies, sécurité réseau des conteneurs et Pod Security ↗
- Kubernetes : fiabilité et mise à l'échelle (probes, ressources, HPA, PDB) ↗
- OpenTelemetry Collector : les Processors (transformer, filtrer et protéger la télémétrie) ↗
- OpenTelemetry Collector : les Exporters (envoyer la télémétrie vers les backends) ↗
- Tracing distribué : la propagation du contexte (W3C Trace Context et baggage) ↗
- Docker : vue d'ensemble, architecture et premiers pas ↗
- Traefik : vue d'ensemble, architecture et premier déploiement ↗
- Beats : aller plus loin (sécurité, performances, Elastic Agent et migration vers Alloy) ↗
- Dynatrace : gérer les permissions (IAM, groupes, politiques et périmètres) ↗
- Grafana Tempo : le backend de traces distribuées à grande échelle ↗
- Installer Grafana Tempo (Docker Compose, binaire et Helm) ↗
- Envoyer des traces vers Tempo : instrumentation OpenTelemetry et Alloy ↗
- TraceQL : le langage de requête des traces ↗
- Tempo : générer des métriques à partir des traces (service graph, span metrics, exemplars) ↗
- Corréler traces, logs, métriques et profils dans Grafana ↗
- Tempo : stockage objet, blocs, compactor et déploiement distribué ↗
- Tempo en production : échantillonnage, limites et supervision ↗
- Grafana Loki : le système de logs inspiré de Prometheus ↗
- Installer Grafana Loki (Docker Compose, binaire et Helm) ↗
- Collecter des logs vers Loki : Alloy, Promtail, Docker et OpenTelemetry ↗
- LogQL (1/2) : requêter les logs (sélecteurs, filtres et parsers) ↗
- LogQL (2/2) : transformer les logs en métriques ↗
- Loki : stockage, index TSDB, rétention et stockage objet ↗
- Alerter sur les logs avec le Ruler de Loki ↗
- Exploiter Loki en production : multi-tenant, limites, cardinalité et supervision ↗
- Thanos : étendre Prometheus (haute disponibilité, vue globale et rétention longue) ↗
- Thanos Sidecar : accoler Thanos à Prometheus et téléverser vers le stockage objet ↗
- Thanos Query et Query Frontend : une vue globale et dédupliquée ↗
- Thanos Store Gateway et Compactor : historique, downsampling et rétention ↗
- Thanos Ruler : règles et alertes sur la vue globale ↗
- Thanos Receive : ingérer du remote write et gérer le multi-tenant ↗
- Déployer Thanos sur Kubernetes (kube-prometheus-stack, Helm et Operator) ↗
- Exploiter Thanos : supervision, performances, dépannage et alternatives ↗
- Bonnes pratiques Docker : images, exécution, sécurité et exploitation ↗
- Bonnes pratiques Vagrant : des environnements reproductibles et rapides ↗
- Bonnes pratiques Traefik : sécurité, haute disponibilité et observabilité ↗
- Bonnes pratiques Ansible : structure, idempotence, sécurité et qualité ↗
- Bonnes pratiques Elasticsearch : mappings, shards, cycle de vie et exploitation ↗
- Bonnes pratiques Logstash : pipelines, performances, fiabilité et supervision ↗
- Bonnes pratiques Prometheus : métriques, cardinalité, règles et exploitation ↗
- Bonnes pratiques Cloud : sécurité, résilience, coûts et exploitation ↗
- Bonnes pratiques Grafana : dashboards, provisioning, performances et sécurité ↗
- Bonnes pratiques Beats : Filebeat, Metricbeat et collecte fiable ↗
- Bonnes pratiques DevOps : culture, CI/CD, infrastructure as code et mesure ↗
- Bonnes pratiques Grafana Tempo : instrumentation, échantillonnage, requêtes et coûts ↗
- Bonnes pratiques Grafana Loki : labels, requêtes, stockage et coûts ↗
- Bonnes pratiques Thanos : architecture, stockage, requêtes et exploitation ↗
- Pourquoi Grafana Mimir ? Architecture et modes de déploiement ↗
- Mimir : le chemin d'écriture (distributor, ingesters, réplication et déduplication HA) ↗
- Mimir : le chemin de lecture (query-frontend, querier, store-gateway et caches) ↗
- Mimir : compactor, rétention et stockage objet ↗
- Mimir : multi-tenant, limites et configuration d'exécution ↗
- Mimir : ruler, Alertmanager et mimirtool ↗
- Déployer et exploiter Mimir sur Kubernetes ↗
- Bonnes pratiques Grafana Mimir : architecture, limites, coûts et exploitation ↗
- Le profiling continu avec Grafana Pyroscope : pourquoi et comment ↗
- Architecture et déploiement de Grafana Pyroscope ↗
- Instrumenter ses applications pour Pyroscope : SDK, Alloy et eBPF ↗
- Analyser les profils dans Grafana : flame graphs, comparaisons et diagnostics ↗
- Relier traces et profils : span profiles avec Tempo et Pyroscope ↗
- Déployer et exploiter Pyroscope sur Kubernetes ↗
- Bonnes pratiques Grafana Pyroscope : collecte, labels, analyse et coûts ↗
- Alertmanager : rôle, architecture et cycle de vie d'une alerte ↗
- Écrire de bonnes règles d'alerte Prometheus (et les tester) ↗
- Routage, regroupement et récepteurs dans Alertmanager ↗
- Silences, inhibitions et intervalles de temps dans Alertmanager ↗
- Haute disponibilité et exploitation d'Alertmanager ↗
- Grafana Alerting et gestion des astreintes ↗
- Bonnes pratiques d'alerting : Prometheus, Alertmanager et astreinte ↗
- SRE : SLI, SLO et SLA expliqués simplement ↗
- Le budget d'erreur : décider avec les SLO ↗
- Mesurer des SLI avec Prometheus ↗
- Alertes sur le taux de consommation du budget (burn rate multi-fenêtres) ↗
- Générer ses SLO Prometheus avec Sloth ↗
- Piloter ses SLO avec Pyrra ↗
- Bonnes pratiques SRE : SLO utiles et budgets respectés ↗
- eBPF expliqué : des programmes dans le noyau Linux pour observer sans instrumenter ↗
- Diagnostiquer avec bpftrace et les outils bcc ↗
- Instrumenter sans code avec Grafana Beyla (OpenTelemetry eBPF Instrumentation) ↗
- Observer le réseau Kubernetes avec Cilium Hubble ↗
- Profiling continu avec eBPF : Parca, Pyroscope et le profiler OpenTelemetry ↗
- eBPF en production : sécurité, prérequis et limites ↗
- Bonnes pratiques eBPF pour l'observabilité ↗
- Tests de charge avec Grafana k6 : pourquoi et quels types de tests ↗
- Écrire des scripts k6 : requêtes, vérifications, scénarios et exécuteurs ↗
- Seuils, métriques et résultats d'un test k6 ↗
- Observer un test k6 : Prometheus, Grafana et corrélation avec le système testé ↗
- Tests navigateur et monitoring synthétique avec k6 ↗
- k6 en intégration continue et sur Kubernetes (k6-operator) ↗
- Bonnes pratiques des tests de performance avec k6 ↗
- Real User Monitoring (RUM) et Core Web Vitals : mesurer ce que vivent les utilisateurs ↗
- Grafana Faro : architecture et installation ↗
- Faro : erreurs JavaScript, logs, événements métier et sessions ↗
- Du clic à la base de données : traces front-end vers back-end avec Faro ↗
- Exploiter les données Faro : requêtes, dashboards, alertes et RGPD ↗
- Étude de cas : le RUM minimal de ce site, sans cookie, exposé à Prometheus ↗
- Bonnes pratiques de l'observabilité front-end avec Faro ↗
- Collecteurs de logs légers : Fluent Bit, Vector et les autres ↗
- Fluent Bit : pipeline, configuration et plugins essentiels ↗
- Fluent Bit sur Kubernetes : DaemonSet, multiline, tampon et supervision ↗
- Vector : sources, transforms, sinks et topologie ↗
- Transformer avec VRL et tester ses pipelines Vector ↗
- Fluent Bit ou Vector ? Choisir, combiner et migrer ↗
- Bonnes pratiques de collecte de logs avec Fluent Bit et Vector ↗
- Kibana : rôle, installation et premiers pas ↗
- Explorer ses données dans Discover : KQL, Lucene et ES|QL ↗
- Visualiser dans Kibana : Lens, dashboards et objets enregistrés ↗
- Elastic Observability : logs, infrastructure, APM et synthétiques ↗
- Alertes, connecteurs et SLO dans Kibana ↗
- Administrer Kibana : espaces, rôles, utilisateurs et supervision ↗
- Bonnes pratiques Kibana et Elastic Observability ↗
- VictoriaMetrics : pourquoi et comment, du nœud unique au cluster ↗
- Ingérer des métriques dans VictoriaMetrics : scraping, vmagent et remote write ↗
- MetricsQL : PromQL avec des super-pouvoirs ↗
- VictoriaMetrics en cluster : vminsert, vmselect, vmstorage et multi-tenant ↗
- Exploiter VictoriaMetrics : vmalert, sauvegardes, Kubernetes et supervision ↗
- Thanos, Grafana Mimir ou VictoriaMetrics : quel stockage long terme pour Prometheus ? ↗
- Bonnes pratiques VictoriaMetrics ↗
- Le tracing distribué avec Jaeger : concepts et architecture ↗
- Installer Jaeger v2 : all-in-one, configuration et stockages ↗
- Instrumenter ses applications pour Jaeger avec OpenTelemetry ↗
- Analyser des traces dans l'interface de Jaeger ↗
- Jaeger en production : échantillonnage, stockage, Kafka et Kubernetes ↗
- Grafana Tempo ou Jaeger : quel backend de traces choisir ? ↗
- Bonnes pratiques du tracing distribué avec Jaeger ↗
- L'observabilité sur ClickHouse : pourquoi une base colonne change la donne ↗
- SigNoz : architecture et installation ↗
- Utiliser SigNoz : APM, traces, logs, dashboards et alertes ↗
- ClickStack : ClickHouse, HyperDX et OpenTelemetry ↗
- Stocker et interroger la télémétrie directement dans ClickHouse ↗
- Exploiter une plateforme d'observabilité sur ClickHouse et choisir son outil ↗
- Bonnes pratiques SigNoz, ClickStack et ClickHouse pour l'observabilité ↗
- Zabbix : architecture et concepts de la supervision ↗
- Installer Zabbix et superviser son premier hôte ↗
- Collecter avec Zabbix : éléments, prétraitement, découverte et modèles ↗
- Déclencheurs, problèmes, actions et notifications dans Zabbix ↗
- Visualiser et automatiser Zabbix : dashboards, Grafana et API ↗
- Zabbix en production : proxies, performance, haute disponibilité et Prometheus ↗
- Bonnes pratiques Zabbix ↗
- Datadog : la plateforme d'observabilité SaaS en un coup d'œil ↗
- Installer l'agent Datadog et configurer les intégrations ↗
- Métriques et tags dans Datadog : tagging unifié, DogStatsD et cardinalité ↗
- Logs dans Datadog : collecte, pipelines, index et maîtrise du volume ↗
- APM Datadog et OpenTelemetry : traces, services et corrélation avec les logs ↗
- Monitors, SLO, dashboards et Datadog as code ↗
- Bonnes pratiques Datadog : tags, coûts, alertes et gouvernance ↗
- Projet fil rouge : les quatre signaux de l'OpenTelemetry Demo dans la stack Grafana ↗
- Dynatrace : définitions, architecture et intelligence artificielle Davis ↗
- Dynatrace SaaS vs Managed : choisir, organiser cluster et environnements ↗
- OneAgent : méthodes de collecte, installation, Kubernetes et santé ↗
- Configuration as Code avec Monaco : tokens, OAuth, projets et CI/CD ↗
- Release monitoring dans Dynatrace : versions, événements de déploiement et suivi des incidents ↗
- Real User Monitoring Dynatrace : injection, applications web et vérification ↗
- Analyser l'expérience utilisateur dans Dynatrace : sessions, traces, analyses et USQL ↗
- Métriques Dynatrace : Data Explorer, sélecteurs de métriques, API et tableaux de bord ↗
- Gestion des problèmes dans Dynatrace : Davis, page problème, notifications et auto-remédiation ↗
- Paramètres essentiels de Dynatrace : propriétaires, maintenances, nommage, requêtes clés et tags ↗
- Les applications Dynatrace : Smartscape, conteneurs, Kubernetes, fonctions cloud et réseau ↗
- DQL en pratique : explorer logs et événements, notebooks, tableaux de bord et performance ↗
- La rétention des données dans Dynatrace : Grail, buckets et durées par type de données ↗
- Créer des tableaux de bord dans Zabbix : dashboards, widgets et pages ↗
- Tableaux de bord Grafana avec la source de données Zabbix ↗
- Bindplane : gérer ses pipelines de télémétrie OpenTelemetry ↗
- OpenTelemetry Collector, Grafana Alloy et Bindplane : comparer trois approches des pipelines de télémétrie ↗
- Installer Bindplane : serveur, BDOT Collector et connexion OpAMP ↗
- Configurations Bindplane : sources, processeurs, destinations et versions ↗
- Réduire, masquer et router la télémétrie avec Bindplane ↗
- Bindplane à l'échelle : fleets, gateways et rollouts ↗
- Bindplane en production : haute disponibilité, sécurité, Kubernetes et configuration as code ↗
- Bonnes pratiques Bindplane ↗
- Arize AI : observabilité et évaluation des applications LLM et des agents ↗
- OpenInference : les conventions OpenTelemetry pour tracer les applications d'IA ↗
- Installer Phoenix et tracer sa première application LLM ↗
- Tracer un RAG et un agent avec OpenInference et Phoenix ↗
- Évaluer une application LLM avec Phoenix : LLM juges, code et annotations ↗
- Datasets, expériences et prompts avec Phoenix ↗
- Arize en production : Phoenix auto-hébergé, Arize AX, sécurité, coûts et monitoring ↗
- Bonnes pratiques Arize et OpenInference ↗
- Architecture de la plateforme Datadog : sites, organisations, clés et modèle de données ↗
- Datadog sur Kubernetes : Operator, Cluster Agent et Autodiscovery ↗
- Dashboards et notebooks Datadog : widgets, template variables et bonnes pratiques ↗
- Métriques Datadog avancées : types, agrégations, cardinalité et Metrics without Limits ↗
- Logs Datadog avancés : index, filtres d'exclusion, Flex Logs, archives et Sensitive Data Scanner ↗
- APM Datadog avancé : échantillonnage, rétention, profiler et Software Catalog ↗
- RUM et Synthetic Monitoring avec Datadog : synthetic transaction monitoring et expérience utilisateur ↗
- Infrastructure avancée avec Datadog : réseau, cloud, conteneurs et bases de données ↗
- Sécurité avec Datadog : Cloud SIEM, Cloud Security et protection des applications ↗
- Incidents et automatisation avec Datadog : On-Call, Incident Management et Workflow Automation ↗
- Coûts et gouvernance Datadog : usage, attribution, RBAC et politiques de tags ↗
- ActiveGate et network zones : architecture, routage et haute disponibilité ↗
- Dynatrace Operator sur Kubernetes : DynaKube, modes de supervision et dépannage ↗
- OpenTelemetry et Dynatrace : OTLP, collecteur et instrumentation ↗
- Logs avancés avec OpenPipeline : traitement, masquage, buckets et rétention ↗
- Davis AI avancé : détection d'anomalies, IA causale, prédictive et générative ↗
- Workflows et AutomationEngine : automatiser notifications et remédiation ↗
- Segments et nouvelle plateforme : remplacer les management zones ↗
- Licensing et FinOps Dynatrace : rate cards, suivi de la consommation et budgets ↗
- AppEngine et applications personnalisées Dynatrace ↗
- Grail et DQL avancés : jointures, lookup, séries temporelles et optimisation ↗
- Cloud et infrastructure avec Dynatrace : AWS, Azure, GCP, Kubernetes et extensions 2.0 ↗
- Alerting avancé Dynatrace : événements de métrique, profils d'alerting et notifications ↗
- Business observability avec Dynatrace : événements métier, KPI et Business Flow ↗
- Sécurité et gouvernance Dynatrace : IAM avancé, politiques, SSO, audit et protection des données ↗
- Architecture distribuée Elasticsearch : rôles des nœuds, shards, répliques et allocation ↗
- Mappings et analyse de texte Elasticsearch : types de champs, analyseurs et mapping dynamique ↗
- Ingestion Elasticsearch : Bulk API, ingest pipelines, enrich et reindex ↗
- Index Lifecycle Management (ILM) : data tiers, rollover et rétention ↗
- Data streams et templates Elasticsearch : component templates, index templates et séries temporelles ↗
- Query DSL et agrégations avancées Elasticsearch, avec ES|QL ↗
- Monitoring et troubleshooting Elasticsearch : santé, shards non assignés, JVM, hot threads et slow logs ↗
- Performance et capacity planning Elasticsearch : shards, heap, indexation et benchmarks ↗
- Snapshot Lifecycle Management : sauvegardes automatisées, restauration et reprise après sinistre ↗
- Sécurité avancée Elasticsearch : TLS, certificats, clés d'API, FLS, DLS et audit ↗
- Kibana avancé : data views, Lens, dashboards, alerting et reporting ↗
- Elasticsearch sur Kubernetes avec ECK : déploiement, stockage persistant et mises à jour ↗
- Recherche vectorielle et RAG avec Elasticsearch : dense_vector, kNN, recherche hybride et RRF ↗
- Automatisation et infrastructure as code pour Elasticsearch : API, Terraform, Ansible et CI/CD ↗
- Cross-cluster search et cross-cluster replication : architectures multi-clusters Elasticsearch ↗
- Monitoring de site web : disponibilité, surveillance HTTPS, certificats et performances ↗
- La stack LGTM (Loki, Grafana, Tempo, Mimir) : architecture et mise en place ↗
- Sécurité réseau des conteneurs (container network security) et networking Kubernetes ↗
- Prometheus sur Kubernetes et l'interface web de Prometheus ↗
- Container registry : choisir et sécuriser son registre d'images (Docker Hub, Harbor, GHCR, ECR) ↗
- Architecture d'un système Linux : noyau, démarrage et arborescence ↗
- Le shell Bash et les fichiers : navigation, redirections, pipes et traitement de texte ↗
- Utilisateurs, groupes, sudo et permissions sous Linux ↗
- Paquets, services systemd, journaux et tâches planifiées ↗
- Stockage sous Linux : disques, partitions, systèmes de fichiers et LVM ↗
- Réseau sous Linux : configuration, diagnostic, pare-feu et SSH ↗
- Processus, mémoire et performance : surveiller et dépanner un serveur Linux ↗
- Sécurité et durcissement d'un serveur Linux ↗
- Scripts Bash pour l'administrateur : écrire des scripts robustes ↗
- Sauvegarde, supervision et dépannage d'un serveur Linux ↗
- Bonnes pratiques d'administration Linux ↗
- Organiser le DevOps : flux de valeur, équipes et culture sans blâme ↗
- Git pour le DevOps : branches, revues de code et versions ↗
- CI/CD de bout en bout (1/5) : principes et anatomie d'un pipeline ↗
- CI/CD de bout en bout (2/5) : intégration continue, tests et qualité ↗
- CI/CD de bout en bout (3/5) : artefacts, registres et environnements ↗
- CI/CD de bout en bout (4/5) : stratégies de déploiement et retour arrière ↗
- CI/CD de bout en bout (5/5) : GitHub Actions, GitLab CI, Jenkins et Argo CD en pratique ↗
- Infrastructure as Code et GitOps : Terraform, Ansible et Argo CD ↗
- Conteneurs, Kubernetes et cloud native dans une démarche DevOps ↗
- DevSecOps : sécuriser la chaîne logicielle de bout en bout ↗
- Observabilité, SRE et gestion des incidents pour les équipes DevOps ↗
- Mesurer la performance DevOps : métriques DORA, SPACE et amélioration continue ↗
- Platform engineering, FinOps et IA : les nouvelles frontières du DevOps ↗
- Les concepts fondamentaux d'OpenTelemetry : signaux, ressources, contexte et maturité ↗
- Collector OpenTelemetry : connecteurs, extensions et observabilité du Collector ↗
- Les conventions sémantiques OpenTelemetry (semconv) : nommer la télémétrie ↗
- Les traces OpenTelemetry en profondeur : spans, statuts, événements, liens et échantillonnage ↗
- Les métriques OpenTelemetry : instruments, temporalité, histogrammes et exemplars ↗
- Les logs avec OpenTelemetry : modèle de données, appenders, corrélation et collecte ↗
- Les profils, le quatrième signal d'OpenTelemetry : profilage continu et corrélation avec les traces ↗
- Corréler traces, métriques, logs et profils avec OpenTelemetry ↗
- OpenTelemetry sur Kubernetes : Operator, auto-instrumentation et Collector ↗
- Vagrant : vue d'ensemble et vocabulaire (box, provider, provisioner, Vagrantfile) ↗
- Vagrant multi-machines : déployer un cluster Docker Swarm prêt à l'emploi ↗
- Les plugins Vagrant : étendre providers, provisioners et commandes ↗
- Partager un environnement Vagrant : ngrok et le plugin vagrant-share ↗
- Traefik : sécuriser et transformer les requêtes avec les middlewares (BasicAuth, ForwardAuth…) ↗
- Traefik : les providers (Docker, Kubernetes, Nomad, Consul, fichiers, clés-valeurs) ↗
- Traefik comme Ingress Controller pour Kubernetes (Helm, IngressRoute, Gateway API) ↗
- Les plugins Traefik : l'exemple de CrowdSec pour bloquer les attaques ↗
- Traefik : les logs (journaux applicatifs et access logs) ↗
- Traefik : le tracing distribué avec OpenTelemetry ↗
- Traefik : les métriques avec Prometheus et OpenTelemetry ↗
- L'API de Traefik : inspecter la configuration et sécuriser le tableau de bord ↗
- Stratégies de déploiement avec Traefik : blue/green, canary et rolling ↗
- Canary automatisé avec Flagger et Traefik sur Kubernetes ↗
- Comprendre AWS : infrastructure mondiale, comptes, outils et tarification ↗
- IAM : identités, rôles et politiques sur AWS ↗
- Le réseau AWS : VPC, sous-réseaux, routage et sécurité ↗
- Le calcul sur AWS : EC2, Auto Scaling, Lambda et conteneurs ↗
- Le stockage sur AWS : S3, EBS, EFS et sauvegarde ↗
- Les bases de données sur AWS : RDS, Aurora, DynamoDB et ElastiCache ↗
- Superviser et sécuriser AWS : CloudWatch, CloudTrail, Config, KMS et GuardDuty ↗
- Infrastructure as Code sur AWS : CloudFormation, CDK, Terraform et Well-Architected ↗
- Maîtriser ses coûts AWS : modèles de prix, budgets et optimisation ↗
- Préparer la certification AWS Certified Cloud Practitioner (CLF-C02) ↗
- Préparer la certification AWS Certified Solutions Architect – Associate (SAA-C03) ↗
- Bonnes pratiques AWS : sécurité, fiabilité, coûts et exploitation ↗
- Fluent Bit : les inputs (entrées) du pipeline en détail ↗
- Fluent Bit : parsers et filters, structurer et transformer les logs ↗
- Fluent Bit : les outputs (sorties), routage et fiabilité de l'envoi ↗
- Vector : les sources en détail ↗
- Vector : les transforms en détail (remap et VRL, route, filter, réduction et métriques) ↗
- Vector : les sinks en détail (destinations, lots, tampons et réessais) ↗
- Comprendre Azure : régions, hiérarchie des ressources, outils et tarification ↗
- Microsoft Entra ID, RBAC et Azure Policy : identités, droits et gouvernance ↗
- Le réseau Azure : VNet, NSG, peering, équilibrage et connectivité hybride ↗
- Le calcul sur Azure : machines virtuelles, App Service, Functions et conteneurs ↗
- Le stockage Azure : comptes de stockage, Blob, Files, disques et redondance ↗
- Les bases de données sur Azure : Azure SQL, Cosmos DB, PostgreSQL et cache ↗
- Superviser et protéger Azure : Monitor, Log Analytics, Defender, Key Vault et Backup ↗
- Infrastructure as Code sur Azure : Bicep, Terraform, Cost Management et Well-Architected ↗
- Préparer la certification Microsoft Azure Fundamentals (AZ-900) ↗
- Préparer la certification Azure Administrator Associate (AZ-104) ↗
- Bonnes pratiques Azure : landing zone, sécurité, fiabilité et coûts ↗
- Comprendre Google Cloud : régions, projets, hiérarchie, outils et tarification ↗
- IAM sur Google Cloud : rôles, comptes de service et règles d'administration ↗
- Le réseau Google Cloud : VPC mondial, sous-réseaux, pare-feu et équilibrage ↗
- Le calcul sur Google Cloud : Compute Engine, GKE, Cloud Run et Cloud Functions ↗
- Le stockage Google Cloud : Cloud Storage, disques persistants et Filestore ↗
- Les bases de données Google Cloud : Cloud SQL, AlloyDB, Spanner, Firestore et Bigtable ↗
- Exploiter Google Cloud : observabilité, sécurité, infrastructure as code et coûts ↗
- Préparer la certification Google Cloud Digital Leader ↗
- Préparer la certification Google Associate Cloud Engineer ↗
- Bonnes pratiques Google Cloud : organisation, sécurité, fiabilité et coûts ↗
- Comprendre OVHcloud : univers, régions, Public Cloud et outils ↗
- Identités et accès sur OVHcloud : compte, IAM, utilisateurs OpenStack et clés ↗
- Le réseau Public Cloud OVHcloud : réseaux privés, vRack, Gateway, Floating IP et Load Balancer ↗
- Le calcul sur OVHcloud : instances Public Cloud et Managed Kubernetes Service ↗
- Le stockage OVHcloud : Block Storage, Object Storage compatible S3 et Cold Archive ↗
- Les bases de données managées OVHcloud (Public Cloud Databases) ↗
- Exploiter OVHcloud : Terraform, supervision, sécurité, coûts et souveraineté ↗
- Bonnes pratiques OVHcloud : organisation, sécurité, réseau, sauvegarde et coûts ↗
- Terraform : principes, architecture et flux de travail ↗
- Le langage HCL : ressources, variables, sorties, données et expressions ↗
- L'état Terraform : backends distants, verrouillage, import et refactorisation ↗
- Les modules Terraform : concevoir, versionner et réutiliser ↗
- Terraform multi-environnements, workspaces et organisation des dépôts ↗
- Tester et sécuriser Terraform : validate, terraform test, tflint, Checkov et politiques ↗
- Terraform en CI/CD : pipelines, revue du plan, OIDC et GitOps ↗
- Terraform sur plusieurs clouds : AWS, Azure, Google Cloud, OVHcloud et Kubernetes ↗
- Préparer la certification HashiCorp Certified: Terraform Associate ↗
- Bonnes pratiques Terraform : structure, état, sécurité, revue et maintenance ↗
- Observabilité sur AWS : CloudWatch, X-Ray, Application Signals, ADOT, Managed Prometheus et Grafana ↗
- Observabilité sur Azure : Azure Monitor, Log Analytics, Application Insights, Prometheus et Grafana managés ↗
- Observabilité sur Google Cloud : Cloud Monitoring, Logging, Trace, Profiler et Managed Prometheus ↗
- Chaos engineering : principes, outils et mise en pratique avec les SLO ↗