Saltar al contenido principal

Clase 09 — Tips Avanzados y Buenas Prácticas

Archivo de configuración (.curlrc)​

curl lee configuración desde ~/.curlrc al iniciar.

# ~/.curlrc
# Opciones que se aplican a TODAS las peticiones

# Silencioso por defecto
silent

# Seguir redirecciones
location

# Timeouts razonables
connect-timeout = 10
max-time = 60

# User-Agent personalizado
user-agent = "MiEquipo-DevOps/1.0"

# Reintentos
retry = 3
retry-delay = 2
# Ignorar .curlrc para una petición
curl -q https://httpbin.org/get

# Usar un archivo de config diferente
curl -K mi-config.txt https://httpbin.org/get

Archivos de config por proyecto (-K)​

# api-config.txt
header = "Content-Type: application/json"
header = "Accept: application/json"
header = "Authorization: Bearer MY_TOKEN"
silent
max-time = 30
# Usar
curl -K api-config.txt https://api.ejemplo.com/datos
curl -K api-config.txt -X POST -d '{"key":"value"}' https://api.ejemplo.com/crear

Netrc para credenciales​

# ~/.netrc - Almacenar credenciales por host
machine api.github.com
  login mi-usuario
  password ghp_xxxxxxxxxx

machine registry.ejemplo.com
  login admin
  password secreto123
# Usar credenciales de .netrc
curl -n https://api.github.com/user | jq '.login'

# Equivalente a:
curl -u "mi-usuario:ghp_xxxxxxxxxx" https://api.github.com/user

HTTP/2 y HTTP/3​

# Forzar HTTP/2
curl --http2 https://httpbin.org/get

# Forzar HTTP/1.1
curl --http1.1 https://httpbin.org/get

# HTTP/3 (si tu curl lo soporta)
curl --http3 https://cloudflare.com

# Ver qué versión se usó
curl -sI https://google.com 2>&1 | head -1
# HTTP/2 200

Multiplexing con HTTP/2​

# Descargar múltiples archivos en una conexión HTTP/2
curl --http2 -Z \
  -o file1.json https://httpbin.org/get \
  -o file2.json https://httpbin.org/ip \
  -o file3.json https://httpbin.org/headers

# -Z habilita multiplexing (paralelo sobre una conexión)

Seguridad​

Ocultar credenciales​

# ❌ MAL: Token visible en la terminal y en el historial
curl -H "Authorization: Bearer ghp_mi_token_secreto" https://api.github.com/user

# ✅ BIEN: Desde variable de entorno
curl -H "Authorization: Bearer $GITHUB_TOKEN" https://api.github.com/user

# ✅ BIEN: Desde archivo
curl -H @/tmp/auth-header https://api.github.com/user

# ✅ BIEN: Desde .netrc
curl -n https://api.github.com/user

# ✅ BIEN: No guardar en historial de bash
 curl -H "Authorization: Bearer $TOKEN" https://api.com  # Espacio antes del comando

Verificar SSL siempre​

# ❌ MAL: Ignorar SSL (solo en desarrollo/debug)
curl -k https://self-signed.ejemplo.com

# ✅ BIEN: Especificar CA
curl --cacert /etc/ssl/certs/mi-ca.pem https://api.ejemplo.com

# ✅ BIEN: Verificar y mostrar info SSL
curl -v --cert-status https://api.ejemplo.com 2>&1 | grep -E "SSL|certificate"

Limpiar datos sensibles​

# Cuando captures verbose para debug, limpia tokens
curl -v https://api.ejemplo.com 2>&1 | \
  sed 's/Authorization: .*/Authorization: [REDACTED]/'

Perfiles de conexión​

#!/bin/bash
# profiles.sh - Perfiles de conexión para diferentes ambientes

case "${AMBIENTE:-dev}" in
    dev)
        export API_URL="http://localhost:8080"
        export API_TOKEN="dev-token-123"
        ;;
    staging)
        export API_URL="https://staging.api.com"
        export API_TOKEN="$STAGING_TOKEN"
        ;;
    prod)
        export API_URL="https://api.com"
        export API_TOKEN="$PROD_TOKEN"
        ;;
esac

# Función con perfil
api() {
    curl -s \
      -H "Authorization: Bearer $API_TOKEN" \
      -H "Content-Type: application/json" \
      --max-time 30 \
      "${API_URL}$1"
}

# Uso
AMBIENTE=staging api /health
AMBIENTE=prod api /users | jq '.'

Convertir curl a código​

# curl genera comandos que puedes convertir a:
# Python: https://curlconverter.com/python/
# JavaScript: https://curlconverter.com/javascript/
# Go, PHP, Rust, etc.

# Ejemplo de curl:
curl -X POST 'https://api.ejemplo.com/deploy' \
  -H 'Authorization: Bearer token123' \
  -H 'Content-Type: application/json' \
  -d '{"version": "2.0"}'

# Equivalente en Python:
# import requests
# response = requests.post(
#     'https://api.ejemplo.com/deploy',
#     headers={'Authorization': 'Bearer token123', 'Content-Type': 'application/json'},
#     json={'version': '2.0'}
# )

Importar/Exportar desde Chrome​

# 1. Abrir Chrome DevTools → Network
# 2. Click derecho en una petición
# 3. "Copy as cURL"
# 4. Pegar en terminal

# Limpiar: quitar headers innecesarios
curl -s 'https://api.ejemplo.com/datos' \
  -H 'Accept: application/json' \
  -H 'Cookie: session=abc123' | jq '.'

Cheat Sheet completo​

MÉTODOS:
  curl URL                     # GET (default)
  curl -X POST URL -d '{}'    # POST con JSON
  curl -X PUT URL -d '{}'     # PUT
  curl -X PATCH URL -d '{}'   # PATCH
  curl -X DELETE URL           # DELETE
  curl -I URL                  # HEAD (solo headers)

HEADERS:
  -H "Key: Value"             # Agregar header
  -H "Content-Type: application/json"
  -H "Authorization: Bearer TOKEN"
  -A "User-Agent"             # User-Agent shortcut

DATOS:
  -d '{"key":"value"}'        # Body (POST/PUT)
  -d @archivo.json            # Body desde archivo
  -d "key=value"              # Form data
  --data-urlencode "k=v"      # URL encoded
  --data-binary @file         # Binario (preserva newlines)
  -F "file=@foto.jpg"         # Multipart (upload)

AUTH:
  -u user:pass                # Basic Auth
  -H "Authorization: Bearer TOKEN"  # Bearer
  -n                          # Usar ~/.netrc
  --digest -u user:pass       # Digest Auth

SALIDA:
  -o archivo                  # Guardar en archivo
  -O                          # Guardar con nombre original
  -s                          # Silencioso
  -v                          # Verbose (debug)
  -i                          # Incluir headers
  -I                          # Solo headers
  -w "format"                 # Write-out format

CONEXIÓN:
  -L                          # Seguir redirecciones
  --max-redirs N              # Máx redirecciones
  --connect-timeout N         # Timeout conexión
  --max-time N                # Timeout total
  --retry N                   # Reintentos
  -k                          # Ignorar SSL (⚠️)
  -x proxy:port               # Usar proxy

WRITE-OUT VARIABLES:
  %{http_code}                # Código HTTP
  %{time_total}               # Tiempo total
  %{time_namelookup}          # DNS
  %{time_connect}             # TCP connect
  %{time_appconnect}          # SSL handshake
  %{time_starttransfer}       # TTFB
  %{size_download}            # Bytes descargados
  %{speed_download}           # Velocidad
  %{remote_ip}                # IP del servidor
  %{ssl_verify_result}        # SSL check (0=OK)

Errores comunes y soluciones​

ErrorCausaSolución
curl: (6) Could not resolve hostDNS no resuelveVerificar dominio, DNS, red
curl: (7) Failed to connectNo hay conexiónVerificar IP, puerto, firewall
curl: (22) 404 Not FoundRecurso no existeVerificar URL (con --fail)
curl: (28) Operation timed outTimeout excedidoAumentar --max-time
curl: (35) SSL connect errorProblema SSLVerificar cert, usar --cacert
curl: (51) SSL peer certificateCert no confiableVerificar CA, no usar -k en prod
curl: (56) Recv failureConexión cortadaReintentar, verificar servidor
JSON sin formatoFalta jqPipear a jq '.'

Ejercicios finales​

  1. Creá un archivo ~/.curlrc con configuración por defecto sensata
  2. Implementá un script con perfiles (dev/staging/prod) que use variables de entorno
  3. Usá -w con formato JSON para crear un reporte de latencia de 10 URLs
  4. Copiá una petición de Chrome DevTools, limpiá los headers innecesarios y convertila en un script
  5. Creá un script completo de deploy que incluya: verificación, despliegue, health check y notificación