Saltar al contenido principal

📋 Ejemplos — Clase 02: Linux Básico para DevOps

Scripts listos para copiar y ejecutar en KillerCoda. Cada uno demuestra un concepto de la clase.

Ejemplo 1 — Hola Mundo y variables del sistema​

Tu primer script con variables propias y del sistema.

hola-sistema.sh
#!/bin/bash
echo "╔══════════════════════════════════════════╗"
echo "║     ¡Hola Mundo en Bash!                  ║"
echo "╚══════════════════════════════════════════╝"
echo ""

# Variables propias
NOMBRE="RoxsRoss"
CURSO="DevOps"
echo "Soy $NOMBRE y estoy aprendiendo $CURSO"
echo ""

# Variables del sistema
echo "📋 Info del sistema:"
echo "  Usuario:    $(whoami)"
echo "  Directorio: $(pwd)"
echo "  Fecha:      $(date '+%Y-%m-%d %H:%M')"
echo "  Sistema:    $(uname -s)"
echo "  Hostname:   $(hostname)"
echo ""

# Aritmética
A=10
B=3
echo "🔢 Aritmética:"
echo "  $A + $B = $((A + B))"
echo "  $A - $B = $((A - B))"
echo "  $A * $B = $((A * B))"
echo "  $A / $B = $((A / B)) (división entera)"
echo "  $A % $B = $((A % B)) (módulo)"
echo ""

# Variables especiales
echo "📌 Variables especiales:"
echo "  \$0 (script): $0"
echo "  \$# (args):   $#"
echo "  \$? (exit):   $?"
echo "  \$HOME:       $HOME"
echo "  \$USER:       $USER"
echo "  \$SHELL:      $SHELL"

Ejemplo 2 — Condicionales completos​

Todos los tipos de condicionales que vas a necesitar.

condicionales.sh
#!/bin/bash
echo "=== Condicionales en Bash ==="
echo ""

# 1. Comparar números
EDAD=25
echo "📌 Números: EDAD=$EDAD"
if [ "$EDAD" -ge 18 ]; then
    echo "  ✅ Mayor de edad"
else
    echo "  ❌ Menor de edad"
fi
echo ""

# 2. Comparar strings
SISTEMA=$(uname -s)
echo "📌 Strings: SISTEMA=$SISTEMA"
if [ "$SISTEMA" = "Darwin" ]; then
    echo "  🍎 Estás en macOS"
elif [ "$SISTEMA" = "Linux" ]; then
    echo "  🐧 Estás en Linux"
else
    echo "  ❓ Sistema: $SISTEMA"
fi
echo ""

# 3. Verificar archivos
echo "📌 Archivos:"
for archivo in /etc/hosts /etc/passwd /tmp/no-existe; do
    if [ -f "$archivo" ]; then
        echo "  ✅ $archivo existe"
    else
        echo "  ❌ $archivo NO existe"
    fi
done
echo ""

# 4. Verificar comandos instalados
echo "📌 Comandos:"
for cmd in bash curl jq docker python3 kubectl; do
    if command -v "$cmd" &>/dev/null; then
        echo "  ✅ $cmd → $(which "$cmd")"
    else
        echo "  ❌ $cmd NO instalado"
    fi
done
echo ""

# 5. Combinaciones AND/OR
HORA=$(date +%H)
echo "📌 Hora actual: $HORA"
if [ "$HORA" -ge 6 ] && [ "$HORA" -lt 12 ]; then
    echo "  🌅 Buenos días"
elif [ "$HORA" -ge 12 ] && [ "$HORA" -lt 18 ]; then
    echo "  ☀️ Buenas tardes"
else
    echo "  🌙 Buenas noches"
fi

Ejemplo 3 — Loops: for y while​

Todos los patrones de loops que vas a usar.

loops.sh
#!/bin/bash
echo "=== Loops en Bash ==="
echo ""

# 1. For con lista
echo "📌 1. Lista simple:"
for color in rojo verde azul amarillo; do
    echo "  🎨 $color"
done
echo ""

# 2. For con rango
echo "📌 2. Rango {1..5}:"
for i in {1..5}; do
    echo "  Número: $i"
done
echo ""

# 3. For con array
echo "📌 3. Array de Pokémon:"
POKEMONES=("Pikachu" "Charizard" "Mewtwo" "Gengar" "Bulbasaur")
for pokemon in "${POKEMONES[@]}"; do
    echo "  ⚡ $pokemon"
done
echo ""

# 4. For con archivos
echo "📌 4. Archivos .sh en el directorio:"
for archivo in *.sh 2>/dev/null; do
    if [ -f "$archivo" ]; then
        lineas=$(wc -l < "$archivo" | tr -d ' ')
        echo "  📄 $archivo ($lineas líneas)"
    fi
done
echo ""

# 5. While con contador
echo "📌 5. While contador:"
CONT=1
while [ "$CONT" -le 5 ]; do
    echo "  Contando: $CONT"
    CONT=$((CONT + 1))
done
echo ""

# 6. Tabla de multiplicar
echo "📌 6. Tabla del 5:"
for i in {1..10}; do
    resultado=$((5 * i))
    printf "  5 × %2d = %2d\n" "$i" "$resultado"
done

Ejemplo 4 — JSON con jq: procesamiento avanzado​

json-avanzado.sh
#!/bin/bash
echo "=== Procesamiento JSON con jq ==="
echo ""

JSON='{
    "equipo": [
        {"nombre": "Pikachu", "tipo": ["electric"], "hp": 35, "nivel": 42},
        {"nombre": "Charizard", "tipo": ["fire", "flying"], "hp": 78, "nivel": 50},
        {"nombre": "Mewtwo", "tipo": ["psychic"], "hp": 106, "nivel": 70},
        {"nombre": "Bulbasaur", "tipo": ["grass", "poison"], "hp": 45, "nivel": 15}
    ],
    "entrenador": "Ash",
    "region": "Kanto"
}'

# 1. Listar nombres
echo "1️⃣ Nombres del equipo:"
echo "$JSON" | jq -r '.equipo[].nombre'
echo ""

# 2. Filtrar por HP > 50
echo "2️⃣ Pokémon con HP > 50:"
echo "$JSON" | jq -r '.equipo[] | select(.hp > 50) | "  \(.nombre) (HP: \(.hp))"'
echo ""

# 3. Ordenar por nivel
echo "3️⃣ Ordenados por nivel (mayor a menor):"
echo "$JSON" | jq -r '.equipo | sort_by(.nivel) | reverse[] | "  \(.nombre) — Nivel \(.nivel)"'
echo ""

# 4. Promedio de HP
echo "4️⃣ Promedio de HP:"
echo "$JSON" | jq '.equipo | (map(.hp) | add) / length'
echo ""

# 5. Crear resumen
echo "5️⃣ Resumen del equipo:"
echo "$JSON" | jq '{
    entrenador: .entrenador,
    total_pokemon: (.equipo | length),
    hp_promedio: ((.equipo | map(.hp) | add) / (.equipo | length)),
    nivel_max: (.equipo | max_by(.nivel) | {nombre, nivel})
}'
echo ""

# 6. Construir JSON desde cero
echo "6️⃣ Construir JSON con --arg:"
jq -n \
    --arg nombre "Gengar" \
    --arg tipo "ghost" \
    --argjson hp 60 \
    --argjson ataque 65 \
    '{pokemon: $nombre, tipo: $tipo, stats: {hp: $hp, ataque: $ataque}}'

Ejemplo 5 — curl + jq: Pokédex completa​

pokedex-completa.sh
#!/bin/bash
API="https://pokeapi.co/api/v2/pokemon"

echo "╔══════════════════════════════════════════╗"
echo "║        🔴 Pokédex CLI — ROXS             ║"
echo "╚══════════════════════════════════════════╝"
echo ""

# Buscar los primeros 10 Pokémon
echo "📋 Primeros 10 Pokémon:"
curl -s "$API?limit=10" | jq -r '.results[] | "  \(.name)"'
echo ""

# Detalle de un Pokémon
echo "📌 Detalle de Pikachu:"
curl -s "$API/pikachu" | jq '{
    nombre: .name,
    id: .id,
    tipos: [.types[].type.name],
    peso_kg: (.weight / 10),
    altura_m: (.height / 10),
    stats: {
        hp: .stats[0].base_stat,
        ataque: .stats[1].base_stat,
        defensa: .stats[2].base_stat,
        velocidad: .stats[5].base_stat
    },
    movimientos_total: (.moves | length)
}'
echo ""

# Comparar dos Pokémon
echo "⚔️ Comparación: Pikachu vs Charizard"
echo "  ┌──────────────┬──────────┬──────────┐"
echo "  │ Stat         │ Pikachu  │ Charizard│"
echo "  ├──────────────┼──────────┼──────────┤"

PIKA=$(curl -s "$API/pikachu")
CHARI=$(curl -s "$API/charizard")

for i in 0 1 2 5; do
    case $i in
        0) LABEL="HP        ";;
        1) LABEL="Ataque    ";;
        2) LABEL="Defensa   ";;
        5) LABEL="Velocidad ";;
    esac
    P=$(echo "$PIKA" | jq ".stats[$i].base_stat")
    C=$(echo "$CHARI" | jq ".stats[$i].base_stat")
    printf "  │ %-12s │ %8s │ %8s │\n" "$LABEL" "$P" "$C"
done
echo "  └──────────────┴──────────┴──────────┘"

Ejemplo 6 — Verificador de APIs​

Un script que verifica si múltiples APIs están respondiendo.

api-check.sh
#!/bin/bash
echo "╔══════════════════════════════════════╗"
echo "║     🌐 API Health Checker             ║"
echo "╚══════════════════════════════════════╝"
echo ""

APIS=(
    "https://pokeapi.co/api/v2/pokemon/1"
    "https://httpbin.org/get"
    "https://jsonplaceholder.typicode.com/posts/1"
    "https://api.github.com"
    "https://sitio-que-no-existe-12345.com"
)

printf "  %-45s %6s %10s\n" "URL" "STATUS" "TIEMPO"
echo "  ─────────────────────────────────────────── ────── ──────────"

OK=0
FAIL=0

for url in "${APIS[@]}"; do
    RESULT=$(curl -s -o /dev/null -w "%{http_code} %{time_total}" --max-time 5 "$url" 2>/dev/null)
    CODE=$(echo "$RESULT" | awk '{print $1}')
    TIME=$(echo "$RESULT" | awk '{printf "%.2fs", $2}')

    if [ "$CODE" -ge 200 ] 2>/dev/null && [ "$CODE" -lt 400 ] 2>/dev/null; then
        printf "  ✅ %-43s %6s %10s\n" "$url" "$CODE" "$TIME"
        OK=$((OK + 1))
    else
        printf "  ❌ %-43s %6s %10s\n" "$url" "$CODE" "$TIME"
        FAIL=$((FAIL + 1))
    fi
done

echo ""
echo "  Resultado: ✅ $OK OK | ❌ $FAIL fallidas"

Ejemplo 7 — YAML en el mundo real​

Ejemplos de YAML que vas a encontrar en DevOps.

docker-compose.yml
# Docker Compose — Ejemplo simplificado
version: "3.8"

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    environment:
      - NODE_ENV=production

  api:
    image: node:18-alpine
    ports:
      - "3000:3000"
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret123
      POSTGRES_DB: myapp
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:
github-actions.yml
# GitHub Actions — CI básico
name: CI Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run tests
        run: |
          echo "Running tests..."
          npm test
kubernetes-pod.yaml
# Kubernetes — Pod básico
apiVersion: v1
kind: Pod
metadata:
  name: mi-app
  labels:
    app: web
spec:
  containers:
    - name: nginx
      image: nginx:alpine
      ports:
        - containerPort: 80

Ejemplo 8 — Cheat Sheet: Bash​

Referencia rápida de todo lo que vimos en Bash.

# ═══ VARIABLES ═══
NOMBRE="valor"               # Crear (sin espacios en =)
echo "$NOMBRE"               # Usar
echo "${NOMBRE}_sufijo"      # Con llaves para concatenar
FECHA=$(date +%Y-%m-%d)      # Resultado de comando
PUERTO=${1:-80}              # Argumento con default

# ═══ ENTRADA / SALIDA ═══
read -p "Texto: " VAR        # Pedir input
echo "texto" > archivo       # Sobreescribir
echo "texto" >> archivo      # Agregar
comando 2>/dev/null          # Ocultar errores
comando | otro               # Pipe

# ═══ CONDICIONALES ═══
if [ "$A" = "$B" ]; then     # Comparar strings
if [ "$A" -gt 10 ]; then     # Mayor que (números)
if [ -f "/ruta" ]; then      # ¿Existe archivo?
if [ -d "/ruta" ]; then      # ¿Existe directorio?
if [ -z "$VAR" ]; then       # ¿Está vacía?
if command -v nginx; then    # ¿Está instalado?

# ═══ LOOPS ═══
for I in 1 2 3 4 5; do echo $I; done
for F in *.html; do echo $F; done
for I in {1..10}; do echo $I; done
while [ "$C" -le 5 ]; do echo $C; C=$((C+1)); done

# ═══ ARITMÉTICA ═══
RESULTADO=$((10 + 5))        # 15
RESULTADO=$((10 * 3))        # 30
RESULTADO=$((10 / 3))        # 3 (entero)
RESULTADO=$((10 % 3))        # 1 (resto)

# ═══ ARRAYS ═══
LISTA=("uno" "dos" "tres")
echo ${LISTA[0]}             # Primer elemento
echo ${LISTA[@]}             # Todos
echo ${#LISTA[@]}            # Cantidad

# ═══ ESPECIALES ═══
$0                           # Nombre del script
$1, $2, $3                   # Argumentos
$#                           # Cantidad de argumentos
$?                           # Exit code del último comando

Ejemplo 9 — Cheat Sheet: jq​

# ═══ BÁSICO ═══
echo '{"a":1}' | jq '.'                    # Formatear
echo '{"a":1}' | jq '.a'                   # Extraer campo
echo '{"a":"hola"}' | jq -r '.a'           # Sin comillas

# ═══ ANIDADO ═══
echo '{"a":{"b":"valor"}}' | jq '.a.b'

# ═══ ARRAYS ═══
echo '{"arr":[1,2,3]}' | jq '.arr[]'       # Todos
echo '{"arr":[1,2,3]}' | jq '.arr[0]'      # Primero
echo '{"arr":[1,2,3]}' | jq '.arr[-1]'     # Último
echo '{"arr":[1,2,3]}' | jq '.arr | length' # Cantidad

# ═══ FILTROS ═══
echo '[{"n":"a","v":1},{"n":"b","v":2}]' | jq '.[] | select(.v > 1)'
echo '[3,1,2]' | jq 'sort'
echo '[3,1,2]' | jq 'sort | reverse'
echo '[{"hp":35},{"hp":78}]' | jq '(map(.hp) | add) / length'

# ═══ CREAR OBJETOS ═══
echo '{"name":"pikachu","weight":60}' | jq '{pokemon: .name, peso: .weight}'

# ═══ CONSTRUIR JSON ═══
jq -n --arg name "pikachu" --argjson hp 35 '{pokemon: $name, hp: $hp}'

# ═══ DESDE ARCHIVO ═══
jq '.' archivo.json
jq '.campo' archivo.json
jq -r '.campo' archivo.json

Ejemplo 10 — Cheat Sheet: curl​

# ═══ GET ═══
curl -s URL                                 # GET silencioso
curl -s URL | jq '.'                        # GET + formato

# ═══ STATUS CODE ═══
curl -s -o /dev/null -w "%{http_code}" URL
curl -s -o /dev/null -w "HTTP %{http_code} en %{time_total}s\n" URL

# ═══ HEADERS ═══
curl -I URL                                 # Ver headers
curl -H "Authorization: Bearer TOKEN" URL   # Enviar header

# ═══ POST ═══
curl -s -X POST -H "Content-Type: application/json" \
     -d '{"nombre":"ash"}' URL

# ═══ GUARDAR ═══
curl -s URL -o archivo.json                 # En archivo
RESP=$(curl -s URL)                         # En variable

# ═══ MÉTRICAS ═══
curl -s -o /dev/null -w "
  HTTP Code:    %{http_code}
  Total Time:   %{time_total}s
  DNS Time:     %{time_namelookup}s
  Size:         %{size_download} bytes
  Speed:        %{speed_download} bytes/s
" URL

# ═══ POKÉAPI ═══
API="https://pokeapi.co/api/v2"
curl -s "$API/pokemon/pikachu" | jq '.name'
curl -s "$API/pokemon/charizard" | jq '[.types[].type.name]'
curl -s "$API/pokemon?limit=10" | jq '.results[].name'

🔗 Recursos​