← volver

CI/CD con GitHub Actions: Despliegue azul/verde en Kubernetes con Helm y ArgoCD

Por · · [DevOps] · lectura estimada: ~3 min

Introducción

El despliegue azul/verde es una estrategia que permite lanzar nuevas versiones de una aplicación sin tiempo de inactividad. Al mantener dos entornos idénticos (azul y verde), se puede enrutar el tráfico gradualmente. En este artículo, combinaremos GitHub Actions para CI, Helm para empaquetar la aplicación y ArgoCD para la entrega continua (CD) con la estrategia azul/verde en Kubernetes.

Requisitos previos

  • Un clúster Kubernetes (local o en la nube).
  • Helm CLI instalado.
  • ArgoCD instalado en el clúster.
  • Un repositorio de código fuente en GitHub.

Estructura del repositorio

Organizaremos el repositorio así:

app/ 
  Chart.yaml
  values.yaml
  templates/
    deployment.yaml
    service.yaml
    ingress.yaml
.github/
  workflows/
    ci.yaml

Pipeline CI con GitHub Actions

El workflow de CI se encarga de compilar, probar y empaquetar la aplicación. Además, genera un artefacto con el chart de Helm actualizado.

name: CI
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Build and test
      run: |
        echo "Compilando y probando..."
        # Comandos reales: npm install, npm test, etc.
    - name: Package Helm chart
      run: |
        helm package ./app -d ./charts
    - name: Upload chart
      uses: actions/upload-artifact@v2
      with:
        name: helm-chart
        path: ./charts/

Estrategia azul/verde con Helm

En los templates de Helm, definimos dos deployments: uno para el entorno azul y otro para el verde. Usamos valores como color para alternar.

{{- if eq .Values.color "blue" }}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-blue
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}
      color: blue
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}
        color: blue
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
{{- end }}

El service apunta a un color activo mediante etiquetas:

apiVersion: v1
kind: Service
metadata:
  name: {{ .Release.Name }}-svc
spec:
  selector:
    app: {{ .Release.Name }}
    color: {{ .Values.activeColor }}
  ports:
  - port: {{ .Values.service.port }}

ArgoCD para entrega continua

ArgoCD gestiona la sincronización del estado deseado en el clúster. Creamos una aplicación ArgoCD que apunte al repositorio y use Helm.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
spec:
  project: default
  source:
    repoURL: https://github.com/usuario/repo.git
    targetRevision: HEAD
    path: app
    helm:
      valueFiles:
        - values.yaml
  destination:
    server: https://kubernetes.default.svc
    namespace: default
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Para el despliegue azul/verde, ArgoCD puede usar PreSync y Sync hooks. Por ejemplo, un hook PreSync que cambie el color activo en el service.

apiVersion: batch/v1
kind: Job
metadata:
  generateName: blue-green-switch-
  annotations:
    argocd.argoproj.io/hook: PreSync
spec:
  template:
    spec:
      containers:
      - name: switch
        image: bitnami/kubectl:latest
        command:
        - sh
        - -c
        - |
          kubectl patch service my-app-svc -p '{"spec":{"selector":{"color":"green"}}}'
      restartPolicy: Never

Pipeline CD con GitHub Actions + ArgoCD

El workflow de CD se activa tras la CI. Actualiza el repositorio con el nuevo tag de imagen y fuerza la sincronización de ArgoCD.

name: CD
on:
  workflow_run:
    workflows: ["CI"]
    types:
      - completed
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Update values
      run: |
        sed -i "s/tag:.*/tag: ${{ github.sha }}/" app/values.yaml
    - name: Commit and push
      run: |
        git config user.email "ci@example.com"
        git config user.name "CI"
        git add .
        git commit -m "Update image tag to ${{ github.sha }}"
        git push
    - name: Sync ArgoCD
      run: |
        argocd app sync my-app --prune --timeout 300

Prueba del pipeline

  1. Haz un push a la rama main. El workflow CI se ejecuta y empaqueta el chart.
  2. El workflow CD actualiza el values.yaml con el nuevo tag y hace push.
  3. ArgoCD detecta el cambio y ejecuta el hook PreSync, que cambia el selector del service al nuevo color.
  4. ArgoCD sincroniza el nuevo deployment (verde) y luego el hook PostSync puede eliminar el antiguo (azul) si se desea.

Conclusión

Esta configuración ofrece un pipeline CI/CD completo con despliegue azul/verde en Kubernetes. GitHub Actions proporciona la integración continua, Helm facilita el empaquetado y ArgoCD gestiona la entrega continua con estrategias avanzadas. Puedes extenderlo con pruebas de integración, validaciones y rollback automático.

Recuerda que la clave del éxito es la automatización y la monitorización constante. ¡Implementa este pipeline y reduce el riesgo de tus despliegues!

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal