Saltar a contenido

📚 Módulo 6: Conectando tu terminal al mundo real

Duración estimada: 3-4 horas según tu ritmo y experiencia.

Objetivo: Usar ssh para conexiones remotas, curl para interactuar con APIs y URLs, jq para procesar JSON, y herramientas de monitoreo del sistema como top y ps. 🎯

Prerrequisitos: Haber completado los Módulos 1-5. Si es posible, disponer de una máquina remota con SSH habilitado para los ejercicios de conexión.

Nota: Los conceptos de red y API son fundamentales en entornos DevOps y administración de sistemas. Practica los ejemplos con APIs públicas si no tienes servidor propio.

📖 Contenidos del Módulo

6.1. ssh: Conéctate a máquinas remotas 🌱

Teoría:

SSH (Secure Shell) es un protocolo que permite conectarse de forma cifrada a servidores remotos. La sintaxis básica es ssh usuario@host. Puedes ejecutar comandos directamente sin abrir una sesión interactiva añadiéndolos al final: ssh usuario@host "comando". Las claves SSH (ssh-keygen) son la alternativa más segura a las contraseñas.

Práctica:

  1. Genera un par de claves SSH (si aún no tienes una):
ssh-keygen -t ed25519 -C "tu_email@ejemplo.com"

Acepta la ruta por defecto (~/.ssh/id_ed25519). Añade una passphrase para mayor seguridad.

  1. Muestra tu clave pública:
cat ~/.ssh/id_ed25519.pub

Esta es la clave que copiarás al servidor remoto para autenticarte sin contraseña.

  1. Copia la clave pública al servidor remoto:
ssh-copy-id usuario@servidor_remoto

Esto añade tu clave al archivo ~/.ssh/authorized_keys del servidor.

  1. Conéctate al servidor remoto:
ssh usuario@servidor_remoto

Una vez dentro, prueba algunos comandos (ls, pwd) y sal con exit.

  1. Ejecuta un comando remoto sin abrir sesión interactiva:
ssh usuario@servidor_remoto "uptime && df -h"

Muy útil para scripts de monitoreo que comprueban el estado de un servidor remoto sin necesidad de una sesión completa.

Consejo: Configura ~/.ssh/config para guardar hosts frecuentes con alias. Así ssh mi_servidor sustituye a ssh usuario@192.168.1.100 -p 2222. 💡

6.2. curl: Interactúa con la web y APIs 🖌️

Teoría:

curl transfiere datos desde y hacia URLs. Es la herramienta estándar para interactuar con APIs REST desde la terminal. Las opciones más usadas son:

  • -s — modo silencioso (sin barra de progreso).
  • -o archivo — guarda la respuesta en un archivo.
  • -H "Cabecera: valor" — añade una cabecera HTTP.
  • -X MÉTODO — especifica el método HTTP (GET, POST, PUT, DELETE).
  • -d "datos" — envía datos en el cuerpo de la petición (útil con POST).

Práctica:

  1. Descarga el contenido de una URL:
curl https://example.com
  1. Obtén datos de una API pública (sin necesidad de clave):
curl -s "https://api.github.com/users/github"
  1. Guarda la respuesta en un archivo:
curl -s "https://api.github.com/users/github" -o github_info.txt
cat github_info.txt
  1. Envía una petición POST con datos JSON:
curl -s -X POST "https://httpbin.org/post" \
     -H "Content-Type: application/json" \
     -d '{"nombre": "Bash", "version": "5.1"}'

httpbin.org es un servicio público que devuelve exactamente lo que le envías, ideal para pruebas.

  1. Comprueba solo el código de estado HTTP de una URL:
curl -s -o /dev/null -w "%{http_code}" https://example.com

-w "%{http_code}" imprime solo el código de respuesta (200, 404, 500, etc.).

Advertencia: Nunca incluyas contraseñas o tokens de API directamente en un script. Guárdalos en variables de entorno o en un archivo de configuración con permisos 600. 🛑

6.3. jq: Procesa JSON desde la terminal ⚙️

Teoría:

jq es un procesador de JSON por línea de comandos. Permite extraer campos, filtrar y transformar estructuras JSON de forma concisa. La expresión más básica es .campo para acceder a una propiedad, y .campo[] para iterar sobre un array.

Instálalo si no está disponible:

sudo apt install jq        # Debian/Ubuntu
sudo dnf install jq        # Fedora/RHEL
brew install jq            # macOS

Práctica:

  1. Procesa JSON básico:
echo '{"nombre": "Bash", "version": 5}' | jq '.'

. con jq formatea el JSON con indentación y colores.

  1. Extrae un campo específico:
echo '{"nombre": "Bash", "version": 5}' | jq '.nombre'
  1. Combina con curl para extraer datos de una API:
curl -s "https://api.github.com/users/github" | jq '.name, .public_repos'
  1. Itera sobre un array JSON:
echo '[{"id":1,"item":"a"},{"id":2,"item":"b"}]' | jq '.[].item'
  1. Filtra elementos de un array según una condición:
echo '[{"nombre":"Ana","edad":30},{"nombre":"Luis","edad":22}]' \
  | jq '[.[] | select(.edad > 25)] | .[].nombre'

Consejo: Prueba tus expresiones jq en jqplay.org antes de usarlas en un script. Ahorra mucho tiempo de depuración. 💡

6.4. Monitoreo del sistema: top, ps y df 📊

Teoría:

Linux incluye herramientas nativas para monitorear el estado del sistema:

  • top — muestra procesos en tiempo real con uso de CPU y memoria.
  • ps aux — lista todos los procesos en ejecución en un momento dado.
  • df -h — muestra el espacio en disco de cada partición montada.
  • free -h — muestra el uso de memoria RAM y swap.

Práctica:

  1. Observa los procesos en tiempo real:
top

Pulsa q para salir. Observa las columnas %CPU y %MEM.

  1. Lista todos los procesos con ps:
ps aux | head -20
  1. Busca un proceso concreto:
ps aux | grep "bash"
  1. Comprueba el espacio en disco:
df -h
  1. Crea un script de informe del sistema:
nano informe_sistema.sh

#!/bin/bash
echo "=== Informe del sistema: $(date) ==="
echo ""
echo "--- Uso de disco ---"
df -h
echo ""
echo "--- Memoria ---"
free -h
echo ""
echo "--- Procesos con mayor uso de CPU (top 5) ---"
ps aux --sort=-%cpu | head -6

Guarda, dale permisos y ejecútalo.

Consejo: Usa htop (si está instalado) como alternativa visual e interactiva a top. Es mucho más cómodo para explorar procesos. 💡

6.5. Scripts remotos y automatización de red 🚀

Teoría:

Combinando ssh, curl y las herramientas de monitoreo puedes construir scripts que gestionan sistemas remotos, comprueban el estado de servicios o envían alertas automáticas. La clave es usar autenticación con claves SSH (sin contraseña) para que los scripts no necesiten interacción humana.

Práctica:

  1. Crea un script que compruebe si un host responde:
nano ping_check.sh

#!/bin/bash
HOST="8.8.8.8"
if ping -c 1 -W 2 "$HOST" &>/dev/null; then
    echo "$HOST está accesible"
else
    echo "$HOST NO responde"
fi
  1. Amplía el script para comprobar varios hosts:
nano ping_multi.sh

#!/bin/bash
hosts=("8.8.8.8" "1.1.1.1" "192.168.1.1")
for host in "${hosts[@]}"; do
    if ping -c 1 -W 2 "$host" &>/dev/null; then
        echo "$host: OK"
    else
        echo "$host: SIN RESPUESTA"
    fi
done
  1. Crea un script que verifique si un servicio web devuelve código 200:
nano check_web.sh

#!/bin/bash
URL="https://example.com"
codigo=$(curl -s -o /dev/null -w "%{http_code}" "$URL")
if [ "$codigo" -eq 200 ]; then
    echo "$URL responde correctamente (HTTP $codigo)"
else
    echo "AVISO: $URL devuelve HTTP $codigo"
fi
  1. Ejecuta un comando en un servidor remoto desde un script:
nano remoto.sh

#!/bin/bash
SERVIDOR="usuario@servidor_remoto"
echo "Espacio en disco del servidor remoto:"
ssh "$SERVIDOR" "df -h /"
  1. Guarda el informe remoto en un archivo local:
ssh "$SERVIDOR" "df -h" > informe_remoto.txt
echo "Informe guardado en informe_remoto.txt"

Consejo: Centraliza los datos de conexión (usuario, host, puerto) en variables al principio del script para que sea fácil adaptarlo a distintos entornos. 💡

🛠️ Ejercicios prácticos

  1. SSH: Genera claves SSH y documenta los pasos para conectarte a un servidor sin contraseña.
  2. curl: Descarga los datos públicos de tu usuario de GitHub con curl y guárdalos en un archivo JSON.
  3. jq: Extrae tu número de repositorios públicos del JSON descargado en el ejercicio anterior.
  4. Monitoreo: Crea un script que muestre el top 3 de procesos por uso de memoria y lo guarde en top_procesos.txt.
  5. Desafío: Crea un script que compruebe cada minuto (con sleep 60) si una URL responde con HTTP 200, y escriba una línea en un log si falla.

📝 Evaluación

Cuestionario (5 preguntas):

  1. ¿Qué ventaja tienen las claves SSH sobre las contraseñas?
  2. ¿Cómo obtienes solo el código de estado HTTP con curl?
  3. ¿Para qué sirve jq '.'?
  4. ¿Qué diferencia hay entre top y ps aux?
  5. ¿Por qué es importante no incluir contraseñas directamente en los scripts?

Tarea práctica:

Crea un script monitor_web.sh que: - Compruebe el estado HTTP de tres URLs definidas en un array. - Registre en monitor.log la fecha, la URL y el código de respuesta de cada comprobación. - Muestre un resumen al final indicando cuántas URLs respondieron correctamente.

Entrega: El script y el archivo monitor.log generado.

🎬 Vídeo con la solución de la evaluación: Próximamente.

🎉 Recursos adicionales

  • Documentación: man ssh, man curl, man jq.
  • Manual de jq: jq Manual (stedolan.github.io) — referencia completa de filtros y expresiones.
  • Práctica de jq: jqplay.org — editor interactivo en el navegador.
  • Referencia de curl: curl.se/docs — documentación oficial.

Tip: Practica curl y jq juntos usando APIs públicas como la de GitHub, OpenWeatherMap o JSONPlaceholder. 💡

🚀 Siguientes pasos

¡Felicidades por completar el Módulo 6! En el Módulo 7 construirás un proyecto final completo: un sistema de backups con monitoreo, manejo avanzado de errores y optimización. ¡El gran proyecto te espera! ✍️