Curso de Slackware Linux

Descargar la ISO oficial, verificar checksums y preparar medios de instalación seguros para máquina virtual o servidor físico.

Crear una máquina virtual adecuada con disco, red, memoria, UEFI o BIOS y snapshots para prácticas controladas.

Diseñar particionado con `fdisk`, `cfdisk` o `parted`, diferenciando `/`, `/home`, `/var`, swap, EFI y particiones de datos.

Formatear sistemas de archivos con criterios de uso, rendimiento, recuperación y compatibilidad.

Seleccionar series de paquetes durante la instalación entendiendo qué aporta cada grupo y qué consecuencias tiene una instalación mínima.

Configurar fuente de instalación desde ISO, mirror, red local o repositorio montado según el laboratorio.

Ejecutar instalación paso a paso, revisando prompts, paquetes, scripts finales y configuración base.

Configurar hostname, red, zona horaria, contraseña de root, usuarios iniciales y servicios básicos tras el primer arranque.

Validar instalación revisando versión, kernel, paquetes instalados, servicios activos, logs y conectividad.

Documentar una checklist post-instalación para repetir despliegues sin depender de memoria o capturas improvisadas.

Explorar la jerarquía de archivos de Slackware y diferenciar sistema base, configuración, paquetes, logs, documentación y scripts de arranque.

Comprender el papel central de `/etc` como ubicación de configuración real del sistema y de muchos servicios.

Revisar `/etc/rc.d`, `/etc/inittab`, `/etc/fstab`, `/etc/profile`, `/etc/slackpkg`, `/etc/hosts` y otros archivos críticos.

Identificar documentación local en `/usr/doc`, páginas man, archivos README y textos incluidos en la distribución.

Establecer una estrategia de backups de configuración antes de modificar archivos sensibles.

Usar `diff`, `cp -a`, `rsync` y control de versiones para comparar configuraciones y conservar historial.

Diferenciar configuración del sistema, configuración de usuario, configuración de servicio y configuración generada durante instalación.

Crear convenciones para comentarios, fechas, responsables y motivo de cambios en archivos críticos.

Evitar modificaciones improvisadas sin prueba, rollback o explicación documental.

Construir un mapa de rutas esenciales para administración diaria, troubleshooting y recuperación.

Comprender el flujo de arranque desde firmware, bootloader, kernel, initrd, `init`, `/etc/inittab` y scripts de inicialización.

Analizar el modelo BSD-style de Slackware y su diferencia frente a systemd y SysV init.

Revisar runlevels habituales y entender cómo Slackware arranca servicios en modo multiusuario, consola o entorno gráfico.

Administrar scripts como `rc.S`, `rc.M`, `rc.inet1`, `rc.inet2`, `rc.local`, `rc.4` y scripts específicos de servicios.

Activar o desactivar servicios mediante permisos de ejecución en scripts `rc.*`.

Crear scripts de arranque propios manteniendo estilo, claridad, dependencias y salida comprensible.

Diagnosticar servicios que no arrancan por rutas incorrectas, permisos, dependencias, variables o errores silenciosos.

Configurar tareas locales en `rc.local` sin convertirlo en un cajón desordenado de comandos no documentados.

Revisar compatibilidad con scripts SysV cuando una aplicación externa lo requiere.

Crear una guía interna para administrar servicios Slackware sin trasladar mecánicamente hábitos de systemd.

Configurar LILO, ELILO o GRUB según tipo de instalación, firmware, preferencias del equipo y compatibilidad del hardware.

Comprender la relación entre kernel, initrd, módulos, root filesystem y parámetros de arranque.

Utilizar herramientas como `mkinitrd` y scripts generadores para preparar initrd cuando el sistema lo necesita.

Instalar o actualizar kernel manteniendo siempre una entrada anterior funcional para recuperación.

Diagnosticar fallos de arranque por kernel incorrecto, initrd ausente, UUID mal definido, partición no montada o bootloader mal instalado.

Entrar en modo rescue desde medio de instalación para montar sistema, chrootear, reinstalar bootloader o corregir configuración.

Revisar logs y mensajes de arranque para identificar fallos de drivers, módulos, fstab, discos o servicios tempranos.

Documentar cada actualización de kernel con versión, motivo, módulos afectados, bootloader actualizado y prueba realizada.

Crear procedimientos de rollback ante kernel no arrancable o sistema inaccesible.

Preparar una estrategia segura para equipos remotos donde un fallo de arranque puede dejar el servidor sin acceso.

Comprender el formato de paquete Slackware y su relación con archivos instalados, scripts de postinstalación y metadatos.

Instalar paquetes con `installpkg` revisando origen, firma, versión, arquitectura y compatibilidad.

Actualizar paquetes con `upgradepkg`, evitando sobrescribir configuraciones sin revisar archivos `.new`.

Eliminar paquetes con `removepkg` entendiendo qué se borra, qué puede quedar como configuración y qué dependencias manuales se rompen.

Explorar paquetes con `explodepkg` para auditar contenido antes de instalarlos.

Crear paquetes simples con `makepkg` para distribuir scripts, herramientas internas o software compilado.

Revisar `/var/log/packages` y `/var/log/scripts` para auditar qué está instalado y qué scripts ejecutó cada paquete.

Comparar paquetes instalados entre servidores para detectar desviaciones y diferencias de configuración.

Documentar instalaciones manuales evitando que el sistema se convierta en una colección de binarios no trazables.

Crear una política interna de paquetes que priorice repositorios oficiales, SlackBuilds revisados y paquetes propios versionados.

Configurar `slackpkg` seleccionando mirrors oficiales adecuados para versión, arquitectura y ubicación.

Ejecutar `slackpkg update`, `slackpkg install-new`, `slackpkg upgrade-all` y `slackpkg clean-system` con orden y criterio.

Revisar ChangeLog y avisos antes de aplicar actualizaciones en sistemas sensibles.

Gestionar archivos de configuración `.new` comparando diferencias antes de reemplazar configuraciones existentes.

Mantener sistemas Slackware actualizados con parches de seguridad sin introducir cambios innecesarios.

Diferenciar actualización dentro de la misma versión estable y salto de versión siguiendo documentación oficial.

Crear ventanas de mantenimiento para actualizar servidores con servicios críticos.

Preparar snapshots, backups o puntos de restauración antes de actualizar paquetes sensibles.

Resolver conflictos de paquetes, mirrors inconsistentes, listas desactualizadas o paquetes eliminados.

Documentar un procedimiento de parcheo Slackware reproducible para entornos corporativos.

Comprender qué es un SlackBuild y por qué Slackware favorece la construcción de paquetes desde scripts transparentes.

Utilizar SlackBuilds.org como fuente de scripts de construcción para software no incluido en la distribución oficial.

Instalar y sincronizar sbopkg para trabajar con SlackBuilds de forma más cómoda y trazable.

Revisar README, dependencias, flags de compilación y advertencias antes de construir un paquete.

Compilar paquetes desde código fuente generando paquetes Slackware instalables con `installpkg` o `upgradepkg`.

Gestionar dependencias manualmente, documentando orden de instalación y versiones utilizadas.

Adaptar SlackBuilds cuando una empresa necesita opciones de compilación específicas, parches internos o rutas distintas.

Evitar instalar software directamente con `make install` sin generar paquete, salvo en laboratorios controlados.

Crear colas de construcción para software con varias dependencias.

Documentar paquetes de terceros con origen, versión, SlackBuild utilizado, dependencias, responsable y motivo de instalación.

Comprender qué aporta slackpkg+ al permitir gestionar repositorios adicionales desde el flujo de `slackpkg`.

Evaluar repositorios no oficiales según reputación, mantenimiento, compatibilidad, firma, arquitectura y frecuencia de actualización.

Diseñar una política de uso de repositorios externos para evitar mezclar paquetes incompatibles o sin soporte.

Configurar prioridades de repositorios cuando varios orígenes ofrecen paquetes con el mismo nombre.

Gestionar multilib cuando se necesitan aplicaciones de 32 bits sobre Slackware64.

Documentar claramente cuándo un sistema deja de ser puramente oficial por incorporación de repositorios externos.

Probar paquetes externos en entornos de laboratorio antes de instalarlos en estaciones o servidores críticos.

Evitar actualizaciones automáticas desde repositorios no controlados sin revisión previa.

Crear mirrors internos cuando la empresa necesita estabilidad, control y reproducibilidad.

Definir criterios para retirar software externo cuando deja de mantenerse o rompe compatibilidad.

Configurar red mediante archivos clásicos como `rc.inet1.conf`, entendiendo interfaz, IP, gateway, DHCP y DNS.

Revisar diferencias entre configuración de red tradicional y herramientas más modernas disponibles en ciertos entornos.

Configurar IP estática para servidores, laboratorios, bastiones o máquinas virtuales.

Gestionar resolución de nombres mediante `/etc/hosts`, `/etc/resolv.conf` y servicios DNS corporativos.

Diagnosticar conectividad con `ip`, `ifconfig` cuando esté disponible, `route`, `ping`, `traceroute`, `dig`, `host`, `ss` y `tcpdump`.

Revisar problemas habituales de red: interfaz no levantada, gateway incorrecto, DNS roto, firewall, VLAN, DHCP o nombres inconsistentes.

Configurar múltiples interfaces, redes virtuales, bridges o entornos de laboratorio con varios segmentos.

Validar conectividad entre máquinas Slackware, hosts y servicios externos.

Documentar configuraciones de red para que reinicios o cambios de hardware no rompan conectividad.

Crear un procedimiento de troubleshooting por capas: enlace, IP, ruta, DNS, puerto, servicio y logs.

Instalar, activar y configurar OpenSSH Server para administrar Slackware de forma remota.

Endurecer `sshd_config` deshabilitando accesos inseguros y aplicando autenticación basada en claves cuando proceda.

Gestionar claves públicas, permisos de `.ssh`, usuarios autorizados y retirada de accesos antiguos.

Limitar acceso por usuario, grupo, IP, puerto o jump host según la política de seguridad.

Revisar logs de autenticación para detectar intentos fallidos, accesos correctos y problemas de permisos.

Configurar banners, timeouts, algoritmos permitidos y restricciones de forwarding cuando el entorno lo exige.

Diagnosticar fallos de SSH provocados por permisos, claves, DNS, firewall, servicio no arrancado o configuración errónea.

Preparar acceso de emergencia conservando seguridad y trazabilidad.

Usar `scp`, `sftp` y `rsync` para mover archivos de forma segura entre sistemas.

Documentar procedimientos de acceso remoto para administradores, automatizaciones y soporte.

Revisar herramientas disponibles para filtrado de red, incluyendo `iptables`, `nftables` o soluciones según versión y paquetes instalados.

Crear reglas básicas para permitir SSH, servicios web, DNS, NTP u otros servicios necesarios y bloquear tráfico innecesario.

Diferenciar políticas de entrada, salida, forwarding, NAT y filtrado por interfaz.

Diseñar firewall orientado a servidor, estación técnica, laboratorio, gateway o entorno virtualizado.

Probar reglas de firewall sin bloquear el propio acceso SSH en servidores remotos.

Persistir reglas de forma controlada mediante scripts de arranque o herramientas aprobadas.

Diagnosticar puertos abiertos, conexiones activas y servicios expuestos con `ss`, `nmap`, `lsof` y logs.

Integrar reglas de firewall con arquitectura de red corporativa, bastiones, VPN o segmentación.

Documentar puertos permitidos, motivo, servicio asociado, responsable y fecha de revisión.

Crear una checklist de exposición mínima antes de publicar un servidor Slackware en red.

Crear usuarios y grupos con criterios de separación de responsabilidades y mínimo privilegio.

Gestionar contraseñas, expiración, bloqueo y políticas básicas con herramientas estándar del sistema.

Configurar sudo cuando se instala y se decide usarlo, evitando trabajar siempre como root en operaciones diarias.

Diferenciar permisos clásicos, ownership, grupos, umask, sticky bit, setuid y setgid.

Aplicar ACLs cuando los permisos tradicionales no resuelven escenarios de colaboración o servicios compartidos.

Crear cuentas de servicio sin shell interactiva para aplicaciones, demonios y procesos internos.

Auditar usuarios con permisos elevados, shells válidas, claves SSH, grupos sensibles y cuentas obsoletas.

Revisar logs de acceso, su, sudo y sesiones administrativas.

Diseñar procedimientos de alta, baja y revisión periódica de cuentas.

Documentar permisos especiales para evitar configuraciones heredadas que nadie entiende.

Activar servicios mediante scripts en `/etc/rc.d`, revisando permisos de ejecución, configuración y logs asociados.

Configurar un servidor web básico con Apache HTTP Server incluido o paquetes disponibles según instalación.

Revisar servicios de red habituales como NTP, DNS, SSH, syslog, impresión o correo local según necesidades.

Administrar demonios clásicos entendiendo archivo de configuración, script de arranque, usuario, puerto y logs.

Crear servicios internos sencillos mediante scripts `rc.` siguiendo el estilo de Slackware.

Aplicar firewall y hardening específico a cada servicio expuesto.

Diagnosticar servicios que no arrancan, puertos ocupados, permisos incorrectos o errores de configuración.

Separar servicios de laboratorio y servicios productivos con documentación y criterios de seguridad distintos.

Revisar qué servicios vienen activos tras instalación y cuáles deben deshabilitarse.

Crear runbooks de operación para arranque, parada, reinicio, validación y recuperación de servicios críticos.

Instalar y configurar entorno gráfico cuando Slackware se utiliza como estación técnica o laboratorio de escritorio.

Seleccionar gestor de ventanas o entorno mediante herramientas como `xwmconfig` y configuración de runlevel.

Entender el papel de X11, drivers gráficos, sesiones, fuentes, entrada, audio y configuración de usuario.

Configurar arranque gráfico en runlevel adecuado cuando el equipo necesita login manager.

Diagnosticar problemas de X11, permisos, drivers, resolución, teclado, ratón o sesión gráfica.

Instalar aplicaciones de escritorio desde paquetes oficiales, SlackBuilds o repositorios externos con criterios de compatibilidad.

Diferenciar estación Slackware para trabajo técnico frente a servidor sin entorno gráfico.

Revisar consumo de recursos, servicios añadidos y superficie de ataque al instalar escritorio.

Preparar una estación de trabajo Slackware para administración, compilación, documentación y desarrollo.

Documentar configuración gráfica para poder reproducirla en otros equipos o laboratorios.

Instalar y revisar toolchain de desarrollo: GCC, make, binutils, headers, libraries y herramientas auxiliares.

Compilar software manualmente en laboratorio para entender configure, make, install, DESTDIR y rutas de instalación.

Convertir compilaciones manuales en paquetes Slackware mediante SlackBuilds o scripts propios.

Aplicar parches antes de compilar cuando una versión requiere ajustes de seguridad, compatibilidad o rutas corporativas.

Gestionar variables de compilación, flags, arquitectura, optimización y dependencias.

Evitar contaminar el sistema con instalaciones directas fuera del gestor de paquetes.

Crear paquetes internos para scripts, agentes, herramientas corporativas o software no disponible en repositorios.

Probar paquetes en máquinas limpias para verificar dependencias no documentadas.

Firmar, almacenar y distribuir paquetes internos mediante repositorio o carpeta controlada.

Documentar el proceso de build para que sea reproducible por otro administrador.

Revisar versiones de kernel instaladas, módulos disponibles, configuración y relación con hardware detectado.

Usar kernels genéricos y huge entendiendo diferencias prácticas y recomendaciones de uso con initrd.

Preparar initrd correctamente cuando se trabaja con kernel genérico, sistemas de archivos específicos o drivers necesarios.

Compilar un kernel personalizado en laboratorio para entender configuración, módulos, instalación y bootloader.

Gestionar módulos con `lsmod`, `modprobe`, `modinfo` y configuración persistente.

Diagnosticar problemas de drivers, almacenamiento, red, gráficos o hardware mediante `dmesg` y logs del kernel.

Mantener un kernel anterior funcional para recuperación ante fallos de compilación o actualización.

Documentar cambios de kernel, opciones activadas, módulos críticos y pruebas posteriores.

Evitar recompilar kernel sin objetivo claro cuando los paquetes oficiales cubren el caso de uso.

Crear un procedimiento seguro para actualizar o personalizar kernel en entornos técnicos.

Gestionar discos y particiones con herramientas clásicas, revisando tamaños, tipos, UUIDs y puntos de montaje.

Configurar `/etc/fstab` con opciones seguras y validar cambios antes de reiniciar el sistema.

Trabajar con LVM cuando se necesita flexibilidad en volúmenes, crecimiento y separación de datos.

Crear y administrar RAID software con `mdadm` en laboratorios donde se requiere redundancia local.

Gestionar swap, sistemas de archivos, checks, montaje manual y reparación básica.

Diagnosticar problemas de disco lleno, inodos agotados, fstab incorrecto, permisos o sistemas de archivos dañados.

Diseñar separación de `/var`, `/home`, datos, logs y backups según rol del servidor.

Preparar procedimientos de ampliación de disco en máquinas virtuales.

Recuperar archivos desde backups, snapshots o medios de rescate.

Documentar layout de almacenamiento para soporte, continuidad y mantenimiento futuro.

Revisar logs del sistema en `/var/log` y comprender qué registra cada archivo relevante.

Configurar syslog según servicios, severidad, rotación y centralización cuando el entorno lo requiere.

Administrar logrotate para evitar que logs de sistema o aplicación llenen disco.

Analizar logs de autenticación, kernel, servicios, paquetes, arranque, red y errores de aplicación.

Crear búsquedas útiles con `grep`, `awk`, `sed`, `less`, `tail`, `journal` si existe en entornos específicos y herramientas clásicas.

Centralizar logs hacia un servidor syslog, SIEM, Loki, Elastic u otra plataforma corporativa.

Proteger logs frente a permisos excesivos, borrado accidental o manipulación.

Crear alertas simples basadas en logs para errores recurrentes o eventos de seguridad.

Documentar rutas de logs por servicio y pasos de recogida de evidencias.

Convertir análisis de logs en parte habitual de mantenimiento y troubleshooting.

Crear scripts shell robustos con control de errores, validación de parámetros, logs y códigos de salida.

Automatizar tareas de mantenimiento: backups, limpieza, comprobaciones, reports, sincronización y validación de servicios.

Programar tareas con cron revisando entorno, rutas, usuario, salida, logs y notificación de errores.

Utilizar `rsync` para backups, sincronización de configuraciones, despliegues simples y réplicas controladas.

Crear scripts idempotentes cuando sea posible para evitar cambios duplicados o efectos no deseados.

Gestionar secretos en scripts evitando credenciales en texto claro o repositorios compartidos.

Versionar scripts y configuraciones con Git para mantener trazabilidad.

Documentar finalidad, frecuencia, dependencias y responsable de cada automatización.

Probar scripts en laboratorio antes de programarlos en servidores reales.

Crear una biblioteca interna de scripts Slackware reutilizables para administración diaria.

Definir qué debe respaldarse en Slackware: configuración, paquetes instalados, datos, scripts, logs críticos y documentación.

Crear backups con `tar`, `rsync`, `dump`, snapshots de máquina virtual o herramientas externas según escenario.

Separar backup de sistema, backup de usuario, backup de aplicación y backup de configuración.

Automatizar copias con cron y registrar resultado para detectar fallos silenciosos.

Probar restauraciones parciales y completas para verificar que los backups son utilizables.

Crear inventario de paquetes instalados y configuraciones modificadas para reconstrucción rápida.

Diseñar retención de copias según criticidad, espacio, normativa y capacidad de recuperación.

Cifrar backups cuando contienen datos sensibles o credenciales.

Preparar medios de rescate para restaurar bootloader, fstab, paquetes o configuraciones críticas.

Documentar RPO, RTO, ubicación de backups, responsable y procedimiento de recuperación.

Reducir superficie de ataque eliminando servicios innecesarios, paquetes no utilizados y accesos no justificados.

Aplicar parches de seguridad revisando ChangeLog, paquetes afectados y criticidad del sistema.

Endurecer SSH, permisos, firewall, cuentas, scripts, cron jobs y servicios expuestos.

Revisar integridad de paquetes y origen de software antes de instalar componentes externos.

Configurar herramientas de auditoría, comprobación de integridad o escaneo local cuando el entorno lo requiere.

Establecer políticas de actualización para Slackware estable y estrategias separadas para entornos `-current`.

Analizar riesgos de compilar software externo sin revisar fuentes, scripts, checksums o dependencias.

Crear procedimientos de respuesta ante vulnerabilidades críticas en librerías, demonios o kernel.

Documentar excepciones de seguridad cuando una aplicación exige configuración menos restrictiva.

Crear una checklist de hardening previa a producción adaptada a Slackware.

Comprender qué representa la rama `-current` y por qué no debe tratarse como una release estable tradicional.

Evaluar cuándo tiene sentido usar `-current` en laboratorio, estación técnica, pruebas de hardware o preparación de futuras versiones.

Configurar mirrors y herramientas evitando mezclar paquetes estables y `-current` de forma accidental.

Leer ChangeLog de `-current` antes de actualizar para detectar cambios relevantes de toolchain, kernel, librerías o aplicaciones.

Preparar snapshots o backups antes de actualizar sistemas en `-current`.

Resolver incidencias provocadas por cambios de paquetes, dependencias manuales o software externo no compatible.

Mantener SlackBuilds y paquetes propios separados por versión estable o current.

Diseñar un entorno de pruebas para validar cambios antes de incorporarlos a una estación de trabajo principal.

Documentar diferencias entre sistemas estables y sistemas current dentro de la empresa.

Crear criterios internos para impedir que servidores productivos se actualicen a current sin justificación formal.

Diseñar un servidor Slackware minimalista para servicios internos con paquetes estrictamente necesarios.

Configurar Apache, Nginx compilado o servicio web disponible según estrategia de paquetes.

Preparar servidor de ficheros mediante NFS, Samba o rsync según clientes y necesidades de seguridad.

Crear un mirror interno de paquetes, patches o SlackBuilds para entornos controlados.

Configurar servidor SSH bastión o administración remota con endurecimiento específico.

Publicar servicios internos aplicando firewall, logs, usuarios de servicio y scripts de arranque.

Monitorizar disponibilidad básica mediante scripts, logs, comprobaciones de puerto y herramientas externas.

Diseñar backups y restauración por servicio.

Documentar arquitectura, puertos, rutas, paquetes, scripts y procedimientos de mantenimiento.

Evitar que un servidor simple acumule funciones inconexas sin separación ni owner claro.

Preparar Slackware como workstation técnica con entorno gráfico, herramientas de red, editores, compiladores y documentación local.

Instalar navegadores, clientes SSH, herramientas Git, terminales, IDEs o editores avanzados según perfil del usuario.

Configurar audio, impresión, red Wi-Fi, sesión gráfica y dispositivos externos cuando se usa en escritorio.

Crear un entorno de compilación para SlackBuilds, paquetes internos y pruebas de software.

Gestionar aplicaciones no oficiales mediante SlackBuilds, sbopkg o repositorios externos aprobados.

Configurar usuarios, grupos, sudo, permisos y backups de home.

Crear snapshots o imágenes de estación para laboratorios formativos.

Documentar personalización sin convertir la estación en un sistema irreproducible.

Comparar uso de Slackware como estación diaria frente a laboratorio avanzado de administración Linux.

Crear un perfil de workstation técnica útil para formadores, administradores y desarrolladores senior.

Revisar opciones disponibles para ejecutar contenedores o virtualización ligera en Slackware según paquetes y soporte externo.

Preparar laboratorios con QEMU/KVM, VirtualBox u otras herramientas cuando el hardware lo permite.

Compilar o instalar herramientas de contenedores desde SlackBuilds si el caso de uso lo justifica.

Evaluar límites de Slackware como host de contenedores frente a distribuciones más orientadas a cloud-native.

Crear máquinas virtuales para probar paquetes, scripts, `-current`, actualizaciones o servicios sin comprometer el sistema principal.

Usar chroot para pruebas controladas de compilación, recuperación o aislamiento básico.

Diseñar entornos de laboratorio reproducibles para formación y troubleshooting.

Documentar dependencias adicionales necesarias para virtualización o contenedores.

Revisar seguridad de entornos aislados sin asumir que una VM o chroot sustituye hardening.

Decidir cuándo Slackware debe ser host, guest, estación de administración o simple laboratorio de aprendizaje.

Medir CPU, memoria, disco, red, procesos y carga con herramientas clásicas de Linux.

Utilizar `top`, `htop`, `vmstat`, `iostat`, `free`, `sar`, `ss`, `lsof`, `ps` y `strace` para diagnóstico.

Diferenciar problemas de CPU, I/O, swapping, red, procesos bloqueados, errores de servicio o saturación de logs.

Crear scripts de monitorización ligera para entornos donde no existe agente corporativo.

Integrar Slackware con Prometheus node_exporter, syslog centralizado, Nagios, Zabbix, Grafana o herramientas equivalentes.

Definir umbrales de alerta para disco, memoria, carga, procesos, servicios y puertos.

Analizar rendimiento tras instalar paquetes externos, actualizar kernel o activar servicios adicionales.

Documentar baseline de sistema recién instalado y comparar evolución con el tiempo.

Preparar procedimientos de respuesta ante saturación de disco, memoria o CPU.

Convertir métricas y logs en decisiones de mantenimiento, no solo en datos almacenados.

Diagnosticar fallos de arranque desde bootloader, kernel, initrd, fstab, scripts rc y servicios iniciales.

Resolver problemas de paquetes provocados por dependencias manuales, librerías ausentes, versiones incompatibles o instalaciones directas.

Investigar errores de compilación revisando toolchain, headers, flags, rutas, permisos y parches.

Corregir problemas de red siguiendo método por capas y validando interfaz, IP, gateway, DNS, firewall y servicio.

Analizar fallos de X11, drivers gráficos, teclado, ratón, permisos o configuración de sesión.

Recuperar acceso tras errores de SSH, permisos, root filesystem, contraseña, bootloader o configuración de red.

Utilizar medio de instalación como herramienta de rescate para montar, chrootear y reparar el sistema.

Investigar procesos bloqueados, librerías rotas, comandos que fallan y servicios que no dejan logs claros.

Crear informes de incidencia con síntoma, causa, evidencia, cambio aplicado y prevención futura.

Convertir errores frecuentes en documentación, scripts de validación o prácticas de hardening.

Comparar hábitos de administración procedentes de Debian, Ubuntu, RHEL, Rocky, Arch o Gentoo con la forma de trabajar en Slackware.

Adaptar mentalidad de paquetes sin resolución automática de dependencias y menor intervención del gestor de sistema.

Migrar configuraciones de servicios revisando rutas, scripts, usuarios, permisos y diferencias de paquetes.

Preparar inventario de software equivalente cuando un entorno existente depende de `apt`, `dnf`, `pacman` o systemd.

Diseñar estrategias de convivencia entre servidores Slackware y entornos corporativos mixtos.

Crear documentación para equipos acostumbrados a systemd, firewalld, SELinux o gestores automáticos.

Evaluar qué cargas pueden migrarse a Slackware y cuáles dependen demasiado de tooling específico de otra distribución.

Preparar pruebas funcionales antes de migrar servicios reales.

Documentar diferencias operativas para reducir errores de administradores que llegan desde otras distribuciones.

Aprovechar Slackware como plataforma de aprendizaje para reforzar fundamentos transferibles a cualquier Linux.

Crear un estándar interno de instalación, paquetes, servicios, usuarios, firewall, SSH, logs, backups y actualizaciones.

Documentar cada servidor con versión, rama, paquetes externos, SlackBuilds, servicios, puertos, responsables y procedimiento de recuperación.

Mantener inventario de paquetes oficiales, paquetes de terceros y software compilado internamente.

Definir criterios de aprobación para usar Slackware en laboratorio, workstation, servidor interno o producción.

Versionar configuraciones críticas y scripts de administración en repositorio privado.

Crear plantillas de runbook para arranque, parada, parcheo, recuperación, compilación y actualización de servicios.

Revisar periódicamente sistemas para detectar desviaciones, paquetes no documentados o servicios innecesarios.

Establecer un calendario de mantenimiento para parches, backups, revisión de logs y pruebas de restauración.

Preparar guías de onboarding para nuevos administradores Slackware.

Convertir la transparencia de Slackware en una ventaja operativa mediante documentación rigurosa y control de cambios.

Diseñar una plataforma Slackware de laboratorio empresarial con servidor base, estación técnica y repositorio interno de paquetes.

Instalar Slackware64 desde ISO, configurando particionado, red, usuarios, bootloader, paquetes base y actualización inicial.

Configurar `slackpkg` con mirror oficial, aplicar parches, revisar archivos `.new` y documentar el procedimiento de actualización.

Crear un servicio personalizado mediante script en `/etc/rc.d`, activarlo correctamente y validar arranque, parada, logs y reinicio.

Instalar software externo mediante SlackBuild, gestionar dependencias manuales y generar un paquete Slackware instalable.

Configurar SSH seguro, firewall básico, usuarios de administración, permisos, logs y política mínima de hardening.

Preparar almacenamiento adicional con montaje persistente, estructura de datos, permisos y backup mediante rsync o tar.

Compilar o instalar un kernel alternativo de laboratorio, preparar initrd y mantener una opción de arranque de recuperación.

Desplegar un servicio web o recurso interno, documentando paquetes, rutas, puertos, scripts, logs y configuración.

Crear scripts de mantenimiento para backup, revisión de logs, comprobación de servicios y sincronización de documentación.

Simular incidencias de arranque, red, paquete, librería, permiso o servicio y resolverlas usando metodología documentada.

Preparar documentación final con arquitectura, decisiones técnicas, paquetes instalados, SlackBuilds usados, runbooks y plan de mantenimiento.

Presentar la solución defendiendo instalación, filosofía Slackware, seguridad, actualización, recuperación, documentación y criterios de uso profesional.