Migra de Ingress NGINX a Higress en 30 minutos con IA: guía técnica práctica

Introducción

El retiro oficial de Ingress NGINX en marzo de 2026 obliga a los equipos de infraestructura a migrar sus recursos antes de que queden expuestos a vulnerabilidades sin parches. Este artículo te muestra cómo completar la migración de 60+ recursos de Ingress en 30 minutos usando Higress, un API Gateway CNCF basado en Envoy e Istio, con asistencia de IA para automatizar análisis, traducción de configuraciones y validación.

La estrategia combina:

• Auditoría automática de recursos NGINX.
• Entorno simulado con Kind (Kubernetes en Docker).
• Generación de plugins WASM para lógica avanzada.
• Validación en paralelo sin impacto en producción.

Qué es y para qué sirve

• Riesgo de seguridad: Ingress NGINX ya no recibe actualizaciones críticas.
• Oportunidad de modernización: Higress soporta integración nativa con modelos de lenguaje (LLMs).
• Reducción de deuda técnica: Elimina dependencias de Lua scripts y snippets complejos.

Prerequisitos

Versiones exactas

• Cluster admin: Acceso a kubectl con permisos para crear Namespaces, Deployments y Custom Resource Definitions (CRDs).
• Docker Hub / Registry: Credenciales para pull de imágenes de Higress (ej: higress-registry.cn-hangzhou.aliyuncs.com).
• Git: Acceso a repositorio con los manifests de Ingress actuales (opcional, pero recomendado para auditoría).

Herramientas adicionales

# Instalar Kind (Linux/macOS)
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-$(uname)-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# Instalar Higress CLI
curl -Lo higressctl https://github.com/higress-group/higress/releases/download/v1.2.0/higressctl-$(uname)-amd64
chmod +x higressctl
sudo mv higressctl /usr/local/bin/

Guía paso a paso

Paso 1: Auditar recursos Ingress existentes

1. Listar todos los Ingress:

   kubectl get ingress --all-namespaces -o custom-columns="NAME:.metadata.name,NAMESPACE:.metadata.namespace,ANNOTATIONS:.metadata.annotations" > ingress_backup.txt
   

– Resultado esperado: Archivo ingress_backup.txt con ~60+ entradas similares a:

     NAME          NAMESPACE   ANNOTATIONS
     app-ingress   prod        nginx.ingress.kubernetes.io/rewrite-target: /,nginx.ingress.kubernetes.io/ssl-redirect: "true"
     

1. Filtrar annotations problemáticas (requieren traducción manual o automática):

   grep -E "nginx\.ingress\.kubernetes\.io|kubernetes\.io/ingress\.class: nginx" ingress_backup.txt > annotations_ngx.txt
   

– Resultado esperado: Archivo con annotations como nginx.ingress.kubernetes.io/configuration-snippet o nginx.ingress.kubernetes.io/server-snippet.

Paso 2: Crear entorno simulado con Kind

1. Crear cluster Kind:

   kind create cluster --name higress-migration --config=- <<EOF
   kind: Cluster
   apiVersion: kind.x-k8s.io/v1alpha4
   nodes:
   - role: control-plane
     image: kindest/node:v1.28.0
   EOF
   

– Resultado esperado: Cluster en Ready (verificar con kubectl get nodes).

1. Instalar Higress con status deshabilitado:

   helm repo add higress https://higress-group.github.io/higress-charts
   helm repo update
   helm install higress higress/higress -n higress-system --create-namespace \
     --set global.enableStatus=false \
     --set global.logLevel=debug
   

– Resultado esperado:

     kubectl -n higress-system get pods
     NAME                        READY   STATUS    RESTARTS   AGE
     higress-7d8f5c9d8-abc12   1/1     Running   0          30s
     

– Nota: enableStatus=false evita que Higress actualice el campo status de los Ingress, permitiendo coexistencia con NGINX.

Paso 3: Migrar recursos con asistencia de IA

• Traducir annotations NGINX a sintaxis Higress.
• Generar plugins WASM para lógica avanzada.

Opción A: Usar el agente de Higress (recomendado)

1. Clonar el repositorio de habilidades de migración:

   git clone https://github.com/higress-group/ai-migration-skills.git
   cd ai-migration-skills/nginx-to-higress
   

1. Ejecutar auditoría automática:

   ./migrate.sh audit --ingress-file ingress_backup.txt --output-dir ./migration-reports
   

– Salida esperada: Archivos JSON con análisis de cada Ingress, ej:

     {
       "ingress": "app-ingress",
       "annotations": {
         "nginx.ingress.kubernetes.io/rewrite-target": "/",
         "risk": "high"
       }
     }
     

1. Generar manifests Higress:

   ./migrate.sh convert --input ./migration-reports/app-ingress.json --output higress-ingress.yaml
   

– Resultado esperado: Archivo higress-ingress.yaml con traducción directa:

     apiVersion: networking.k8s.io/v1
     kind: Ingress
     metadata:
       name: app-ingress
       namespace: prod
     spec:
       rules:
       - host: app.example.com
         http:
           paths:
           - path: /
             pathType: Prefix
             backend:
               service:
                 name: app-service
                 port:
                   number: 80
     

Opción B: Generar plugins WASM para lógica compleja

   location /custom {
     set $test "hello";
     echo $test;
   }
   

1. Generar plugin WASM con IA:

   cd ai-migration-skills/higress-wasm-go-plugin
   ./generate-plugin.sh --snippet "$(cat custom-snippet.conf)" --output custom-plugin.wasm
   

– Resultado esperado: Archivo custom-plugin.wasm compilado para Higress.

1. Aplicar plugin en Higress:

   # En higress-ingress.yaml
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: app-ingress
     annotations:
       higress.io/wasm-plugins: "custom-plugin.wasm"
   spec: ...
   

Paso 4: Validar migración en entorno simulado

1. Aplicar manifests Higress:

   kubectl apply -f higress-ingress.yaml
   

1. Verificar reglas de routing:

   higressctl get routes --namespace prod
   

– Resultado esperado: Tabla con rutas activas, ej:

     NAMESPACE   ROUTE_NAME   HOST          MATCH   SERVICE   STATUS
     prod        app-ingress  app.example.com  /      app-svc   Synced
     

1. Probar tráfico:

   # Obtener IP del Ingress (Kind usa NodePort)
   kubectl get svc -n higress-system higress -o jsonpath='{.spec.ports[0].nodePort}'
   curl -H "Host: app.example.com" http://<NODE_IP>:<NODE_PORT>/
   

– Resultado esperado: Respuesta idéntica a la configuración original con NGINX.

Paso 5: Implementar en producción (migración segura)

1. Desinstalar NGINX:

   helm uninstall ingress-nginx -n ingress-nginx  # Si usabas Helm
   kubectl delete -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.8.2/deploy/static/provider/cloud/deploy.yaml
   

1. Instalar Higress en producción:

   helm install higress higress/higress -n higress-system \
     --set global.enableStatus=true \
     --set controller.service.type=LoadBalancer
   

1. Aplicar manifests migrados:

   kubectl apply -f higress-ingress.yaml
   

1. Verificar status de Ingress:

   kubectl get ingress --all-namespaces -w
   

– Resultado esperado: Todos los Ingress con ADDRESS asignado y AGE > 0.

1. Monitorear tráfico:

   kubectl -n higress-system logs -l app=higress-controller --tail=50
   

– Filtro útil: Busca errores como 502 Bad Gateway o 404 Not Found.

Consideraciones y buenas prácticas

1. Limitaciones conocidas

• Annotations no soportadas: Algunas como nginx.ingress.kubernetes.io/auth-url requieren traducción manual a authentication en Higress.

• WebSockets: Higress soporta WebSockets, pero configura el timeout explícitamente:

  apiVersion: networking.k8s.io/v1
  kind: Ingress
  metadata:
    annotations:
      higress.io/backend-protocol: "WebSocket"
      higress.io/timeout: "3600"
  

2. Riesgos y mitigaciones

• Istio Ingress Gateway: Si ya usas Istio, migra directamente a su controlador de Ingress (menos disruptivo, pero menos features AI-native).
• Traefik: Otra opción CNCF, pero sin soporte nativo para WASM en routing avanzado.

4. Monitoreo post-migración

Configura alertas para:

• Latencia: Umbral > 500ms en el 95% de las peticiones.
• Errores 5xx: Umbral > 0.1%.
• Uso de CPU/Memoria: Higress debe usar < 20% de los recursos del nodo.

Conclusión

La migración de Ingress NGINX a Higress es inevitable por razones de seguridad, pero puede hacerse en 30 minutos con el enfoque correcto:

1. Audita tus recursos con IA para identificar qué necesita traducción.
2. Simula el entorno con Kind para validar sin riesgos.
3. Genera manifests y plugins WASM automáticamente.
4. Valida el routing en paralelo antes de aplicar en producción.
5. Monitoriza el nuevo gateway para detectar anomalías tempranas.

Higress no solo resuelve la migración, sino que prepara tu infraestructura para la era de los modelos de lenguaje, con soporte nativo para LLMs y WebAssembly. No esperes a que expire tu NGINX: sigue esta guía y haz el cambio hoy.

FIN