Tutorial DevOps: Implementação Prática de Microsserviços com Docker e Kubernetes

Os microsserviços revolucionaram o desenvolvimento de software moderno, permitindo que organizações construam aplicações complexas de forma mais eficiente e escalável. Docker e Kubernetes emergem como tecnologias essenciais neste cenário, oferecendo ferramentas robustas para containerização e orquestração.

Este tutorial apresenta uma abordagem prática para implementar microsserviços usando essas tecnologias em um ambiente DevOps, com exemplos reais e configurações testadas.

Fundamentos dos Microsserviços com Docker

A arquitetura monolítica tradicional apresenta limitações significativas para aplicações que precisam escalar dinamicamente. Os microsserviços dividem aplicações em serviços independentes, cada um com responsabilidades específicas e ciclo de vida próprio.

Docker resolve o problema de isolamento e portabilidade através de containers leves que encapsulam cada microsserviço com suas dependências. Uma pesquisa da CNCF de 2023 mostra que 89% das organizações utilizam containers em produção.

Vantagens Práticas do Docker

• Portabilidade: Containers executam consistentemente em desenvolvimento, teste e produção
• Eficiência: Redução de 60-70% no tempo de deployment comparado a VMs tradicionais
• Isolamento: Cada serviço opera em ambiente próprio sem conflitos de dependências
• Versionamento: Controle preciso de versões através de tags de imagem

Kubernetes: Orquestração Avançada de Containers

Gerenciar dezenas ou centenas de containers manualmente torna-se impraticável rapidamente. Kubernetes automatiza deployment, scaling e management de aplicações containerizadas, oferecendo recursos empresariais como alta disponibilidade e balanceamento de carga.

Recursos Essenciais do Kubernetes

Implementação Prática: E-commerce com Microsserviços

Vamos implementar um sistema de e-commerce dividido em três microsserviços: autenticação, catálogo de produtos e processamento de pagamentos. Cada serviço será containerizado com Docker e orquestrado via Kubernetes.

1. Containerização com Docker

Primeiro, criamos o Dockerfile para o serviço de autenticação:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
USER node
CMD ["npm", "start"]

2. Configuração Kubernetes

Definimos o deployment e service para o microsserviço de autenticação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: auth-service
  labels:
    app: auth
spec:
  replicas: 3
  selector:
    matchLabels:
      app: auth
  template:
    metadata:
      labels:
        app: auth
    spec:
      containers:
      - name: auth-container
        image: auth-service:v1.2.0
        ports:
        - containerPort: 3000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: auth-secrets
              key: db-url
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: auth-service
spec:
  selector:
    app: auth
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: ClusterIP

3. Pipeline CI/CD com GitLab

Automatizamos o deployment com pipeline GitLab CI/CD:

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - docker build -t $CI_REGISTRY_IMAGE/auth-service:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE/auth-service:$CI_COMMIT_SHA

deploy:
  stage: deploy
  script:
    - kubectl set image deployment/auth-service auth-container=$CI_REGISTRY_IMAGE/auth-service:$CI_COMMIT_SHA
    - kubectl rollout status deployment/auth-service
  only:
    - main

Monitoramento e Observabilidade

Implementamos observabilidade completa usando Prometheus para métricas, Grafana para visualização e Jaeger para tracing distribuído. Esta stack fornece visibilidade end-to-end sobre performance e comportamento dos microsserviços.

Para ambientes que requerem conectividade segura entre clusters, VPNs site-to-site podem ser configuradas para comunicação inter-cluster segura.

Melhores Práticas e Otimizações

Gestão de Recursos

• Defina resource limits e requests adequados para cada container
• Utilize Horizontal Pod Autoscaler (HPA) baseado em métricas customizadas
• Implemente Vertical Pod Autoscaler (VPA) para otimização de recursos

Segurança

• Execute containers com usuários não-privilegiados
• Utilize secrets do Kubernetes para dados sensíveis
• Implemente Network Policies para isolamento de rede
• Escaneie imagens regularmente com ferramentas como Trivy

Performance

• Otimize imagens Docker usando multi-stage builds
• Configure readiness e liveness probes adequadamente
• Utilize cache distribuído como Redis para dados compartilhados
• Implemente circuit breakers para resiliência

A combinação de Docker e Kubernetes oferece uma plataforma robusta para microsserviços, mas o sucesso depende de planejamento arquitetônico cuidadoso, monitoramento contínuo e otimização iterativa baseada em métricas reais de produção.