Curso de GNU/Linux

Instalar GNU/Linux en máquina virtual con red, disco, usuario, hostname, zona horaria, repositorios y particionado controlado.

Diseñar particiones separadas para `/`, `/home`, `/var`, `/tmp`, `/boot` o swap cuando la operación lo justifica.

Elegir entre instalación mínima, servidor, escritorio, cloud image o imagen personalizada según finalidad del sistema.

Configurar red inicial, nombre de host, DNS, idioma, teclado, zona horaria y repositorios oficiales.

Crear snapshots tras la instalación base para poder revertir errores durante prácticas o cambios de configuración.

Evitar instalar paquetes innecesarios que aumentan superficie de ataque, consumo, mantenimiento y complejidad.

Validar arranque, usuarios, sudo, SSH, conectividad, actualización y estado de servicios básicos.

Documentar credenciales de laboratorio, IPs, roles de máquina, distribución, versión y propósito de cada VM.

Preparar un servidor y un cliente Linux para practicar administración remota, red, servicios y troubleshooting.

Construir una plantilla de instalación corporativa con checklist, particionado, hardening inicial y verificación.

Comprender el flujo de arranque desde firmware, bootloader, kernel, initramfs, PID 1 y servicios iniciales.

Revisar GRUB, entradas de arranque, parámetros del kernel, modo recovery y selección de versiones disponibles.

Analizar initramfs como entorno temprano necesario para montar discos, drivers, cifrado, LVM o root filesystem.

Interpretar mensajes de arranque con `dmesg`, journal, consola, logs del kernel y servicios fallidos.

Resolver problemas básicos de boot: kernel panic de laboratorio, root no encontrado, fstab roto o servicio bloqueante.

Aplicar cambios de kernel con prudencia, manteniendo versiones anteriores y plan de rollback.

Comprender ramas mainline, stable y longterm del kernel para interpretar ciclo de vida y soporte técnico.

Evitar tocar parámetros de arranque en sistemas productivos sin snapshot, consola de recuperación o ventana de mantenimiento.

Documentar cambios de bootloader, kernel, drivers y módulos para auditoría y soporte posterior.

Construir una práctica de recuperación de arranque con fstab incorrecto, GRUB y modo rescue.

Entender la jerarquía de directorios como base para localizar configuración, binarios, librerías, logs, datos y ficheros temporales.

Relacionar rutas como `/etc`, `/var`, `/usr`, `/opt`, `/home`, `/root`, `/tmp`, `/run`, `/proc`, `/sys` y `/dev` con su función operativa.

Aplicar el Filesystem Hierarchy Standard como referencia de ubicación y uniformidad en sistemas tipo Unix.

Usar comandos como `ls`, `find`, `stat`, `file`, `tree`, `du`, `df`, `ln`, `readlink` y `realpath` con criterio.

Diferenciar ficheros regulares, directorios, enlaces simbólicos, enlaces duros, sockets, pipes, dispositivos y pseudo-ficheros.

Evitar borrar rutas críticas sin comprender montajes, enlaces, permisos, procesos abiertos y servicios dependientes.

Organizar datos de aplicaciones bajo rutas mantenibles, con separación entre binarios, configuración, logs y datos persistentes.

Crear políticas de limpieza para temporales, logs rotados, cachés, paquetes descargados y artefactos de despliegue.

Documentar rutas corporativas para aplicaciones internas, backups, scripts, certificados, logs y datos compartidos.

Construir una guía de navegación y localización de evidencias en un servidor Linux realista.

Dominar Bash o Zsh para trabajar con historial, autocompletado, expansión, redirecciones, pipes, variables y sustitución de comandos.

Usar herramientas de texto como `cat`, `less`, `head`, `tail`, `grep`, `awk`, `sed`, `cut`, `sort`, `uniq`, `wc` y `jq`.

Crear comandos compuestos que permitan analizar logs, filtrar datos, extraer campos y preparar informes rápidos.

Configurar aliases, funciones, prompt, historial seguro y perfiles de shell sin ocultar errores ni guardar secretos.

Trabajar con editores como Vim, Nano o Micro para modificar configuración con control y copia de seguridad previa.

Evitar comandos destructivos sin revisar expansión de variables, comodines, rutas absolutas y permisos de ejecución.

Usar `screen`, `tmux` o sesiones persistentes para tareas remotas, mantenimiento y procesos largos.

Registrar comandos relevantes en documentación técnica sin exponer credenciales, tokens o datos sensibles.

Crear una estructura personal de trabajo para scripts, notas, evidencias, configuraciones y plantillas reutilizables.

Construir un toolkit de terminal para administración diaria con aliases, funciones, filtros y plantillas seguras.

Crear usuarios y grupos con criterios de responsabilidad, servicio, administración, soporte, despliegue y acceso temporal.

Gestionar contraseñas, expiración, bloqueo, shell, home, UID, GID, grupos suplementarios y cuentas de sistema.

Configurar `sudo` mediante reglas específicas, evitando conceder acceso root completo cuando solo hace falta un comando concreto.

Diferenciar cuenta humana, cuenta técnica, cuenta de servicio, cuenta temporal y cuenta de emergencia.

Evitar cuentas compartidas que destruyen trazabilidad, responsabilidad y capacidad de auditoría.

Revisar ficheros como `/etc/passwd`, `/etc/shadow`, `/etc/group` y `/etc/sudoers` sin editarlos de forma insegura.

Aplicar mínimo privilegio y revisar pertenencia a grupos sensibles como `sudo`, `wheel`, `docker`, `adm`, `systemd-journal` o equivalentes.

Auditar accesos locales y remotos mediante logs, últimos inicios de sesión, claves SSH y actividad administrativa.

Diseñar procesos de alta, baja, revisión y caducidad de usuarios en servidores corporativos.

Construir una matriz de usuarios, grupos y privilegios para administración segura de un servidor Linux.

Entender permisos tradicionales de lectura, escritura y ejecución sobre propietario, grupo y otros.

Aplicar `chmod`, `chown`, `chgrp`, `umask`, bits especiales, sticky bit, setuid y setgid con casos reales.

Usar ACLs cuando los permisos POSIX básicos no permiten expresar necesidades de acceso por varios usuarios o grupos.

Revisar Linux capabilities para conceder privilegios concretos a procesos sin ejecutar todo como root.

Evitar permisos 777 como solución rápida, porque abren riesgo de modificación, fuga, ejecución maliciosa y pérdida de control.

Diseñar permisos para aplicaciones web, directorios compartidos, logs, backups, scripts, claves privadas y datos sensibles.

Detectar ficheros con setuid, permisos inseguros, propietarios incorrectos o datos accesibles por usuarios no autorizados.

Documentar permisos esperados por ruta crítica y crear controles de drift o cambios no autorizados.

Resolver incidencias de permisos diferenciando usuario efectivo, grupo, ACL, umask, contexto de seguridad y proceso.

Construir una práctica de corrección de permisos en aplicación, logs, scripts y directorio compartido.

Analizar procesos con `ps`, `top`, `htop`, `pgrep`, `pstree`, `pidstat` y `/proc`.

Comprender estados de proceso, procesos zombie, procesos huérfanos, prioridades, nice, señales y jerarquía padre-hijo.

Gestionar procesos con `kill`, `pkill`, `killall`, `nice`, `renice`, `nohup`, background jobs y foreground jobs.

Evitar matar procesos críticos sin identificar servicio, dependencia, usuario, socket, ficheros abiertos e impacto.

Usar `lsof`, `fuser`, `strace` y herramientas de diagnóstico para entender bloqueos, ficheros abiertos y llamadas de sistema.

Analizar consumo de CPU, memoria, I/O, red y número de procesos antes de atribuir una incidencia a la aplicación.

Relacionar procesos con servicios systemd, cgroups, límites, logs y unidades de ejecución.

Configurar límites básicos con `ulimit` y políticas de recursos cuando una aplicación consume demasiado.

Documentar incidencias de proceso con PID, comando, usuario, consumo, logs, causa probable y acción aplicada.

Construir un ejercicio de troubleshooting con proceso bloqueado, puerto ocupado, consumo alto y cierre controlado.

Comprender systemd como conjunto de componentes básicos para Linux, incluyendo gestor de sistema y servicios que arranca como PID 1.

Gestionar servicios con `systemctl`, revisando estado, arranque automático, dependencias, fallos, reinicios y logs asociados.

Crear unidades `.service` para aplicaciones internas con usuario dedicado, directorio de trabajo, variables y política de reinicio.

Usar targets para entender niveles de funcionamiento, modo multiusuario, modo gráfico, rescue y emergency.

Configurar timers como alternativa moderna a cron cuando se necesita trazabilidad, integración con systemd y logs claros.

Analizar logs con `journalctl`, filtrando por unidad, boot, prioridad, intervalo, usuario, PID o mensaje.

Crear overrides en lugar de editar unidades de proveedor, manteniendo configuración mantenible y actualizable.

Aplicar hardening de unidades con opciones como usuario no privilegiado, restricciones de filesystem, namespaces y límites.

Resolver servicios que no arrancan diferenciando error de permisos, binario, dependencia, puerto, entorno, working directory o configuración.

Construir un servicio systemd completo con timer, logs, política de reinicio, hardening básico y documentación.

Gestionar paquetes con APT, DNF, Zypper o gestores equivalentes según distribución y política corporativa.

Diferenciar repositorio oficial, repositorio de proveedor, paquete local, paquete firmado, snap, flatpak, AppImage y compilación manual.

Validar firmas, claves, origen y reputación antes de añadir repositorios externos o instalar software de terceros.

Evitar instalar paquetes manualmente sin inventario, owner, motivo, versión y procedimiento de actualización.

Aplicar actualizaciones de seguridad, actualizaciones mayores, holds, rollback y limpieza de paquetes huérfanos.

Usar repositorios internos o mirrors corporativos cuando la empresa necesita control, auditoría, rendimiento o aislamiento.

Crear políticas para software permitido, versiones soportadas, ventanas de parcheo y dependencias críticas.

Diagnosticar conflictos de dependencias, paquetes rotos, locks, repositorios inaccesibles y cambios de versión inesperados.

Documentar instalaciones con comandos, repositorios, versiones, impacto y verificación posterior.

Construir un flujo corporativo de actualización de paquetes con pruebas, snapshot, despliegue y rollback.

Gestionar discos con `lsblk`, `blkid`, `fdisk`, `parted`, `mkfs`, `mount`, `findmnt` y `/etc/fstab`.

Elegir sistemas de ficheros como ext4, XFS o Btrfs según estabilidad, snapshots, rendimiento, soporte y uso previsto.

Configurar montajes persistentes, opciones de seguridad, rendimiento, cuotas, permisos y comprobaciones de arranque.

Evitar errores en `/etc/fstab` que impiden arrancar el sistema o bloquean servicios críticos.

Analizar consumo de disco por directorio, inodos, ficheros abiertos borrados, logs crecientes y snapshots acumulados.

Gestionar swap, swappiness, ficheros swap y particiones swap según carga y política del servidor.

Planificar crecimiento de disco, separación de datos, logs, aplicaciones y backups para evitar caídas por falta de espacio.

Revisar integridad y errores de disco con herramientas de SMART, logs del kernel y mensajes del sistema.

Documentar layout de almacenamiento, UUIDs, puntos de montaje, tamaño, uso, owner y criticidad.

Construir una práctica de ampliación de disco, creación de partición, montaje persistente y recuperación de fstab.

Usar LVM para gestionar volúmenes físicos, grupos de volúmenes, volúmenes lógicos, ampliación y reducción controlada.

Crear snapshots LVM para operaciones de mantenimiento, pruebas de cambio o backup consistente cuando el caso lo permite.

Configurar RAID por software con `mdadm` para tolerancia a fallos, rendimiento o laboratorios de disponibilidad.

Diferenciar RAID, backup, snapshot, réplica y alta disponibilidad para evitar falsas expectativas de recuperación.

Aplicar cifrado con LUKS cuando se protegen discos, portátiles, backups, volúmenes sensibles o entornos regulados.

Planificar recuperación de claves, passphrases, headers LUKS y procedimientos de emergencia.

Evitar experimentar con reducción de volúmenes o cambios de RAID sin backup, snapshot y prueba en laboratorio.

Monitorizar estado de RAID, discos degradados, errores SMART, latencia e integridad del almacenamiento.

Documentar operaciones de almacenamiento con antes/después, comandos, riesgos, validación y rollback.

Construir un laboratorio con LVM, volumen cifrado, RAID simulado, snapshot y ampliación controlada.

Configurar interfaces, direcciones IP, rutas, gateway, DNS, hostname, MTU y resolución de nombres.

Usar herramientas como `ip`, `ss`, `ping`, `traceroute`, `dig`, `resolvectl`, `nmcli`, `tcpdump` y `ethtool`.

Diferenciar NetworkManager, systemd-networkd, netplan, wicked u otros modelos según distribución.

Diagnosticar problemas de red separando capa física, IP, routing, DNS, firewall, proxy, TLS y aplicación.

Configurar VLANs, bonding, bridge, interfaces virtuales y redes de laboratorio cuando el entorno lo exige.

Evitar cambios remotos de red sin consola alternativa, ventana de mantenimiento o rollback automático.

Documentar configuración de red con IPs, interfaces, rutas, DNS, firewall, VLANs y dependencias.

Validar conectividad antes y después de cambios con pruebas repetibles y evidencias.

Analizar tráfico con capturas limitadas, evitando almacenar datos sensibles o tráfico fuera de alcance.

Construir un laboratorio de red con dos servidores, rutas, DNS, firewall y troubleshooting guiado.

Configurar OpenSSH para administración remota segura con claves, usuarios permitidos, puertos, banners y restricciones.

Deshabilitar acceso root directo y autenticación por contraseña cuando la política corporativa exige claves y MFA externo.

Usar `ssh-agent`, claves con passphrase, bastiones, jump hosts y configuración de cliente en `~/.ssh/config`.

Gestionar `authorized_keys`, permisos de claves, rotación, baja de accesos y control de usuarios con privilegios.

Evitar compartir claves privadas, copiar accesos entre usuarios o mantener llaves de antiguos empleados.

Configurar túneles SSH, port forwarding y SOCKS de forma controlada para administración y diagnóstico.

Auditar accesos SSH con logs, últimos inicios de sesión, intentos fallidos y comportamiento anómalo.

Proteger SSH con firewall, fail2ban, rate limiting, listas permitidas o segmentación de red.

Documentar procedimientos de alta, baja, emergencia, recuperación y acceso mediante bastión.

Construir una configuración SSH corporativa con claves, bastión, restricción de usuarios y auditoría.

Comprender filtrado de paquetes en Linux y diferencias prácticas entre nftables, firewalld, iptables legacy y herramientas de distribución.

Definir política por defecto, reglas de entrada, salida, forwarding, servicios permitidos, origen, puerto y protocolo.

Usar firewalld para administrar zonas, servicios, puertos, rich rules y cambios persistentes en entornos compatibles.

Trabajar con nftables cuando se necesita control detallado, reglas versionables y configuración más explícita.

Evitar abrir puertos por comodidad sin justificar servicio, origen, necesidad, monitorización y owner.

Integrar firewall local con seguridad perimetral, security groups cloud, load balancers y segmentación de red.

Probar reglas antes de cerrar sesión remota para no bloquear el acceso administrativo.

Crear logs de firewall cuando se investigan denegaciones, ataques, ruido de red o problemas de conectividad.

Documentar matriz de puertos permitidos por servidor, servicio, origen, destino, entorno y responsable.

Construir un firewall de servidor con SSH restringido, web permitido, logs controlados y pruebas de conectividad.

Configurar cliente DNS, resolución local, caché, búsqueda de dominios, `/etc/hosts` y diagnóstico de nombres.

Sincronizar tiempo con NTP o chrony para evitar problemas en logs, certificados, Kerberos, backups y auditoría.

Desplegar un servidor web básico con Nginx o Apache para publicar una aplicación, landing interna o health check.

Configurar proxy directo o inverso según necesidad, diferenciando acceso corporativo, TLS, headers y backend.

Entender el correo local del sistema para alertas, cron, servicios y notificaciones administrativas.

Evitar exponer servicios a internet sin firewall, TLS, actualización, logs y configuración mínima de seguridad.

Crear certificados de laboratorio y preparar integración con PKI corporativa o ACME cuando procede.

Revisar logs de servicio, puertos, usuarios, configuración y dependencias antes de culpar a la red.

Documentar cada servicio con finalidad, owner, puertos, ficheros de configuración, logs y procedimiento de reinicio.

Construir un servidor interno con DNS local, chrony, Nginx, TLS de laboratorio y logs centralizados.

Analizar logs con journald, syslog, ficheros en `/var/log`, logs de aplicación y logs del kernel.

Configurar rotación de logs para evitar discos llenos, pérdida de evidencias o crecimiento descontrolado.

Centralizar logs hacia un SIEM, syslog remoto, OpenSearch, Elastic, Loki u otra plataforma aprobada.

Crear alertas sobre errores recurrentes, servicios caídos, intentos de acceso, disco lleno, CPU alta o fallos de backup.

Usar métricas básicas de CPU, memoria, disco, red, procesos y servicios para detectar degradación antes de caída.

Evitar logs con secretos, tokens, datos personales o información excesiva que incumpla privacidad o seguridad.

Configurar auditoría con auditd cuando se necesita trazabilidad de accesos, cambios de ficheros o comandos sensibles.

Documentar qué se monitoriza, qué se alerta, quién responde y qué runbook se sigue ante cada evento.

Diferenciar observabilidad operativa, auditoría de seguridad, troubleshooting y reporting ejecutivo.

Construir un esquema de logs y métricas para un servidor Linux con servicio web y acceso SSH.

Diagnosticar rendimiento con `top`, `htop`, `vmstat`, `iostat`, `pidstat`, `free`, `sar`, `ss`, `iftop` y herramientas equivalentes.

Diferenciar problemas de CPU, memoria, swap, disco, red, bloqueo de aplicación, base de datos o saturación externa.

Analizar load average con contexto de cores, procesos bloqueados, I/O wait y concurrencia real.

Detectar memory leaks, presión de memoria, swap excesivo, caché de página y procesos consumidores.

Revisar rendimiento de disco con latencia, throughput, colas, errores, sistema de ficheros y tipo de almacenamiento.

Analizar puertos, conexiones, sockets, retransmisiones, backlog y límites de red.

Configurar límites de systemd, cgroups, ulimit y parámetros de aplicación cuando un servicio necesita control de recursos.

Evitar tunings aleatorios de kernel o sysctl sin medición previa, hipótesis clara y prueba controlada.

Crear baselines de rendimiento para comparar antes y después de cambios o incidencias.

Construir un caso de troubleshooting de rendimiento con CPU, memoria, disco y red afectados.

Aplicar hardening inicial con actualización, paquetes mínimos, servicios necesarios, firewall, SSH seguro y usuarios controlados.

Revisar servicios activos, puertos abiertos, paquetes instalados, permisos peligrosos y procesos innecesarios.

Configurar políticas de contraseñas, bloqueo, caducidad, MFA externo cuando proceda y revisión de cuentas inactivas.

Proteger ficheros sensibles, claves privadas, certificados, backups, scripts y directorios de configuración.

Usar herramientas de auditoría como Lynis u otras aprobadas para detectar debilidades y priorizar mejoras.

Evitar benchmarks de seguridad aplicados de forma ciega sin considerar rol del servidor, aplicación y operación real.

Relacionar hardening con CIS, guías internas, normativa, riesgo, criticidad y coste operativo.

Crear baseline de seguridad para servidores nuevos y controles periódicos de drift.

Documentar excepciones de seguridad con motivo, owner, fecha de revisión y control compensatorio.

Construir una checklist de hardening para servidor web, servidor interno y host de administración.

Comprender diferencias entre permisos clásicos y control obligatorio de acceso mediante SELinux o AppArmor.

Revisar por qué algunas distribuciones priorizan SELinux y otras AppArmor, según familia, soporte y configuración por defecto.

Interpretar contextos, perfiles, modos enforce, permissive, complain, denials y logs asociados.

Evitar desactivar SELinux o AppArmor como primera solución sin entender el bloqueo y crear política adecuada.

Diagnosticar errores donde permisos POSIX parecen correctos, pero la política MAC impide acceso a fichero, puerto o recurso.

Aplicar ajustes de contexto, booleanos, perfiles o reglas de forma controlada y documentada.

Crear políticas o perfiles mínimos para servicios internos cuando se requiere contención adicional.

Integrar MAC con systemd hardening, usuarios dedicados, firewall y permisos de ficheros.

Documentar excepciones y cambios de política con evidencia, justificación y revisión periódica.

Construir un laboratorio donde SELinux o AppArmor bloquea una app y se corrige sin desactivar seguridad global.

Diseñar estrategia de backup según RPO, RTO, criticidad, datos, configuración, bases de datos, logs y retención.

Diferenciar copia de fichero, snapshot, backup de aplicación, backup de base de datos, réplica y disaster recovery.

Usar herramientas como rsync, tar, borg, restic, snapshots LVM/Btrfs o soluciones corporativas según escenario.

Cifrar backups cuando contienen datos sensibles, configuraciones, claves, dumps o información de clientes.

Evitar confiar en backups no probados; la restauración debe verificarse con ejercicios periódicos.

Separar backups locales, externos, offline, inmutables y copias fuera del dominio principal según riesgo.

Documentar qué se copia, frecuencia, ubicación, retención, owner, prueba de restauración y procedimiento de emergencia.

Preparar recuperación de configuración, usuarios, servicios, certificados, datos de aplicación y dependencias.

Medir éxito de backups, errores, duración, crecimiento, capacidad y tiempos reales de restauración.

Construir un plan completo de backup y restauración para un servidor web con base de datos de laboratorio.

Usar cron para tareas periódicas simples, entendiendo entorno limitado, rutas, usuarios, logs y salida estándar.

Configurar anacron cuando el sistema no está siempre encendido y se necesitan tareas aplazadas.

Diseñar systemd timers cuando se requiere trazabilidad, dependencias, journald, randomización o integración con unidades.

Evitar tareas programadas invisibles sin owner, documentación, logs o control de errores.

Crear scripts idempotentes que puedan reejecutarse sin dañar datos ni duplicar acciones.

Registrar salida, errores, códigos de retorno y tiempo de ejecución de cada tarea relevante.

Proteger scripts de cron con permisos correctos, rutas absolutas, variables controladas y validación de entrada.

Crear alertas cuando una tarea crítica falla o no se ejecuta en la ventana esperada.

Documentar calendario operativo de tareas con frecuencia, propósito, usuario, impacto y procedimiento de pausa.

Construir un sistema de tareas programadas para backup, limpieza, reporte, chequeo de servicios y alerta.

Escribir scripts Bash con `set -euo pipefail`, funciones, variables, validaciones, logs y códigos de salida claros.

Controlar argumentos, opciones, entrada de usuario, ficheros temporales, locks y ejecución concurrente.

Evitar scripts frágiles que dependen de rutas, formatos o permisos no validados.

Crear scripts idempotentes para instalación, configuración, chequeos, rotación, despliegue o verificación.

Usar shellcheck, pruebas simples y revisión de código para mejorar calidad de scripts administrativos.

Gestionar secretos fuera del script mediante variables, ficheros protegidos, vault o mecanismos corporativos.

Documentar cada script con finalidad, requisitos, ejemplos, riesgos, rollback y owner.

Crear salida legible para humanos y salida estructurada para automatizaciones o reportes.

Versionar scripts en Git y desplegarlos mediante procesos controlados.

Construir un conjunto de scripts de administración para alta de usuarios, validación de servicios y reporte de salud.

Usar Ansible para convertir configuración manual en playbooks reproducibles, auditables y versionados.

Crear inventarios, grupos, variables, roles, templates, handlers y tareas idempotentes.

Automatizar instalación de paquetes, usuarios, SSH, firewall, servicios, configuración, hardening y despliegue básico.

Evitar playbooks que ejecutan comandos arbitrarios sin estado deseado, validación o control de cambios.

Proteger variables sensibles con Ansible Vault o mecanismos corporativos de gestión de secretos.

Probar playbooks en laboratorio antes de aplicarlos en servidores reales.

Diseñar roles reutilizables para servidores web, base, seguridad, observabilidad, backup y usuarios.

Documentar ejecución, dependencias, variables, rollback y compatibilidad por distribución.

Integrar Ansible con Git, CI/CD, revisión de cambios y ventanas de mantenimiento.

Construir un playbook completo que configura servidor base, SSH, firewall, Nginx, logs y backup.

Comprender contenedores como procesos aislados mediante namespaces, cgroups, capas de imagen, filesystem y red virtual.

Diferenciar imagen, contenedor, volumen, red, registry, tag, digest, Dockerfile y runtime OCI.

Usar Docker o Podman según política empresarial, seguridad, rootless, compatibilidad y ecosistema.

Ejecutar contenedores de forma controlada con usuarios no root, volúmenes mínimos, puertos necesarios y variables seguras.

Evitar montar `/var/run/docker.sock` o ejecutar contenedores privilegiados sin justificación y controles.

Crear imágenes reproducibles con Dockerfile, minimizando capas, secretos, paquetes innecesarios y superficie de ataque.

Gestionar logs, reinicios, healthchecks, límites de CPU/memoria y persistencia de datos.

Analizar incidencias de contenedores desde host Linux: red, DNS, permisos, volúmenes, procesos y logs.

Documentar despliegues de contenedores con imagen, versión, puertos, volúmenes, secretos, red y owner.

Construir una aplicación de laboratorio en contenedor con servicio, volumen, red, logs y hardening básico.

Comprender KVM/QEMU como base de virtualización nativa en Linux para servidores, laboratorios y plataformas internas.

Gestionar máquinas virtuales con libvirt, `virsh`, virt-manager o herramientas superiores como Proxmox cuando proceda.

Configurar redes NAT, bridge, host-only, VLANs y almacenamiento para VMs de laboratorio o servicios internos.

Crear snapshots, clones, plantillas, cloud-init e imágenes base para acelerar despliegues reproducibles.

Evitar sobreasignar CPU, memoria o disco sin entender overcommit, I/O, NUMA, ballooning y carga real.

Gestionar backups de VMs, exportaciones, migraciones y recuperación de máquinas virtuales.

Monitorizar hosts Linux con métricas de CPU, memoria, disco, red y estado de VMs.

Documentar cada VM con owner, rol, recursos, red, sistema operativo, criticidad y plan de recuperación.

Integrar virtualización con firewall, almacenamiento compartido, backups y control de accesos.

Construir un host de laboratorio KVM con dos VMs, red bridge, snapshot y backup básico.

Administrar instancias Linux en AWS, Azure, Google Cloud, OpenStack u otros entornos cloud.

Diferenciar imagen cloud, cloud-init, metadata service, security groups, claves SSH, snapshots y discos persistentes.

Crear servidores reproducibles con user-data, scripts, Ansible, Terraform o plantillas cloud aprobadas.

Evitar configuraciones manuales no documentadas que impiden reconstruir servidores tras fallo o escalado.

Gestionar firewalls cloud y firewall local sin crear reglas contradictorias o exposición accidental.

Proteger instancias con roles, identidades gestionadas, mínimos privilegios, logs y rotación de claves.

Monitorizar recursos cloud: CPU, memoria, disco, red, coste, snapshots, backups y eventos de plataforma.

Preparar imágenes base endurecidas para servidores Linux cloud de la empresa.

Documentar diferencias entre administración Linux tradicional y operación sobre infraestructura cloud.

Construir una instancia Linux cloud de laboratorio con cloud-init, SSH seguro, firewall y servicio web.

Diferenciar alta disponibilidad, balanceo, failover, backup, réplica y disaster recovery.

Diseñar servicios stateless y stateful con dependencias claras, almacenamiento persistente y recuperación planificada.

Usar balanceadores, reverse proxies, keepalived, Pacemaker/Corosync o soluciones cloud según criticidad.

Evitar prometer alta disponibilidad si no se han probado fallos reales, recuperación y split-brain.

Configurar health checks, reinicio automático, watchdogs, límites y dependencias para servicios críticos.

Planificar mantenimiento sin caída mediante nodos redundantes, drenaje, backups y comunicación.

Documentar RTO, RPO, owners, procedimientos de failover y criterios de vuelta a normalidad.

Medir disponibilidad, tiempos de recuperación, errores de failover y cobertura de monitorización.

Relacionar HA con diseño de aplicación, base de datos, almacenamiento, red y DNS.

Construir un laboratorio de servicio redundante con proxy, dos backends, health check y prueba de caída.

Gestionar certificados TLS para servicios internos, externos, APIs, proxies, paneles de administración y herramientas de monitorización.

Diferenciar certificado, clave privada, CSR, CA, cadena, SAN, expiración, trust store y renovación.

Usar OpenSSL, ACME, certbot, step-ca o PKI corporativa según entorno y política.

Proteger claves privadas con permisos estrictos, owner correcto, backups seguros y rotación planificada.

Evitar certificados caducados o mal instalados que rompen servicios, integraciones y confianza de usuarios.

Crear alertas de expiración y procedimientos de renovación antes de ventanas críticas.

Gestionar secretos mediante ficheros protegidos, variables seguras, vaults, gestores cloud o systemd credentials cuando proceda.

Evitar secretos en scripts, Git, logs, histórico de shell, contenedores, imágenes o documentación compartida.

Documentar certificados y secretos con owner, fecha, servicio, ubicación, rotación y plan de emergencia.

Construir un servicio HTTPS con certificado de laboratorio, renovación simulada y permisos correctos.

Preparar aplicaciones internas como servicios systemd con usuarios dedicados, directorios, logs, variables y permisos.

Diseñar estructura de despliegue con releases, symlinks, configuración separada, logs y directorios persistentes.

Gestionar variables de entorno, ficheros `.env`, secretos, puertos, sockets, workers y dependencias.

Evitar ejecutar aplicaciones como root o desde sesiones interactivas no controladas.

Crear procedimientos de despliegue con precheck, backup, parada, despliegue, migración, arranque, health check y rollback.

Configurar Nginx o Apache como reverse proxy con TLS, headers, compresión, logs y límites básicos.

Registrar logs de aplicación en journald, ficheros rotados o plataforma centralizada.

Monitorizar salud de la aplicación con endpoints, métricas, procesos y alertas.

Documentar arquitectura de aplicación, puertos, usuarios, rutas, dependencias, comandos y owners.

Construir un despliegue completo de aplicación de laboratorio con systemd, Nginx, TLS, logs y rollback.

Aplicar un método de diagnóstico basado en hipótesis, evidencias, cambios recientes, alcance e impacto.

Diferenciar síntomas y causa raíz para no resolver incidencias con reinicios que solo aplazan el problema.

Revisar capas en orden: usuario, permisos, servicio, logs, red, DNS, disco, memoria, CPU, configuración y dependencias externas.

Usar herramientas como `journalctl`, `systemctl`, `ss`, `lsof`, `strace`, `tcpdump`, `dig`, `curl`, `iostat` y `vmstat`.

Evitar cambios simultáneos múltiples que impiden saber qué corrigió la incidencia.

Registrar línea temporal de eventos, comandos ejecutados, resultados, decisiones y estado final.

Crear runbooks para incidentes frecuentes: servicio caído, disco lleno, certificado caducado, DNS roto o permiso incorrecto.

Definir criterios de escalado cuando la incidencia afecta seguridad, disponibilidad, datos o clientes internos.

Convertir incidentes repetidos en automatizaciones, alertas, documentación o cambios de diseño.

Construir un ejercicio integral de troubleshooting con fallos combinados de red, permisos, disco, servicio y TLS.

Crear documentación útil para servidores: propósito, owner, distribución, versión, IP, servicios, puertos, backups y dependencias.

Mantener runbooks de instalación, actualización, despliegue, recuperación, troubleshooting, cambio y baja de sistemas.

Definir estándares de naming, usuarios, grupos, rutas, logs, paquetes, firewall, hardening y monitorización.

Evitar documentación que describe cómo debería estar el sistema pero no coincide con la configuración real.

Usar Git para versionar scripts, Ansible, configuraciones, plantillas, documentación y procedimientos.

Crear checklists para cambios, actualizaciones, accesos, auditoría, backup, despliegue y revisión periódica.

Definir ownership de servidores, servicios, datos, certificados, backups, alertas y tareas programadas.

Medir madurez operativa con disponibilidad, incidencias, parches, backups probados, documentación vigente y alertas útiles.

Preparar handover técnico para que un servidor pueda ser operado por otro miembro del equipo sin dependencia personal.

Construir un estándar corporativo de operación GNU/Linux con plantillas, roles, checks y ciclo de vida.

Diseñar una arquitectura de laboratorio con dos servidores GNU/Linux, red interna, cliente de administración y servicios empresariales simulados.

Instalar y preparar una distribución actual con particionado, usuario sudo, SSH seguro, repositorios, hostname, red y snapshot inicial.

Configurar almacenamiento con volumen adicional, montaje persistente, permisos, cuota, backup y prueba de restauración.

Desplegar una aplicación interna como servicio systemd con usuario dedicado, logs, variables, límites, reinicio y health check.

Publicar la aplicación mediante Nginx o Apache con TLS de laboratorio, reverse proxy, headers básicos y firewall.

Automatizar configuración base con Ansible, incluyendo usuarios, paquetes, SSH, firewall, servicio, logs y backup.

Aplicar hardening con mínimo privilegio, actualizaciones, auditoría básica, SELinux o AppArmor cuando proceda y revisión de permisos.

Configurar monitorización y logs con journald, métricas básicas, alertas simuladas y dashboard o informe operativo.

Ejecutar troubleshooting planificado con fallos de permisos, red, certificado, disco y servicio, documentando causa raíz.

Presentar el proyecto final con arquitectura, configuración, evidencias, scripts, runbooks, riesgos, controles y plan de mejora continua.