Preguntas de entrevista para Junior SRE con respuestas

# Ejemplo de cálculo de SLI/SLO
def calcular_presupuesto_error(total_solicitudes, solicitudes_fallidas, objetivo_slo=0.999):
    """
    Calcula el consumo del presupuesto de error
    
    SLO: 99.9% de tasa de éxito
    Presupuesto de error: 0.1% de fallos permitidos
    """
    tasa_exito = (total_solicitudes - solicitudes_fallidas) / total_solicitudes
    tasa_error = solicitudes_fallidas / total_solicitudes
    
    # Presupuesto de error: cuánto del 0.1% permitido hemos usado
    errores_permitidos = total_solicitudes * (1 - objetivo_slo)
    presupuesto_consumido = (solicitudes_fallidas / errores_permitidos) * 100
    
    return {
        'tasa_exito': tasa_exito,
        'tasa_error': tasa_error,
        'objetivo_slo': objetivo_slo,
        'slo_cumplido': tasa_exito >= objetivo_slo,
        'presupuesto_error_consumido': presupuesto_consumido,
        'presupuesto_restante': max(0, 100 - presupuesto_consumido)
    }

# Ejemplo
resultado = calcular_presupuesto_error(
    total_solicitudes=1000000,
    solicitudes_fallidas=500,  # 0.05% de tasa de error
    objetivo_slo=0.999
)

print(f"Tasa de Éxito: {resultado['tasa_exito']:.4%}")
print(f"SLO Cumplido: {resultado['slo_cumplido']}")
print(f"Presupuesto de Error Consumido: {resultado['presupuesto_error_consumido']:.1f}%")

# Ejemplo: Automatizar el reinicio del servicio
#!/bin/bash
# auto-restart-service.sh

SERVICE_NAME="myapp"
MAX_RETRIES=3
RETRY_DELAY=5

check_service() {
    systemctl is-active --quiet $SERVICE_NAME
    return $?
}

restart_service() {
    echo "$(date): Reiniciando $SERVICE_NAME"
    systemctl restart $SERVICE_NAME
    
    # Esperar a que el servicio se estabilice
    sleep $RETRY_DELAY
    
    if check_service; then
        echo "$(date): $SERVICE_NAME reiniciado correctamente"
        # Enviar notificación
        curl -X POST https://alerts.company.com/webhook \
          -d "{\"message\": \"$SERVICE_NAME auto-reiniciado\"}"
        return 0
    else
        return 1
    fi
}

# Lógica principal
if ! check_service; then
    echo "$(date): $SERVICE_NAME está inactivo"
    
    for i in $(seq 1 $MAX_RETRIES); do
        echo "Intento $i de $MAX_RETRIES"
        if restart_service; then
            exit 0
        fi
        sleep $RETRY_DELAY
    done
    
    # Todos los reintentos fallaron - escalar
    echo "$(date): Falló el reinicio de $SERVICE_NAME después de $MAX_RETRIES intentos"
    curl -X POST https://pagerduty.com/api/incidents \
      -d "{\"service\": \"$SERVICE_NAME\", \"severity\": \"critical\"}"
    exit 1
fi

# Configuración de scraping de Prometheus
scrape_configs:
  - job_name: 'api-server'
    static_configs:
      - targets: ['localhost:8080']
    metrics_path: '/metrics'
    scrape_interval: 15s

# Mal: Alerta sobre CPU alta
- alert: HighCPU
  expr: cpu_usage > 80
  
# Bien: Alerta sobre el impacto en el usuario
- alert: HighLatency
  expr: http_request_duration_seconds{quantile="0.95"} > 1
  for: 5m
  annotations:
    summary: "La latencia de la API es alta"
    description: "La latencia del percentil 95 es {{ $value }}s"

- alert: DatabaseConnectionPoolExhausted
  expr: db_connection_pool_active / db_connection_pool_max > 0.9
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "El pool de conexiones de la base de datos está casi agotado"
    runbook: "https://wiki.company.com/runbooks/db-connections"

# Digno de una llamada de guardia (despierta a alguien)
- alert: ServiceDown
  expr: up{job="api"} == 0
  for: 1m
  labels:
    severity: critical
    
# Digno de un ticket (manejar durante las horas de trabajo)
- alert: DiskSpaceWarning
  expr: disk_free_percent < 20
  for: 30m
  labels:
    severity: warning

# Lista de verificación de evaluación rápida
- ¿Cuál es el impacto en el usuario?
- ¿Cuántos usuarios afectados?
- ¿Qué servicios se ven afectados?
- ¿Está empeorando?

# Estrategias comunes de mitigación
- Revertir el despliegue reciente
- Escalar los recursos
- Desactivar la característica problemática
- Failover al sistema de respaldo
- Limitar la tasa de tráfico

# Plantilla de Postmortem de Incidentes

## Resumen
Breve descripción de lo que sucedió

## Impacto
- Duración: 2024-11-25 10:00 - 10:45 UTC (45 minutos)
- Usuarios afectados: ~10,000 (5% del total)
- Servicios impactados: API, Web Frontend

## Causa Raíz
El pool de conexiones de la base de datos se agotó debido a consultas lentas

## Cronología
- 10:00: Se disparó la alerta por alta latencia de la API
- 10:05: El ingeniero de guardia reconoció
- 10:10: Se identificó la base de datos como cuello de botella
- 10:15: Se aumentó el tamaño del pool de conexiones (mitigación)
- 10:30: Se identificaron y eliminaron las consultas lentas
- 10:45: El servicio se recuperó por completo

## Resolución
- Inmediata: Se aumentó el pool de conexiones de 100 a 200
- A corto plazo: Se añadió un tiempo de espera de la consulta (30s)
- A largo plazo: Optimizar las consultas lentas, añadir la monitorización de las consultas

## Elementos de Acción
- [ ] Añadir alerta para las consultas lentas (Responsable: Alice, Vencimiento: 2024-12-01)
- [ ] Implementar el tiempo de espera de la consulta en la aplicación (Responsable: Bob, Vencimiento: 2024-12-05)
- [ ] Revisar y optimizar las 10 consultas más lentas (Responsable: Charlie, Vencimiento: 2024-12-10)

## Lecciones Aprendidas
- La monitorización del pool de conexiones era insuficiente
- La degradación del rendimiento de las consultas pasó desapercibida

# 1. Verificar el problema
curl -w "@curl-format.txt" -o /dev/null -s https://api.example.com/health

# curl-format.txt:
#     time_namelookup:  %{time_namelookup}s\n
#        time_connect:  %{time_connect}s\n
#     time_appconnect:  %{time_appconnect}s\n
#    time_pretransfer:  %{time_pretransfer}s\n
#       time_redirect:  %{time_redirect}s\n
#  time_starttransfer:  %{time_starttransfer}s\n
#                     ----------\n
#          time_total:  %{time_total}s\n

# 2. Comprobar las métricas de la aplicación
# - Tasa de solicitudes (¿pico repentino?)
# - Tasa de errores (¿errores que causan reintentos?)
# - Uso de recursos (CPU, memoria)

# 3. Comprobar las dependencias
# - Tiempo de consulta de la base de datos
# - Llamadas a la API externa
# - Tasa de aciertos de la caché

# 4. Comprobar la infraestructura
top  # Uso de la CPU
free -h  # Memoria
iostat  # E/S del disco
netstat -s  # Estadísticas de la red

# 5. Comprobar los registros en busca de errores
tail -f /var/log/app/error.log | grep -i "timeout\|slow\|error"

# 6. Perfilar la aplicación
# Ejemplo de Python
import cProfile
cProfile.run('mi_funcion()')

# 7. Comprobar la base de datos
# Registro de consultas lentas
SELECT * FROM mysql.slow_log ORDER BY query_time DESC LIMIT 10;

# Consultas activas
SELECT pid, query, state, query_start 
FROM pg_stat_activity 
WHERE state = 'active';

#!/usr/bin/env python3
"""
Comprobador de salud del servicio con capacidad de auto-reinicio
"""
import requests
import subprocess
import time
import sys
from datetime import datetime

class ServiceMonitor:
    def __init__(self, service_name, health_url, max_retries=3):
        self.service_name = service_name
        self.health_url = health_url
        self.max_retries = max_retries
    
    def check_health(self):
        """Comprobar si el servicio está sano"""
        try:
            response = requests.get(
                self.health_url,
                timeout=5
            )
            return response.status_code == 200
        except requests.exceptions.RequestException as e:
            print(f"{datetime.now()}: La comprobación de salud falló: {e}")
            return False
    
    def restart_service(self):
        """Reiniciar el servicio usando systemctl"""
        try:
            print(f"{datetime.now()}: Reiniciando {self.service_name}")
            subprocess.run(
                ['systemctl', 'restart', self.service_name],
                check=True,
                capture_output=True
            )
            time.sleep(10)  # Esperar a que el servicio se inicie
            return True
        except subprocess.CalledProcessError as e:
            print(f"{datetime.now()}: El reinicio falló: {e.stderr}")
            return False
    
    def send_alert(self, message, severity='warning'):
        """Enviar alerta al sistema de monitorización"""
        try:
            requests.post(
                'https://alerts.company.com/webhook',
                json={
                    'service': self.service_name,
                    'message': message,
                    'severity': severity,
                    'timestamp': datetime.now().isoformat()
                },
                timeout=5
            )
        except Exception as e:
            print(f"Falló el envío de la alerta: {e}")
    
    def monitor(self):
        """Bucle principal de monitorización"""
        if self.check_health():
            print(f"{datetime.now()}: {self.service_name} está sano")
            return 0
        
        print(f"{datetime.now()}: {self.service_name} no está sano")
        self.send_alert(f"{self.service_name} está inactivo", severity='warning')
        
        # Intentar reiniciar
        for attempt in range(1, self.max_retries + 1):
            print(f"Intento de reinicio {attempt}/{self.max_retries}")
            
            if self.restart_service() and self.check_health():
                print(f"{datetime.now()}: Servicio recuperado")
                self.send_alert(
                    f"{self.service_name} auto-recuperado después del reinicio",
                    severity='info'
                )
                return 0
            
            time.sleep(5)
        
        # Todos los reintentos fallaron
        print(f"{datetime.now()}: Falló la recuperación del servicio")
        self.send_alert(
            f"{self.service_name} falló la recuperación después de {self.max_retries} intentos",
            severity='critical'
        )
        return 1

if __name__ == '__main__':
    monitor = ServiceMonitor(
        service_name='myapp',
        health_url='http://localhost:8080/health'
    )
    sys.exit(monitor.monitor())

# Runbook: Alta Latencia de la API

## Síntomas
- Latencia del percentil 95 de la API > 1 segundo
- Quejas de los usuarios sobre la lentitud en la carga de la página
- Alerta: "HighAPILatency" disparándose

## Gravedad
**Advertencia** - Degrada la experiencia del usuario pero el servicio es funcional

## Pasos de Investigación

### 1. Comprobar las métricas actuales
```bash
# Comprobar la distribución de la latencia
curl -s http://prometheus:9090/api/v1/query?query='histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))'

# Comprobar la tasa de solicitudes
curl -s http://prometheus:9090/api/v1/query?query='rate(http_requests_total[5m])'

# Conexiones de la base de datos
mysql -e "SHOW PROCESSLIST;"

# Latencia de Redis
redis-cli --latency

# APIs externas
curl -w "%{time_total}\n" -o /dev/null -s https://external-api.com/health

kubectl scale deployment api --replicas=10

redis-cli CONFIG SET maxmemory-policy allkeys-lru

kubectl rollout undo deployment/api

kubectl apply -f rate-limit-config.yaml

from enum import Enum
import time

class CircuitState(Enum):
    CLOSED = "closed"  # Operación normal
    OPEN = "open"      # Fallando, rechazar solicitudes
    HALF_OPEN = "half_open"  # Probando la recuperación

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = None
        self.state = CircuitState.CLOSED
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if time.time() - self.last_failure_time > self.timeout:
                self.state = CircuitState.HALF_OPEN
            else:
                # Devolver fallback en lugar de llamar al servicio que falla
                return self.fallback()
        
        try:
            result = func(*args, **kwargs)
            self.on_success()
            return result
        except Exception as e:
            self.on_failure()
            return self.fallback()
    
    def on_success(self):
        self.failures = 0
        self.state = CircuitState.CLOSED
    
    def on_failure(self):
        self.failures += 1
        self.last_failure_time = time.time()
        if self.failures >= self.failure_threshold:
            self.state = CircuitState.OPEN
    
    def fallback(self):
        # Devolver datos en caché o respuesta por defecto
        return {"status": "degraded", "data": []}

# Uso
breaker = CircuitBreaker()
result = breaker.call(external_api_call, user_id=123)

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_resilient_session():
    session = requests.Session()
    
    # Estrategia de reintento
    retry = Retry(
        total=3,
        backoff_factor=0.3,
        status_forcelist=[500, 502, 503, 504]
    )
    
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('http://', adapter)
    session.mount('https://', adapter)
    
    return session

# Uso con timeout
session = create_resilient_session()
try:
    response = session.get('https://api.example.com/data', timeout=5)
except requests.exceptions.Timeout:
    # Degradación elegante - usar datos en caché
    response = get_cached_data()

# Pull una imagen
docker pull nginx:latest

# Ejecutar un contenedor
docker run -d \
  --name my-nginx \
  -p 8080:80 \
  nginx:latest

# Listar los contenedores en ejecución
docker ps

# Ver los registros
docker logs my-nginx

# Ejecutar un comando en el contenedor
docker exec -it my-nginx bash

# Detener el contenedor
docker stop my-nginx

# Eliminar el contenedor
docker rm my-nginx

# Imagen base
FROM python:3.12-slim

# Establecer el directorio de trabajo
WORKDIR /app

# Copiar los requisitos
COPY requirements.txt .

# Instalar las dependencias
RUN pip install --no-cache-dir -r requirements.txt

# Copiar el código de la aplicación
COPY . .

# Exponer el puerto
EXPOSE 8000

# Comprobación de salud
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8000/health || exit 1

# Ejecutar la aplicación
CMD ["python", "app.py"]

# Construir la imagen
docker build -t myapp:1.0 .

# Ejecutar con variables de entorno
docker run -d \
  --name myapp \
  -p 8000:8000 \
  -e DATABASE_URL=postgres://db:5432/mydb \
  -e LOG_LEVEL=info \
  myapp:1.0

# Ver el uso de recursos
docker stats myapp

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://db:5432/mydb
    depends_on:
      - db
      - redis
    restart: unless-stopped
  
  db:
    image: postgres:14
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_PASSWORD=secret
    volumes:
      - postgres_data:/var/lib/postgresql/data
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# Iniciar todos los servicios
docker compose up -d

# Ver los registros
docker compose logs -f web

# Escalar el servicio
docker compose up -d --scale web=3

# Detener todos los servicios
docker compose down

# Clonar el repositorio
git clone https://github.com/company/repo.git
cd repo

# Crear una rama de características
git checkout -b feature/add-monitoring

# Hacer cambios y commit
git add .
git commit -m "Añadir monitorización de Prometheus"

# Push al remoto
git push origin feature/add-monitoring

# Actualizar desde main
git checkout main
git pull origin main
git checkout feature/add-monitoring
git rebase main

# Fusionar la característica (después de la aprobación del PR)
git checkout main
git merge feature/add-monitoring
git push origin main

# Ramas de características de corta duración
git checkout -b feature/arreglo-rapido
# Trabajar durante < 1 día
git push origin feature/arreglo-rapido
# Fusionar a main inmediatamente después de la revisión

name: Desplegar a Producción

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Ejecutar pruebas
        run: |
          npm install
          npm test
      
      - name: Ejecutar linting
        run: npm run lint
  
  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Construir la imagen de Docker
        run: |
          docker build -t myapp:${{