ROUSSELTM LEARNING
Mapa del sitio
Temas, cursos y artículos, en un solo lugar.
Cursos
Docker : del descubrimiento al nivel experto
Explorar ↗
- Visión general de la formación
- Docker : del descubrimiento al nivel experto
- Virtualización y contenerización
- Los componentes de Docker con términos de actividades portuarias
- Configuración del entorno de prueba
- Instalación del motor Docker - Docker engine - TP con vagrant y virtualbox
- Instalación de Docker desktop
- Presentación CLI - TP con vagrant y virtualbox
- Instalación de Docker
- El concepto de capa en Docker
- Docker hub
- Despliegue de contenedores
- Dockerfile
- Dockerfile - Construcciones multi-etapa (Multi-stage builds)
- Construcción de una imagen y transferencia a docker hub - uptimerobot exporter
- Buenas prácticas para construir un Dockerfile - .dockerignore - multi-stage
- Creación de mi primer contenedor
- Container registry: elegir y proteger el registro
- La comunicación de red de un contenedor - inspect - network
- La persistencia de los datos dentro de un contenedor
- La seguridad con docker security bench
- Gestionar su propio registry
- Toma de contacto con Docker Desktop - Docker Scout - extensiones
- Desplegar un registry docker harbor de VMware - scan - trivy - security
- Mi primera puesta en red y persistencia de un contenedor
- Mi primera imagen multi-stage
- Introducción
- ¿Debemos escribir 'docker compose' o 'docker-compose'?
- Creación de un archivo compose.yaml
- Uso avanzado de etiquetas (labels) - config traefik - deployment kubernetes
- Mi primer archivo docker compose
- Introducción
- Desplegar Clúster Docker SWARM y primeras manipulaciones
- Expulsión (Eviction) de contenedores - Memory - CPU - QoS Classes
- Configuración como código - Terraform/Opentofu - saltstack - Ansible
- Los pilares de la observabilidad: logs, traces y métricas
- Configuración exporter prometheus VM/contenedores - cadvisor - node-exporter - ingress
- Logs, traces y métricas con Dynatrace - Docker y kubernetes
- Proyecto 1
- Guía rápida de Docker: comandos esenciales
- Buenas prácticas de Docker
- DCA
Dynatrace: del descubrimiento a la maestría
Explorar ↗
- Visión general de la formación
- Dynatrace: del descubrimiento a la maestría
- Definiciones
- Cómo seguir la formación
- Arquitectura de Dynatrace
- 🧠 Dynatrace Davis
- Preparación del entorno de pruebas
- SaaS vs Managed
- ¿Qué es el playground?
- Acceder al playground
- Interfaz SaaS vs Managed
- Organización del clúster / entorno
- Primeros pasos con la interfaz de Dynatrace
- Página nueva vs página clásica
- Dashboard vs Dashboard clásico - Dashboards vs Dashboards classic
- Cómo conocer de un vistazo el estado de un host, servicio...
- Conjunto de tecnologías presentes en tu clúster - Technologies and processes
- Añadir/eliminar funciones del clúster - extensions - extensions manager
- Licencias de Dynatrace: modelo clásico y DPS
- Seguir tu consumo de DDU - Davis Data Units (modelo de licencia clásico)
- Licencias y FinOps
- Los métodos de recopilación - oneagent - opentelemetry - exporter Prometheus...
- Oneagent
- Instalación del oneagent - Hostgroup - tags - owners - properties
- Reconfigurar el oneagent con la CLI oneagentctl o mediante el deployment status
- Oneagent en el mundo docker / kubernetes
- Oneagent health
- Cómo conocer de un vistazo el estado de un host, servicio...
- La correlación entre los pilares de la observabilidad - logs, métricas y trazas
- Práctica - la recopilación
- ActiveGate y network zones
- Dynatrace Operator en Kubernetes
- OpenTelemetry y Dynatrace
- Comprender y manejar las diferentes API de Dynatrace
- Presentación de Monaco
- Crear y manejar los tokens: ejemplo de tokens para Monaco
- Crear un cliente OAuth si tienes una suscripción SaaS
- [CI/CD] Construye tu propia imagen Docker para Monaco - Github action
- Presentación de dynatrace simply smarter
- Exportar, crear, eliminar... tu primera configuración con Monaco
- [CI/CD] Pipeline para ejecutar Monaco automáticamente - Gitlab CI/CD
- Selección de los elementos del clúster - filtros - Entity selector
- Manejar las zonas de gestión - management zones - settings
- Práctica - Creación y uso de los Entity Selectors
- Segmentos y nueva plataforma
- Introducción
- Crea automáticamente incidencias en tus herramientas - Issue tracking
- Encuentra la información indicada en tu despliegue de kubernetes - release
- Gestión de eventos - API - events - release monitoring - CI/CD
- Supervisión de usuarios reales sin instalar agentes
- Cómo encontrar, modificar y eliminar una aplicación creada
- Supervisión de usuarios reales de una aplicación PaaS
- Supervisión de usuarios reales mediante una extensión del navegador
- Cómo verificar que la instrumentación está correctamente implantada
- Introducción al synthetic
- Crear una supervisión HTTP (HTTP monitor)
- Modificar una supervisión HTTP (HTTP monitor)
- Supervisión mediante navegador (Browser monitor)
- Supervisión mediante navegador (Browser monitor) - uso de javascript
- Supervisión mediante navegador (Browser monitor) - CSS selector
- Añadir autenticación a tus escenarios - credential vault
- Práctica - El Synthetic Monitoring
- Aplicación frontend
- Apdex (Application Performance Index) vs Core Web Vitals
- User session
- Flujo entre servicios - service flow
- Trazas distribuidas - distributed traces
- Analizar los llamantes - Application Databases - backtrace
- Análisis multidimensional - multidimensional analysis
- Acciones y eventos - User session query language - USQL
- Construye tu primera consulta USQL - SQL like - USQL
- Comprender y optimizar los recorridos de tus usuarios - funnel - USQL
- Práctica - Visualiza y analiza tu experiencia de usuario (DEM)
- Business observability
- Introducción
- Crea tu primer gráfico - Data explorer
- Crear tu primer dashboard - dashboards classic
- La aplicación de problemas (Problems)
- Auto-remediation: self healing
- El contenido de una página de problema
- Instalar la aplicación móvil para recibir las alertas - install mobile
- Davis AI avanzado
- Alertas avanzadas
- Workflows y AutomationEngine
- Los propietarios (owners / ownerships)
- Reconfigurar un oneagent para definir el propietario de la máquina
- Ventanas de mantenimiento - Maintenance Windows
- Renombrado de recursos - host naming - process group naming - request naming
- Peticiones clave - key requests
- Aplicar los tags - Automatically applied tags - Manually applied tags
- Presentación de SLO - SLI - SLA - SRE
- Gestión de los SLO
- Smartscape topology
- Las subaplicaciones
- Analiza la sesión de tus visitantes como si estuvieras allí - waterfall analysis
- Mostrar todos los contenedores presentes en el clúster - containers
- Ver y analizar un clúster kubernetes - kubernetes
- Recorrer los datos recopilados en una suscripción - Lambda Function - AWS
- Supervisa el uso de la red - Host networking
- Cloud e infraestructura
- AppEngine y aplicaciones personalizadas
- Presentación de Grail
- Recorre y busca tus datos de observabilidad - Logs and events - Grail
- Construye tus primeras consultas DQL - Grail
- Enriquece tus consultas DQL y añádelas a un cuaderno - Notebooks - Grail
- Enriquece tus consultas DQL y añádelas a un dashboard - Dashboards - Grail
- Las buenas prácticas para construir consultas DQL eficientes - Grail
- Práctica - Análisis avanzado con Grail, DQL y Entity Selectors
- Logs avanzados y OpenPipeline
- Grail y DQL avanzados
- Gestionar los permisos: IAM, grupos y políticas
- Seguridad y gobernanza
- La retención de los datos
- Proyecto 1
- Proyecto 2: RUM
- Las aplicaciones que dominar para el análisis
- Buenas prácticas de Dynatrace
- Associate
- Advanced Observability Specialist
- DEM and Business Analytics Specialist
- Implementation Professional
- Administration Professional
Vagrant: del descubrimiento a la experiencia
Explorar ↗
- Descripción general del curso
- Vagrant: del descubrimiento a la experiencia
- Instalación de Vagrant
- Los providers: VirtualBox - Docker - VMware - Hyper-V ...
- Vagrant Cloud: Boxes públicas y privadas
- Gestión de boxes: vagrant box
- Construcción de imágenes: HashiCorp Packer
- Construcción de imágenes: exportar una máquina - no recomendado
- Initialization: vagrant init
- Construir y detener su primera máquina: vagrant up / down
- Definición del provider y las características de la máquina: CPU - RAM - ...
- Nomenclatura - vagrant - VirtualBox - hostname
- Conexión a la máquina creada - vagrant ssh - rdp
- Sincronización de archivos
- Redes: port forward - red privada - red pública
- Configuración de la máquina: Provisioner File
- Configuración de la máquina: Provisioner Shell
- Configuración de la máquina: Provisioner Ansible - Salt - Chef - Puppet
- Configuración de la máquina: Provisioner Docker
- Práctica: mi primera máquina virtual con Vagrant
- Por qué el multi-máquina
- Vagrantfile: variables, condiciones y bucles para desplegar varias máquinas
- Desplegar un clúster Docker Swarm listo para usar (unión ya realizada)
- Práctica: un entorno multi-máquina (web + base de datos)
- Presentación: casos de los providers y provisioners
- Compartir un entorno de pruebas: ngrok y el plugin vagrant-share
- Práctica: provisioning con Ansible y snapshots
- Buenas prácticas de Vagrant
Traefik: del descubrimiento a la experiencia
Explorar ↗
- Vue d'ensemble de Traefik
- Traefik: del descubrimiento a la experiencia
- Load balancer - proxy - reverse proxy
- Traefik
- Cómo seguir este curso
- Código promocional para nuestros otros cursos
- Preparación del entorno de pruebas
- Installation
- Standalone - clásico
- Docker
- Kubernetes - Helm
- Cuidado con los cuellos de botella - HA - SPOF - Traefik Enterprise - Traefik Hub
- Los métodos de configuración - Archivo (YAML) - Archivo (TOML) - CLI - ...
- Configuración estática vs dinámica
- Configuración estática
- Configuración dinámica - Docker - Kubernetes - Consul - Rancher - Nomad - ...
- Configuración de SSL - Let's Encrypt
- Panel de control
- Entrypoints
- Routers - HTTP - TCP - UDP
- Services
- Middlewares - configuración de seguridad con basicauth, forwardauth...
- Providers - Docker - Kubernetes - Nomad - Consul - etcd - Redis - HTTP ...
- Traefik como Ingress Controller para Kubernetes
- Los plugins - ejemplo con CrowdSec
- Los logs
- Las trazas
- Las métricas
- API
- Estrategias de despliegue: blue/green - canary - rolling
- Canary deployment - Flagger
- ACME: despliegue SSL/TLS automatizado
- Gestionar certificados con Let's Encrypt
- Buenas prácticas de Traefik
- Práctica: publicar dos aplicaciones con Traefik y Docker
- Práctica: middlewares, balanceo de carga y seguridad
Ansible: del descubrimiento a la experiencia
Explorar ↗
- Ansible: del descubrimiento a la experiencia
- Administración de sistemas
- Automatización: IaC vs CaC
- Ansible
- Instalación
- Conexión a los servidores
- Preparación del entorno de pruebas
- Instalación
- El inventario: estático, dinámico, grupos y variables
- Práctica: inventario y comandos ad-hoc
- Comandos ad-hoc
- Estructurar el código con roles
- Práctica: un rol nginx con plantilla y handler
- Archivos dinámicos: Jinja2 y facts
- Seguridad: Vault, SSH y privilegios
- Gestionar la infraestructura con playbooks
- Una interfaz gráfica: AWX, Semaphore y AAP
- Ir más lejos: pruebas, CI/CD y rendimiento
- Buenas prácticas de Ansible
- RHCE
Elasticsearch: del descubrimiento a la maestría
Explorar ↗
- Elasticsearch: del descubrimiento a la maestría
- Introducción
- Arquitectura Elastic y buenas prácticas
- Instalación
- Bases de datos NoSQL, índices, shards y Apache Lucene
- Índices - buenas prácticas
- Instalación de Kibana
- Preparación del entorno de pruebas
- Instalación de Elasticsearch
- Arquitectura distribuida avanzada
- Licencias: modelos de licencia de Elasticsearch
- Probar consultas y configuraciones con Kibana Dev Tools
- Obtener la información del clúster
- Gestión de licencias
- Monitorización y diagnóstico
- Rendimiento y planificación de capacidad
- Los índices
- Las plantillas (templates)
- Mappings y análisis de texto
- Ingesta e ingest pipelines
- Data streams y templates
- Index Lifecycle Management (ILM)
- Espacios de Kibana: funcionalidades ocultas o desactivadas
- Seguridad: usuarios, roles y claves de API (roles reservados y obsoletos)
- Usuarios y roles externos: Role Mapping
- Gestión de los espacios
- Usuarios y roles
- API keys
- Role mappings
- Seguridad avanzada
- Lenguajes de consulta: Query DSL, KQL y ES|QL
- Filtra tus documentos
- La búsqueda
- Query DSL y agregaciones avanzadas
- Kibana avanzado
- Búsqueda vectorial y RAG
- Detección de cambios
- Copia de seguridad y restauración
- Snapshot Lifecycle Management
- Cross-cluster search y replication
- Elasticsearch en Kubernetes con ECK
- Automatización e infraestructura como código
- Buenas prácticas de Elasticsearch
- Proyecto final: operar un clúster Elasticsearch de producción simulada
- ECE
Logstash: del descubrimiento a la experiencia
Explorar ↗
- Logstash: del descubrimiento a la experiencia
- Introducción
- El concepto de pipeline
- Instalación
- Las entradas: inputs
- Los filtros: filters
- Los filtros: plugin grok
- Los filtros: plugin dissect vs grok
- Las salidas: output
- Gestión de plugins
- Elastic Common Schema (ECS)
- Preparación del entorno de pruebas
- Instalación de Logstash
- Mi primer pipeline
- Mi segundo pipeline
- Buenas prácticas de Logstash
Prometheus: del descubrimiento a la experiencia
Explorar ↗
- Prometheus: del descubrimiento a la experiencia
- Preparación del entorno de pruebas
- La observabilidad
- Arquitectura
- Presentación de los exporters
- Las metrics - las labels y los valores
- Instalación de los exporters - node exporter - cadvisor - traefik
- Opentelemetry como exporter de prometheus
- Construcción de un exporter personalizado
- Las buenas prácticas
- Despliegue de exporters
- Monitorización de sitios web y HTTPS
- Introducción
- Instalación
- Envío y eliminación de datos - uso de las librerías
- Exportar las métricas de un Batch
- Architecture - push - pull
- Instalación
- Auto-supervisión de prometheus - exporter prometheus server
- Prometheus Web UI
- Prometheus Web UI - Graph - Prometheus Query Language - PromQL
- Comprender las recording rules
- Escribir y nombrar las recording rules
- Probar, desplegar y supervisar las reglas
- Práctica: escribir, probar y medir recording rules
- Alertar con Alertmanager
- Práctica: alertar con Prometheus y Alertmanager
- Visualizar métricas con Grafana
- Práctica: visualizar Prometheus en Grafana (métodos USE y RED)
- Prometheus en Kubernetes: Operator y ServiceMonitor
- Práctica: supervisar Kubernetes con kube-prometheus-stack
- Prometheus en Kubernetes y su interfaz web
- Buenas prácticas de Prometheus
- PCA
Cloud Computing: del descubrimiento a la experiencia
Explorar ↗
- Cloud Computing: del descubrimiento a la experiencia
- ¿Qué es el Cloud Computing? La definición del NIST
- Elasticidad vs escalabilidad
- ¿Qué es una aplicación cloud native?
- IaaS, PaaS, SaaS: modelos de servicio
- El modelo de responsabilidad compartida
- Computación serverless
- Modelos de despliegue: público, privado, híbrido, multi-cloud
- Edge computing
- Las 6 R: estrategias de migración
- Introducción a FinOps
- Dejen de pasar a la nube, a los microservicios...
- CaaS: estado del arte y buenas prácticas
- Buenas prácticas de Cloud
- Práctica: aprovisionar recursos cloud sin cuenta (LocalStack)
- Práctica: Infrastructure as Code con Terraform
- Práctica: elasticidad y alta disponibilidad con Docker Compose
- AWS Certified Cloud Practitioner (CLF-C02)
- Microsoft Azure Fundamentals (AZ-900)
OpenTelemetry: del descubrimiento a la experiencia
Explorar ↗
- OpenTelemetry: del descubrimiento a la experiencia
- ¿Por qué OpenTelemetry?
- Los conceptos fundamentales de OpenTelemetry
- El protocolo OTLP y sus especificaciones
- Los 3 niveles de arquitectura de OpenTelemetry
- El papel del Collector y la arquitectura del pipeline
- Los Receivers: recopilar los datos de telemetría
- Los Processors: transformar y filtrar las señales
- Los Exporters: enrutar los datos hacia los backends
- Conectores, extensiones y observabilidad del Collector
- Práctica: configurar un Collector de OpenTelemetry (receivers, processors, exporters)
- Auto-instrumentación (Java, Python, Node.js)
- Instrumentación manual con el SDK
- Propagación de contexto
- Práctica: instrumentar una aplicación y propagar el contexto
- OpenInference: trazar las aplicaciones de IA
- Las convenciones semánticas (semconv)
- Las trazas en profundidad
- Tracing distribuido y propagación de contexto
- Práctica: Instrumentar trazas a mano (spans, eventos, errores, enlaces, muestreo)
- Las métricas en profundidad
- Práctica: Instrumentos, vistas y exemplars con el SDK de métricas
- Los logs en profundidad
- Práctica: Logs de OpenTelemetry correlacionados con las trazas y recogida de archivos
- Los perfiles, la cuarta señal
- Práctica: Perfilar una aplicación y vincular perfiles y trazas
- Correlacionar trazas, métricas, logs y perfiles
- Práctica: Correlacionar las cuatro señales de dos servicios auto-instrumentados
- Desplegar un pipeline de observabilidad completo con un Agente y una Gateway
- OpenTelemetry en Kubernetes
- Práctica: OpenTelemetry Operator y auto-instrumentación en Kubernetes
- Proyecto integrador: las cuatro señales
- TP integrador: diagnosticar la OpenTelemetry Demo con las cuatro señales
- OpenTelemetry Collector, Grafana Alloy y Bindplane
- Buenas prácticas de OpenTelemetry
- OTCA
- Splunk O11y Metrics User
- New Relic Verified Foundations
- New Relic APM Practitioner
Grafana: del descubrimiento a la experiencia
Explorar ↗
- Grafana: del descubrimiento a la experiencia
- Instalación
- Infrastructure as Code (IaC)
- Cómo aprovechar bien la documentación
- Carpeta de provisioning
- Grafana Provisioning: automatizar dashboards y orígenes de datos
- Las conexiones
- Las fuentes de datos
- Elasticsearch
- Prometheus
- Introducción
- Los errores a evitar
- Qué es una dashlet
- Antes de empezar
- Grafana Dashboard
- El papel de las variables
- Las variables globales
- Las variables locales
- Variables: guía completa
- Dominar las consultas: PromQL, LogQL, SQL y expresiones
- Introducción
- Table view
- Tipos de datos
- Las transformaciones en detalle
- Introducción
- Value Mappings
- Grafana Cloud: empezar con la plataforma gestionada
- Proyecto 1: Códigos de respuesta HTTP
- Proyecto 2: Manipulación de la API de Dynatrace
- Proyecto 3: Manipulación de los datos
- Proyecto 4: Explotación de Elasticsearch
- Proyecto 5: Primeros pasos
- Grafana Assistant: IA para la observabilidad
- ¿Grafana o Kibana?
- La stack LGTM
- Buenas prácticas de Grafana
DevOps: del descubrimiento a la experiencia
Explorar ↗
- Descripción general del curso
- DevOps: estado del arte y buenas prácticas
- Variantes de DevOps
- El muro de la confusión
- Soporte Logístico Integrado
- Organizar el DevOps: flujo de valor, equipos y cultura
- Git para DevOps
- Práctica: Trunk-based development, commits convencionales y versiones
- CI/CD (1/5): principios y anatomía de un pipeline
- CI/CD (2/5): integración continua, pruebas y calidad
- Práctica: un pipeline CI/CD completo
- CI/CD (3/5): artefactos, registros y entornos
- CI/CD (4/5): estrategias de despliegue y vuelta atrás
- Práctica: Promoción de una imagen y despliegue blue/green
- Práctica: Rolling update, canary y vuelta atrás en Kubernetes
- CI/CD (5/5): GitHub Actions, GitLab CI, Jenkins y Argo CD
- Infraestructura como código y GitOps
- Práctica: Infraestructura como código con Terraform
- Práctica: GitOps con Argo CD
- La aplicación de 12 factores
- Contenedores, Kubernetes y cloud native
- DevSecOps: asegurar la cadena de suministro de software
- Práctica: Asegurar el pipeline: secretos, vulnerabilidades, SBOM y firma
- Observabilidad, SRE y gestión de incidentes
- Medir el rendimiento DevOps: DORA y SPACE
- Práctica: medir las métricas DORA a partir de Git
- Platform engineering, FinOps e IA
- El dilema: ¿con o sin IA?
- Buenas prácticas de DevOps
- Proyecto final: una cadena DevOps completa del commit a producción
- DevOps Foundation
Beats: del descubrimiento a la maestría
Explorar ↗
- Beats: del descubrimiento a la maestría
- Beats: Filebeat - Winlogbeat - Metricbeat - ...
- Beats: Configuración con o sin módulo
- Elastic Agent: Fleet
- OpenTelemetry
- Otras fuentes: Syslog - Fluent Bit - ...
- ¿Y si añadimos una cola?: Kafka - RabbitMQ - Redis ...
- Configuración del entorno de prueba
- Instalación de Filebeat
- Ir más lejos: seguridad, rendimiento, Elastic Agent y migración
- Buenas prácticas de Beats
- Práctica: recoger logs de nginx con Filebeat hacia Elasticsearch
Kubernetes: del descubrimiento a la experiencia
Explorar ↗
- Kubernetes: del descubrimiento a la experiencia
- Entorno de prueba
- Entorno de pruebas: kind
- Arquitectura y componentes de Kubernetes
- Guía rápida de kubectl
- Pods, ReplicaSets y Deployments
- Fiabilidad y escalado: probes, HPA, PDB
- Práctica: desplegar, exponer y actualizar una aplicación
- Services de Kubernetes
- Los diferentes CNI
- Exponer aplicaciones: Ingress y Gateway API
- ConfigMaps y Secrets
- PersistentVolumes, Claims y StorageClass
- Resource Quotas
- Gestores de paquetes
- Gestores de despliegue
- Jobs vs Serverless
- Estrategias de colocación
- Asegurar el clúster: RBAC, NetworkPolicies, Pod Security
- Práctica: RBAC y NetworkPolicy
- Seguridad de red de los contenedores
- Buenas prácticas de Kubernetes
- Comparación de ofertas de Kubernetes
- KCNA
- CKA
- CKAD
- CKS
Alloy: del descubrimiento a la maestría
Explorar ↗
- Alloy: del descubrimiento a la maestría
- ¿Qué es Grafana Alloy?
- El concepto de "Pipelines Programables"
- Arquitectura interna
- Instalación
- La interfaz de usuario de Alloy
- Práctica: instalar Alloy con Docker y explorar su interfaz
- Bloques de configuración
- River vs HCL
- Variables y Funciones
- Gestión de Secretos
- Variables de entorno y OpenTelemetry
- Práctica: primer pipeline - métricas del sistema y logs locales
- Descubrimiento (Discovery)
- Scraping
- Escritura Remota (Remote Write)
- Interoperabilidad OTLP
- Práctica: scraping, relabeling y recepción OTLP de métricas
- Fuentes de logs
- Pipelines de procesamiento
- Envío
- Práctica: Recolección y envío de logs a Loki
- Práctica: parsear, filtrar y enriquecer logs JSON
- Trazas
- Transformación
- Práctica: ingerir, transformar y muestrear trazas hacia Tempo
- Perfilado Continuo
- Puesta en marcha de la recolección de perfiles
- Práctica: profiling continuo con Pyroscope
- El modo Clúster
- Práctica: montar un clúster de Alloy de 3 nodos
- Alloy en Kubernetes
- Práctica: desplegar Alloy en Kubernetes con Helm
- Observabilidad de Alloy
- Buenas prácticas de recolección
- Alloy, Grafana Agent y Promtail
- ¿Alloy u OpenTelemetry Collector?
- ¿Alloy o Dynatrace ActiveGate?
- OpenTelemetry Collector, Grafana Alloy y Bindplane
- Referencia de componentes
- Práctica final: pipeline de observabilidad unificado y modular
HAProxy: del descubrimiento a la experiencia
Explorar ↗
- HAProxy: del descubrimiento a la experiencia
- Introducción al Equilibrio de Carga
- El ecosistema HAProxy: de Open Source a HAProxy One
- Instalación y Gestión del servicio
- Anatomía de la configuración: Global, Frontend, Backend y Defaults
- Guía detallada de directivas de configuración
- Guía rápida de HAProxy: comandos esenciales
- Algoritmos: Round Robin, Leastconn y Hash
- Persistencia de sesión (stickiness)
- Health checks y alta disponibilidad
- Dominar las ACLs
- Las ACL: la guía completa
- Terminación SSL y Offloading
- ACME: SSL/TLS automatizado
- Certificados con Let's Encrypt
- El Dashboard de Estadísticas
- Alta y baja dinámica de backends
- Visualizar la infraestructura: Topology Visualizer
- HAProxy y Docker: construir un clúster balanceado de alta disponibilidad
- Práctica: persistencia, health checks y página de estadísticas
- Práctica: terminación SSL y enrutamiento por ACL
- HAProxy Ingress Controller para Kubernetes
- Ingress Controller: guía de producción
- Buenas prácticas de HAProxy
- Novedades de HAProxy: OpenTelemetry, JWT, rendimiento
Grafana Tempo: del descubrimiento a la maestría
Explorar ↗
- Grafana Tempo: del descubrimiento a la maestría
- El tracing distribuido con Tempo
- ¿Tempo o Jaeger?
- Instalación de Tempo
- Práctica: Desplegar Tempo y enviar tu primera traza
- El protocolo OTLP
- Instrumentar tus aplicaciones
- Trazas con Alloy
- Práctica: Instrumentar una aplicación Python con OpenTelemetry
- TraceQL
- Práctica: Diagnosticar con TraceQL
- Métricas a partir de las trazas
- Correlacionar trazas, logs, métricas y perfiles
- Práctica: Métricas RED y service graph con el metrics-generator
- Almacenamiento y escalado
- Tempo en producción
- Práctica final: Una plataforma de tracing con MinIO, muestreo y correlación
- Buenas prácticas de Tempo
Grafana Loki: del descubrimiento a la maestría
Explorar ↗
- Grafana Loki: del descubrimiento a la maestría
- ¿Qué es Grafana Loki?
- ¿Loki o Elasticsearch?
- Instalación de Loki
- Práctica: Desplegar Loki y enviar tus primeros logs
- Recolectar los logs hacia Loki
- Gestión de logs con Alloy
- Práctica: Recolectar los logs de contenedores y archivos con Alloy
- LogQL: consultar los logs
- LogQL: transformar los logs en métricas
- Práctica: Dominar LogQL
- Almacenamiento, índice TSDB y retención
- El Ruler de Loki
- Práctica: Alertar sobre los logs con el Ruler
- Operar Loki en producción
- Práctica final: Plataforma de logs con MinIO, retención y multi-tenant
- Buenas prácticas de Loki
Thanos: del descubrimiento a la maestría
Explorar ↗
- Thanos: del descubrimiento a la maestría
- ¿Por qué Thanos?
- Prometheus, VictoriaMetrics y Thanos
- ¿Thanos, Mimir o VictoriaMetrics?
- Thanos Sidecar
- Práctica: Prometheus + Thanos Sidecar + MinIO
- Thanos Query y Query Frontend
- Práctica: Alta disponibilidad con dos Prometheus y Thanos Query
- Store Gateway y Compactor
- Práctica: Store Gateway, Compactor y downsampling
- Thanos Ruler
- Thanos Receive
- Práctica: Reglas globales con el Ruler y recepción por remote write
- Desplegar Thanos en Kubernetes
- Operar Thanos
- Práctica final: Thanos en Kubernetes
- Buenas prácticas de Thanos
Grafana Mimir: del descubrimiento a la maestría
Explorar ↗
- Grafana Mimir: del descubrimiento a la maestría
- ¿Por qué Grafana Mimir?
- La ruta de escritura
- Práctica: Mimir monolítico con MinIO, Prometheus y Grafana
- Práctica: Deduplicar dos Prometheus en alta disponibilidad
- La ruta de lectura
- Compactor, retención y almacenamiento de objetos
- Multi-tenant y límites
- Práctica: Tenants, límites y configuración de ejecución
- Ruler, Alertmanager y mimirtool
- Práctica: Reglas y alertas con el ruler y mimirtool
- Desplegar y operar Mimir en Kubernetes
- Práctica final: Mimir en Kubernetes con Helm
- Buenas prácticas de Grafana Mimir
Grafana Pyroscope: del descubrimiento a la maestría
Explorar ↗
- Grafana Pyroscope: del descubrimiento a la maestría
- El profiling continuo
- Arquitectura y despliegue de Pyroscope
- Instrumentar las aplicaciones
- Práctica: Perfilar una aplicación Go con el SDK de Pyroscope
- Práctica: Perfilar todos los contenedores de un host con Alloy y eBPF
- Analizar los perfiles en Grafana
- Práctica: Diagnosticar y validar una optimización con la comparación
- Vincular trazas y perfiles
- Práctica: De las trazas a los perfiles con Tempo y los span profiles
- Pyroscope en Kubernetes
- Práctica final: Profiling continuo de un clúster Kubernetes
- Buenas prácticas de Pyroscope
Alertmanager y gestión de alertas: del descubrimiento a la maestría
Explorar ↗
- Alertmanager y gestión de alertas: del descubrimiento a la maestría
- Alertmanager: papel y ciclo de vida
- Práctica: Primera cadena de alertas con Prometheus, Alertmanager y correo electrónico
- Escribir buenas reglas de alerta
- Enrutamiento, agrupación y receptores
- Práctica: Enrutamiento por equipo, agrupación e inhibición
- Silencios, inhibiciones e intervalos
- Práctica: Pruebas unitarias de reglas y silencios de mantenimiento
- Alta disponibilidad y operación
- Práctica: Alertmanager de alta disponibilidad y Watchdog
- Grafana Alerting y guardias
- Práctica final: Alerting de Grafana aprovisionado en YAML
- Buenas prácticas de alerting
SRE en la práctica: SLI, SLO y presupuestos de error
Explorar ↗
- SRE en la práctica: SLI, SLO y presupuestos de error
- SLI, SLO y SLA
- El presupuesto de error
- Medir SLI con Prometheus
- Práctica: Definir un SLI y calcular un presupuesto de error
- Alertas sobre el burn rate
- Generar tus SLO con Sloth
- Práctica: Generar SLO y alertas de burn rate con Sloth
- Gestionar tus SLO con Pyrra
- Práctica: Seguir tus SLO en la interfaz de Pyrra
- Buenas prácticas SRE
- Práctica final: Política de presupuesto de error y revisión de SLO
- Ingeniería del caos: principios, herramientas y práctica
- SRE Practitioner
Observabilidad con eBPF: del descubrimiento a la maestría
Explorar ↗
- Observabilidad con eBPF: del descubrimiento a la maestría
- eBPF explicado
- Diagnosticar con bpftrace y bcc
- Práctica: Diagnosticar un servidor Linux con bpftrace
- Instrumentar sin código con Beyla
- Práctica: Métricas RED y trazas sin código con Beyla
- Observar la red con Hubble
- Práctica: Flujos de red de Kubernetes con Cilium y Hubble
- Profiling continuo con eBPF
- Práctica: Perfilar todo un host con Parca
- eBPF en producción
- Buenas prácticas de eBPF
- CCA
Grafana k6: pruebas de carga y de rendimiento
Explorar ↗
- Grafana k6: pruebas de carga y de rendimiento
- ¿Por qué hacer pruebas de carga?
- Escribir scripts k6
- Práctica: primera prueba k6 con verificaciones y umbrales
- Umbrales, métricas y resultados
- Práctica: escenarios, tasa constante y prueba de estrés
- Observar una prueba k6
- Práctica: resultados de k6 en Prometheus y Grafana
- Navegador y monitorización sintética
- Práctica: prueba de navegador y Core Web Vitals
- k6 en CI y en Kubernetes
- Práctica final: prueba de rendimiento bloqueante en integración continua
- Buenas prácticas de k6
Grafana Faro: observabilidad front-end y RUM
Explorar ↗
- Grafana Faro: observabilidad front-end y RUM
- RUM y Core Web Vitals
- Arquitectura e instalación de Faro
- Práctica: Recopilar los Web Vitals de una página con Faro, Alloy y Loki
- Errores, eventos y sesiones
- Práctica: Errores, eventos de negocio y sesiones
- Trazas del navegador al back-end
- Práctica: Propagar las trazas del navegador hacia una API
- Explotar los datos de Faro
- Práctica final: Dashboard de experiencia de usuario y alerta
- Caso práctico: el RUM de este sitio
- Buenas prácticas de Faro
Fluent Bit: del descubrimiento a la maestría
Explorar ↗
- Fluent Bit: del descubrimiento a la maestría
- Panorama de los recopiladores de logs
- Fluent Bit: pipeline y configuración
- Los inputs en detalle
- Parsers y filtros en detalle
- Los outputs en detalle
- TP: Primer pipeline de Fluent Bit hacia Loki
- Fluent Bit en Kubernetes
- TP: Fluent Bit en Kubernetes con metadatos
- ¿Fluent Bit o Vector?
- Buenas prácticas de recopilación
Kibana y Elastic Observability: del descubrimiento a la maestría
Explorar ↗
- Kibana y Elastic Observability: del descubrimiento a la maestría
- Kibana: función e instalación
- TP: Instalar Kibana y explorar logs con KQL
- Discover, KQL y ES|QL
- TP: Analizar con ES|QL
- Lens, dashboards y objetos guardados
- TP: Dashboard de Lens versionado
- Elastic Observability
- Alertas, conectores y SLO
- TP: Regla de alerta ES|QL y conector
- Administrar Kibana
- TP Final: Espacios y roles para dos equipos
- Buenas prácticas de Kibana
- Elastic Observability Engineer
- Elastic Certified Analyst
- Elastic SIEM Analyst
VictoriaMetrics: del descubrimiento a la maestría
Explorar ↗
- VictoriaMetrics: del descubrimiento a la maestría
- ¿Por qué VictoriaMetrics?
- Práctica: VictoriaMetrics single-node con Prometheus y Grafana
- Ingerir métricas
- Práctica: vmagent, búfer en disco y caída del almacenamiento
- MetricsQL
- Práctica: ejercicios de MetricsQL y cardinalidad
- VictoriaMetrics en clúster
- Práctica: clúster VictoriaMetrics multi-tenant
- Operar VictoriaMetrics
- Práctica final: alertas con vmalert y Alertmanager
- ¿Thanos, Mimir o VictoriaMetrics?
- Buenas prácticas de VictoriaMetrics
Jaeger: tracing distribuido del descubrimiento a la maestría
Explorar ↗
- Jaeger: tracing distribuido del descubrimiento a la maestría
- El tracing distribuido con Jaeger
- Instalar Jaeger v2
- Práctica: Jaeger all-in-one y diagnóstico con HotROD
- Instrumentar con OpenTelemetry
- Práctica: instrumentar una aplicación Python hacia Jaeger
- Analizar trazas en Jaeger
- Práctica: monitorización del rendimiento de los servicios (SPM)
- Jaeger en producción
- Práctica final: Jaeger sobre Elasticsearch con tail sampling
- ¿Tempo o Jaeger?
- Buenas prácticas de Jaeger
SigNoz: del descubrimiento a la maestría
Zabbix: supervisión de infraestructura del descubrimiento a la maestría
Explorar ↗
- Zabbix: supervisión de infraestructura del descubrimiento a la maestría
- Zabbix: arquitectura y conceptos
- Instalar Zabbix
- Práctica: Instalar Zabbix y supervisar un primer host
- Recolectar datos con Zabbix
- Práctica: Plantilla propia, ítems, triggers y descubrimiento
- Práctica: Recolectar métricas de Prometheus con Zabbix
- Triggers y notificaciones
- Práctica: Notificaciones por webhook, escalado y mantenimiento
- Dashboards, Grafana y API
- Crear paneles en Zabbix
- Paneles de Grafana con la fuente de datos Zabbix
- Zabbix en producción
- Práctica final: Automatizar Zabbix con la API y mostrarlo en Grafana
- Buenas prácticas de Zabbix
- ZCU
- ZCS
Datadog: del descubrimiento a la maestría
Explorar ↗
- Datadog: del descubrimiento a la maestría
- Datadog de un vistazo
- Arquitectura de la plataforma Datadog
- Agente e integraciones
- Práctica: Instalar el agente de Datadog y activar una integración
- Datadog en Kubernetes
- Práctica: Supervisar un clúster Kubernetes con el Datadog Operator
- Métricas y tags
- Métricas avanzadas y cardinalidad
- Práctica: Métricas personalizadas con DogStatsD y dashboard
- Dashboards y notebooks
- Logs en Datadog
- Logs avanzados: índices, Flex y archivos
- Práctica: Pipeline de logs, facetas y control del volumen
- APM y OpenTelemetry
- APM avanzado: muestreo y profiler
- Práctica: APM en Python y correlación entre logs y trazas
- RUM y monitoreo sintético (Synthetic Monitoring)
- Práctica: Tests Synthetics con Terraform y en CI
- Red, cloud y bases de datos
- La seguridad con Datadog
- Monitors, SLO y Terraform
- Incidentes y automatización
- Práctica final: Monitors y SLO en Terraform
- Costes y gobernanza
- Buenas prácticas de Datadog
- Datadog Fundamentals
- Log Management Fundamentals
- APM & Distributed Tracing Fundamentals
Bindplane: pipelines de telemetría OpenTelemetry del descubrimiento a la maestría
Explorar ↗
- Bindplane: pipelines de telemetría OpenTelemetry del descubrimiento a la maestría
- Bindplane: gestionar los pipelines de telemetría
- OpenTelemetry Collector, Grafana Alloy y Bindplane
- Instalar Bindplane
- Práctica: Instalar Bindplane y conectar un primer colector
- Configuraciones de Bindplane
- Práctica: Construir un pipeline de logs y observar los datos
- Reducir, enmascarar y enrutar
- Práctica: Reducir y enmascarar los logs y medir la mejora
- Fleets, gateways y rollouts
- Práctica: Rollout por lotes, error y vuelta atrás
- Bindplane en producción
- Práctica final: Pipeline de producción gestionado como código
- Buenas prácticas de Bindplane
Arize AI: observabilidad y evaluación de LLM del descubrimiento a la maestría
Explorar ↗
- Arize AI: observabilidad y evaluación de LLM del descubrimiento a la maestría
- Arize AI: observabilidad y evaluación de los LLM
- OpenInference: trazar las aplicaciones de IA
- Instalar Phoenix y trazar una aplicación
- Práctica: Instalar Phoenix y trazar una primera aplicación LLM
- Trazar un RAG y un agente
- Práctica: Trazar un RAG y sesiones
- Evaluar con LLM jueces
- Práctica: Evaluar las respuestas con código y un LLM juez
- Datasets, experimentos y prompts
- Práctica: Comparar dos prompts con un experimento
- Arize en producción
- Práctica final: Observabilidad LLM de producción con Phoenix
- Buenas prácticas de Arize y OpenInference
Administración Linux: del descubrimiento a la maestría
Explorar ↗
- Administración Linux: del descubrimiento a la maestría
- Linux y Unix: distribuciones y comandos esenciales
- Arquitectura de un sistema Linux
- El shell Bash y los archivos
- Práctica: Analizar logs en la línea de comandos
- Usuarios, grupos, sudo y permisos
- Práctica: Cuentas, carpeta de equipo, sudo y ACL
- Paquetes, servicios systemd y logs
- Práctica: Crear y gestionar un servicio systemd
- Discos, sistemas de archivos y LVM
- Práctica: LVM, fstab y ampliación en caliente
- Red, cortafuegos y SSH
- Práctica: Diagnóstico de red, SSH con clave y cortafuegos
- Procesos, memoria y rendimiento
- Seguridad y endurecimiento
- Scripts Bash robustos
- Práctica: Un script de copia de seguridad robusto y programado
- Copias de seguridad, supervisión y resolución de problemas
- Práctica final: Preparar un servidor para producción y resolver un incidente
- Buenas prácticas de Linux
- LFCS
- RHCSA
Vector: del descubrimiento a la maestría
Explorar ↗
- Vector: del descubrimiento a la maestría
- Panorama de los recopiladores de logs
- Vector: topología y componentes
- Las sources en detalle
- Las transforms en detalle
- Los sinks en detalle
- VRL y pruebas unitarias
- TP: Analizar logs de nginx con Vector y VRL
- TP final: Pruebas unitarias de Vector y enmascaramiento de datos personales
- ¿Fluent Bit o Vector?
- Buenas prácticas de recopilación
ClickStack: del descubrimiento a la maestría
AWS: del descubrimiento a la maestría
Explorar ↗
- AWS: del descubrimiento a la maestría
- Comprender AWS: infraestructura, cuentas, herramientas y precios
- IAM: identidades, roles y políticas
- La red: VPC, subredes, enrutamiento y seguridad
- Cómputo: EC2, Auto Scaling, Lambda y contenedores
- Almacenamiento: S3, EBS, EFS y copias de seguridad
- Bases de datos: RDS, Aurora, DynamoDB
- Supervisar y asegurar: CloudWatch, CloudTrail, KMS, GuardDuty
- Observabilidad en AWS: CloudWatch, X-Ray, ADOT, Prometheus y Grafana
- Infraestructura como código y Well-Architected
- Controlar los costes de AWS
- Práctica: Almacenamiento S3 con LocalStack
- Práctica: Una API serverless (API Gateway, Lambda, DynamoDB) en LocalStack
- Práctica: Infraestructura como código y desacoplamiento con SQS y SNS (Terraform en LocalStack)
- Buenas prácticas de AWS
- Guía de preparación: Cloud Practitioner (CLF-C02)
- AWS Certified Cloud Practitioner (CLF-C02)
- Guía de preparación: Solutions Architect Associate (SAA-C03)
- AWS Certified Solutions Architect – Associate (SAA-C03)
Microsoft Azure: del descubrimiento a la maestría
Explorar ↗
- Microsoft Azure: del descubrimiento a la maestría
- Comprender Azure: regiones, jerarquía, herramientas y precios
- Entra ID, RBAC y Azure Policy
- La red de Azure
- Cómputo: VM, App Service, Functions y contenedores
- El almacenamiento de Azure
- Las bases de datos de Azure
- Supervisar y proteger Azure
- Observabilidad en Azure: Azure Monitor, Log Analytics, Application Insights
- Bicep, Terraform y control de costes
- Práctica: Blob y Queue Storage con Azurite
- Práctica: Una Azure Function activada por una cola, en local
- Práctica: Infraestructura como código con Bicep (validación local y what-if)
- Buenas prácticas de Azure
- Guía de preparación: AZ-900
- Microsoft Azure Fundamentals (AZ-900)
- Guía de preparación: AZ-104
- Microsoft Azure Administrator Associate (AZ-104)
Google Cloud: del descubrimiento a la maestría
Explorar ↗
- Google Cloud: del descubrimiento a la maestría
- Comprender Google Cloud
- IAM en Google Cloud
- La red de Google Cloud
- Cómputo en Google Cloud
- El almacenamiento de Google Cloud
- Las bases de datos de Google Cloud
- Operar Google Cloud
- Observabilidad en Google Cloud: Monitoring, Logging, Trace, Profiler
- Práctica: Mensajería con el emulador de Pub/Sub
- Práctica: Una API con el Functions Framework y el emulador de Firestore
- Práctica: Cloud Storage en local con fake-gcs-server
- Buenas prácticas de Google Cloud
- Guía de preparación: Cloud Digital Leader
- Google Cloud Digital Leader
- Guía de preparación: Associate Cloud Engineer
- Google Associate Cloud Engineer
OVHcloud: del descubrimiento a la maestría
Explorar ↗
- OVHcloud: del descubrimiento a la maestría
- Comprender OVHcloud
- Identidades y accesos
- La red del Public Cloud
- Instancias y Managed Kubernetes
- El almacenamiento de OVHcloud
- Las bases de datos gestionadas
- Operar OVHcloud
- Práctica: Object Storage compatible con S3 simulado con MinIO
- Práctica: El flujo de Managed Kubernetes simulado con k3d
- Práctica: Terraform para OVHcloud probado con proveedores simulados
- Buenas prácticas de OVHcloud
Terraform: del descubrimiento a la maestría
Explorar ↗
- Terraform: del descubrimiento a la maestría
- Principios, arquitectura y flujo de trabajo
- El lenguaje HCL
- El estado: backends, bloqueo, importación
- Los módulos
- Entornos y organización
- Probar y asegurar
- Terraform en CI/CD
- Terraform en varias nubes
- Práctica: Primeros pasos con Terraform en LocalStack
- Práctica: Estado remoto, bloqueo, importación y refactorización
- Práctica: Un módulo probado (terraform test, tflint, Checkov)
- Buenas prácticas de Terraform
- Guía de preparación: Terraform Associate
- HashiCorp Certified: Terraform Associate (004)