Microservicios

Arquitectura de microservicios, Docker, Kubernetes, API Gateway, service mesh y orquestación

Objetivos de Aprendizaje

Introducción a Microservicios

Monolito vs Microservicios

Arquitectura Monolítica

UI
Business Logic
Data Access
Database
Ventajas
  • Desarrollo inicial simple
  • Fácil testing e2e
  • Deployment sencillo
  • Debugging directo
Desventajas
  • Escalabilidad limitada
  • Tecnología única
  • Deployments riesgosos
  • Mantenimiento complejo

Arquitectura de Microservicios

User Service
Order Service
Payment Service
Inventory Service
Notification Service
Analytics Service
API Gateway
Ventajas
  • Escalabilidad independiente
  • Tecnologías diversas
  • Deployments independientes
  • Equipos autónomos
Desventajas
  • Complejidad de red
  • Consistencia de datos
  • Testing distribuido
  • Monitoreo complejo

Principios de Microservicios

Single Responsibility

Cada servicio tiene una responsabilidad específica y bien definida

Loose Coupling

Servicios independientes con mínimas dependencias entre ellos

High Cohesion

Funcionalidades relacionadas agrupadas en el mismo servicio

Database per Service

Cada servicio gestiona su propia base de datos

Decentralized

Gobierno descentralizado y autonomía de equipos

Fault Tolerance

Diseño resiliente ante fallos de otros servicios

Docker y Containerización

Containerización con Docker

Docker permite empaquetar aplicaciones con todas sus dependencias en contenedores ligeros y portables, garantizando consistencia entre entornos.

Portabilidad

Ejecuta en cualquier entorno que soporte Docker

Aislamiento

Aplicaciones aisladas sin conflictos de dependencias

Eficiencia

Menor overhead que máquinas virtuales

Escalabilidad

Fácil escalado horizontal de servicios

Dockerfile para Microservicio Django

# Dockerfile
FROM python:3.11-slim

# Establecer directorio de trabajo
WORKDIR /app

# Instalar dependencias del sistema
RUN apt-get update && apt-get install -y \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

# Copiar requirements y instalar dependencias Python
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

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

# Crear usuario no-root
RUN adduser --disabled-password --gecos '' appuser && \
    chown -R appuser:appuser /app
USER appuser

# Exponer puerto
EXPOSE 8000

# Variables de entorno
ENV PYTHONPATH=/app
ENV DJANGO_SETTINGS_MODULE=config.settings.production

# Comando de inicio
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "config.wsgi:application"]

Docker Compose para Múltiples Servicios

# docker-compose.yml
version: '3.8'

services:
  # API Gateway
  api-gateway:
    build: ./api-gateway
    ports:
      - "80:80"
    depends_on:
      - user-service
      - order-service
      - payment-service
    environment:
      - USER_SERVICE_URL=http://user-service:8000
      - ORDER_SERVICE_URL=http://order-service:8001
      - PAYMENT_SERVICE_URL=http://payment-service:8002
    networks:
      - microservices-network

  # User Service
  user-service:
    build: ./user-service
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:password@user-db:5432/userdb
      - REDIS_URL=redis://redis:6379/0
    depends_on:
      - user-db
      - redis
    networks:
      - microservices-network

  # Order Service
  order-service:
    build: ./order-service
    ports:
      - "8001:8000"
    environment:
      - DATABASE_URL=postgresql://order:password@order-db:5432/orderdb
      - USER_SERVICE_URL=http://user-service:8000
    depends_on:
      - order-db
    networks:
      - microservices-network

  # Payment Service
  payment-service:
    build: ./payment-service
    ports:
      - "8002:8000"
    environment:
      - DATABASE_URL=postgresql://payment:password@payment-db:5432/paymentdb
      - STRIPE_SECRET_KEY=${STRIPE_SECRET_KEY}
    depends_on:
      - payment-db
    networks:
      - microservices-network

  # Databases
  user-db:
    image: postgres:15
    environment:
      - POSTGRES_DB=userdb
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - user_data:/var/lib/postgresql/data
    networks:
      - microservices-network

  order-db:
    image: postgres:15
    environment:
      - POSTGRES_DB=orderdb
      - POSTGRES_USER=order
      - POSTGRES_PASSWORD=password
    volumes:
      - order_data:/var/lib/postgresql/data
    networks:
      - microservices-network

  payment-db:
    image: postgres:15
    environment:
      - POSTGRES_DB=paymentdb
      - POSTGRES_USER=payment
      - POSTGRES_PASSWORD=password
    volumes:
      - payment_data:/var/lib/postgresql/data
    networks:
      - microservices-network

  # Redis para caché
  redis:
    image: redis:7-alpine
    networks:
      - microservices-network

volumes:
  user_data:
  order_data:
  payment_data:

networks:
  microservices-network:
    driver: bridge

Kubernetes y Orquestación

Orquestación con Kubernetes

Kubernetes automatiza el despliegue, escalado y gestión de aplicaciones containerizadas, proporcionando alta disponibilidad y recuperación automática.

Componentes Principales

Pod

Unidad mínima de despliegue

Deployment

Gestión de réplicas y actualizaciones

Service

Exposición y balanceo de carga

Ingress

Enrutamiento HTTP/HTTPS

ConfigMap

Configuración de aplicaciones

Secret

Gestión de credenciales

Deployment de Microservicio

# user-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  labels:
    app: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:v1.2.0
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: user-service-secrets
              key: database-url
        - name: REDIS_URL
          valueFrom:
            configMapKeyRef:
              name: user-service-config
              key: redis-url
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health/
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready/
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: ClusterIP

Ingress Controller

# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: microservices-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  tls:
  - hosts:
    - api.miempresa.com
    secretName: api-tls
  rules:
  - host: api.miempresa.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80
      - path: /orders
        pathType: Prefix
        backend:
          service:
            name: order-service
            port:
              number: 80
      - path: /payments
        pathType: Prefix
        backend:
          service:
            name: payment-service
            port:
              number: 80

API Gateway y Service Mesh

API Gateway

Punto de entrada único que gestiona todas las peticiones a los microservicios, proporcionando funcionalidades transversales como autenticación, rate limiting y monitoreo.

Enrutamiento

Dirige peticiones al servicio correcto

Autenticación

Validación centralizada de tokens

Rate Limiting

Control de velocidad de peticiones

Monitoreo

Métricas y logging centralizado

Configuración Kong API Gateway

# kong.yml
_format_version: "3.0"

services:
- name: user-service
  url: http://user-service:8000
  plugins:
  - name: jwt
    config:
      secret_is_base64: false
  - name: rate-limiting
    config:
      minute: 100
      hour: 1000

- name: order-service
  url: http://order-service:8001
  plugins:
  - name: jwt
    config:
      secret_is_base64: false
  - name: cors
    config:
      origins:
      - "https://miapp.com"
      methods:
      - GET
      - POST
      - PUT
      - DELETE

routes:
- name: user-routes
  service: user-service
  paths:
  - /api/users
  - /api/auth

- name: order-routes
  service: order-service
  paths:
  - /api/orders
  - /api/cart

plugins:
- name: prometheus
  config:
    per_consumer: true
- name: file-log
  config:
    path: /var/log/kong/access.log

Service Mesh

Infraestructura dedicada para gestionar comunicación entre servicios, proporcionando observabilidad, seguridad y control de tráfico sin modificar el código de aplicación.

Observabilidad

Métricas, logs y trazas automáticas

Seguridad

mTLS automático entre servicios

Traffic Management

Load balancing y circuit breakers

Policy Enforcement

Políticas de acceso y rate limiting

Configuración Istio Service Mesh

# virtual-service.yaml
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: user-service-vs
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        version:
          exact: v2
    route:
    - destination:
        host: user-service
        subset: v2
      weight: 100
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 80
    - destination:
        host: user-service
        subset: v2
      weight: 20

---
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: user-service-dr
spec:
  host: user-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        http1MaxPendingRequests: 50
        maxRequestsPerConnection: 10
    circuitBreaker:
      consecutiveErrors: 3
      interval: 30s
      baseEjectionTime: 30s
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2

Proyecto en GitHub

Arquitectura de Microservicios Completa

Sistema completo de e-commerce implementado con microservicios, Docker, Kubernetes, API Gateway y service mesh, demostrando todas las tecnologías de esta semana.

Arquitectura del Sistema

Frontend
React SPA Mobile App
API Gateway
Kong Rate Limiting Auth
Microservicios
User Service Product Service Order Service Payment Service Inventory Service Notification Service
Capa de Datos
PostgreSQL MongoDB Redis Elasticsearch

6 Microservicios

Servicios independientes con responsabilidades específicas

Containerización

Docker y Docker Compose para desarrollo local

Kubernetes

Orquestación completa con Helm charts

Service Mesh

Istio para observabilidad y seguridad

Resumen Semana 14

Arquitectura de Microservicios

Comprensión profunda de patrones, principios y trade-offs de la arquitectura de microservicios.

Docker y Containerización

Dominio de Docker para empaquetar y desplegar microservicios de forma consistente.

Kubernetes

Orquestación avanzada con deployments, services, ingress y gestión de configuración.

API Gateway

Implementación de punto de entrada único con funcionalidades transversales.

Service Mesh

Gestión avanzada de comunicación entre servicios con Istio.

Proyecto Completo

Sistema de e-commerce completo implementado con todas las tecnologías de microservicios.