Arquitetura de Deployment

🚀 Estratégia de Deploy

O Payment Gateway suporta múltiplos ambientes e estratégias de deployment, desde desenvolvimento local até clusters Kubernetes de produção.

🏗️ Ambientes de Deploy

1. Development Environment

# docker-compose.dev.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - DB_TYPE=sqlite
    volumes:
      - .:/app
      - node_modules:/app/node_modules
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

2. Staging Environment

# Kubernetes staging
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-gateway-staging
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: app
        image: payment-gateway:staging
        env:
        - name: NODE_ENV
          value: "staging"
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: staging-url

3. Production Environment

# Kubernetes production
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-gateway-prod
spec:
  replicas: 5
  template:
    spec:
      containers:
      - name: app
        image: payment-gateway:v1.0.0
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

🐳 Containerização

Multi-stage Dockerfile

# Build stage
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# Runtime stage
FROM node:18-alpine AS runtime
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001

WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --chown=nodejs:nodejs . .

USER nodejs
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

CMD ["node", "src/server.js"]

Docker Compose para Produção

version: '3.8'
services:
  app:
    image: payment-gateway:latest
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    environment:
      - NODE_ENV=production
    networks:
      - payment-network
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: payments
      POSTGRES_USER: paymentuser
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

secrets:
  db_password:
    external: true

networks:
  payment-network:
    driver: overlay

☸️ Kubernetes Deployment

Namespace Configuration

apiVersion: v1
kind: Namespace
metadata:
  name: payment-system
  labels:
    environment: production
    team: payments

Application Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-gateway
  namespace: payment-system
spec:
  replicas: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: payment-gateway
  template:
    metadata:
      labels:
        app: payment-gateway
    spec:
      containers:
      - name: payment-gateway
        image: payment-gateway:v1.0.0
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: database-credentials
              key: url
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: redis-credentials
              key: url
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

Service Configuration

apiVersion: v1
kind: Service
metadata:
  name: payment-gateway-service
  namespace: payment-system
spec:
  selector:
    app: payment-gateway
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: ClusterIP

Ingress with TLS

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: payment-gateway-ingress
  namespace: payment-system
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/rate-limit: "100"
spec:
  tls:
  - hosts:
    - api.paymentgateway.com
    secretName: payment-gateway-tls
  rules:
  - host: api.paymentgateway.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: payment-gateway-service
            port:
              number: 80

🔄 CI/CD Pipeline

GitHub Actions Workflow

name: Deploy Payment Gateway

on:
  push:
    branches: [main]
    tags: ['v*']

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        cache: 'npm'
    - run: npm ci
    - run: npm run test
    - run: npm run lint

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Build Docker image
      run: |
        docker build -t payment-gateway:$GITHUB_SHA .
        docker tag payment-gateway:$GITHUB_SHA payment-gateway:latest
    
    - name: Push to registry
      run: |
        echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
        docker push payment-gateway:$GITHUB_SHA
        docker push payment-gateway:latest

  deploy-staging:
    needs: build
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: staging
    steps:
    - name: Deploy to staging
      run: |
        kubectl set image deployment/payment-gateway-staging \
          payment-gateway=payment-gateway:$GITHUB_SHA \
          -n payment-system-staging

  deploy-production:
    needs: build
    if: startsWith(github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
    environment: production
    steps:
    - name: Deploy to production
      run: |
        kubectl set image deployment/payment-gateway \
          payment-gateway=payment-gateway:$GITHUB_SHA \
          -n payment-system

📊 Monitoring e Observabilidade

Prometheus Configuration

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    
    scrape_configs:
    - job_name: 'payment-gateway'
      static_configs:
      - targets: ['payment-gateway-service:80']
      metrics_path: '/metrics'
      scrape_interval: 5s

Grafana Dashboard

{
  "dashboard": {
    "title": "Payment Gateway Metrics",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(http_requests_total[5m])",
            "legendFormat": "{{method}} {{status}}"
          }
        ]
      },
      {
        "title": "Payment Success Rate",
        "type": "stat",
        "targets": [
          {
            "expr": "rate(payments_successful_total[5m]) / rate(payments_total[5m]) * 100"
          }
        ]
      }
    ]
  }
}

🚨 Alerting e Incident Response

AlertManager Rules

groups:
- name: payment-gateway
  rules:
  - alert: HighErrorRate
    expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: High error rate detected
      
  - alert: PaymentProviderDown
    expr: up{job="payment-providers"} == 0
    for: 1m
    labels:
      severity: warning
    annotations:
      summary: Payment provider is down

🔒 Security e Compliance

Network Policies

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: payment-gateway-network-policy
spec:
  podSelector:
    matchLabels:
      app: payment-gateway
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: ingress-nginx
    ports:
    - protocol: TCP
      port: 3000
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: database
    ports:
    - protocol: TCP
      port: 5432

Security Scanning

# Trivy security scan
- name: Run Trivy vulnerability scanner
  uses: aquasecurity/trivy-action@master
  with:
    image-ref: 'payment-gateway:${{ github.sha }}'
    format: 'sarif'
    output: 'trivy-results.sarif'

- name: Upload Trivy scan results
  uses: github/codeql-action/upload-sarif@v2
  with:
    sarif_file: 'trivy-results.sarif'

📈 Scaling e Performance

Horizontal Pod Autoscaler

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: payment-gateway-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: payment-gateway
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Vertical Pod Autoscaler

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: payment-gateway-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: payment-gateway
  updatePolicy:
    updateMode: "Auto"
  resourcePolicy:
    containerPolicies:
    - containerName: payment-gateway
      maxAllowed:
        cpu: 1
        memory: 1Gi
      minAllowed:
        cpu: 100m
        memory: 128Mi

🌍 Multi-Region Deployment

Global Load Balancer

# Global Load Balancer Configuration
apiVersion: v1
kind: Service
metadata:
  name: payment-gateway-global
  annotations:
    cloud.google.com/global-lb: "true"
spec:
  type: LoadBalancer
  selector:
    app: payment-gateway
  ports:
  - port: 443
    targetPort: 3000
    protocol: TCP

Regional Clusters

# Deploy to multiple regions
regions=("us-east-1" "eu-west-1" "ap-southeast-1")

for region in "${regions[@]}"; do
  kubectl config use-context $region
  kubectl apply -f kubernetes/
done

---

Última atualização: December 2024