Nacos Kubernetes: 7 Pasos para Service Discovery 2026

Nacos Kubernetes es la solución definitiva para implementar service discovery y gestión de configuración dinámica en tus clusters de Kubernetes. Con más de 32.500 estrellas en GitHub y respaldado por Alibaba, Nacos Kubernetes se ha convertido en 2026 en la plataforma preferida para arquitecturas de microservicios cloud-native que requieren descubrimiento de servicios automático, health checks en tiempo real y configuración centralizada sin redeploys.

En esta guía completa, aprenderás cómo desplegar y configurar Nacos Kubernetes en tu infraestructura en 7 pasos prácticos, desde la instalación básica hasta configuraciones avanzadas con StatefulSets, Nacos Operator y persistencia con NFS. Descubrirás por qué empresas como Alibaba, ICBC y Huya confían en esta plataforma para gestionar miles de microservicios en producción.

¿Qué es Nacos Kubernetes?

Nacos Kubernetes (Dynamic Naming and Configuration Service) es una plataforma open-source de Alibaba diseñada específicamente para la gestión de microservicios en entornos cloud-native. Cuando hablamos de Nacos Kubernetes, nos referimos a la integración nativa de Nacos con clusters de Kubernetes mediante el proyecto nacos-k8s, que facilita el despliegue mediante StatefulSets, Helm charts y el Nacos Operator.

A diferencia de otras soluciones como Consul o Eureka, Nacos Kubernetes ofrece cuatro capacidades fundamentales integradas en una sola plataforma: service discovery con DNS y HTTP, health checks automáticos, configuración dinámica sin redepliegues, y DNS dinámico con políticas de routing avanzadas. Esta combinación única lo convierte en una solución más completa y específica para ecosistemas Kubernetes.

Arquitectura de Nacos Kubernetes

La arquitectura de Nacos en Kubernetes se compone de tres capas principales. En la capa de datos, Nacos puede funcionar en modo standalone con base de datos embebida o en modo cluster con MySQL/PostgreSQL externo para alta disponibilidad. En la capa de servicios, los pods de Nacos se despliegan como StatefulSets para garantizar identidades de red estables y volúmenes persistentes.

Los microservicios en tu cluster se registran automáticamente en Nacos mediante APIs REST o integración nativa con Spring Cloud, Dubbo y gRPC. El mecanismo peer-finder permite que los nuevos nodos de Nacos se descubran automáticamente al escalar el StatefulSet, manteniendo la sincronización del estado del cluster sin intervención manual.

Similar a cómo ArgoCD Kubernetes automatiza los despliegues con GitOps, Nacos Kubernetes centraliza la configuración permitiendo actualizaciones en caliente sin necesidad de redeploy de pods. Esta característica es especialmente valiosa en entornos de producción donde el downtime no es una opción.

Paso 1: Preparar el Entorno Kubernetes

Antes de instalar Nacos Kubernetes, necesitas un cluster de Kubernetes funcional (versión 1.20 o superior recomendada) y kubectl configurado correctamente. Verifica que tienes acceso al cluster:

kubectl cluster-info
kubectl get nodes

Para despliegues en producción, necesitarás configurar almacenamiento persistente. Nacos requiere PersistentVolumeClaims para mantener los datos de configuración y el estado del cluster. Puedes usar NFS, Ceph, o los StorageClasses nativos de tu proveedor cloud (EBS en AWS, Persistent Disk en GCP, Azure Disk en Azure).

Clona el repositorio oficial de nacos-k8s que contiene todos los manifiestos YAML necesarios:

git clone https://github.com/nacos-group/nacos-k8s.git
cd nacos-k8s

Paso 2: Desplegar Nacos con Quick Start

Para entornos de desarrollo o pruebas, puedes usar el script de quick start que despliega Nacos en configuración standalone sin persistencia. Ten en cuenta que este método usa emptyDir, lo que significa que los datos se perderán si los pods se reinician:

chmod +x quick-startup.sh
./quick-startup.sh

Este script crea automáticamente el namespace, despliega los pods de Nacos y expone el servicio. Verifica que los pods estén corriendo:

kubectl get pods -l app=nacos
kubectl get svc nacos-cs

Accede a la consola web de Nacos mediante port-forward. El usuario y contraseña por defecto son ambos «nacos»:

kubectl port-forward svc/nacos-cs 8848:8848
# Accede a http://localhost:8848/nacos

Paso 3: Configurar Persistencia con NFS

Para entornos de producción, necesitas configurar almacenamiento persistente. El proyecto nacos-k8s incluye ejemplos con NFS. Primero, despliega el provisionador NFS:

kubectl create -f deploy/nfs/rbac.yaml
kubectl create -f deploy/nfs/deployment.yaml
kubectl create -f deploy/nfs/class.yaml

Luego despliega MySQL como base de datos backend para Nacos. El modo cluster requiere una base de datos externa para sincronizar el estado entre nodos:

kubectl create -f deploy/mysql/mysql-nfs.yaml

Espera a que el pod de MySQL esté listo antes de continuar. Puedes monitorearlo con herramientas como Prometheus Kubernetes para observabilidad completa del cluster.

kubectl get pods -l app=mysql
kubectl logs -f -l app=mysql

Paso 4: Desplegar Cluster Nacos con StatefulSets

Edita el archivo deploy/nacos/nacos-pvc-nfs.yaml para configurar la conexión a MySQL. Los parámetros críticos son:

env:
- name: SPRING_DATASOURCE_PLATFORM
  value: "mysql"
- name: MYSQL_SERVICE_HOST
  value: "mysql-service"
- name: MYSQL_SERVICE_PORT
  value: "3306"
- name: MYSQL_SERVICE_DB_NAME
  value: "nacos_devtest"
- name: MYSQL_SERVICE_USER
  value: "nacos"
- name: MYSQL_SERVICE_PASSWORD
  value: "nacos"
- name: NACOS_REPLICAS
  value: "3"
- name: PREFER_HOST_MODE
  value: "hostname"

El parámetro NACOS_REPLICAS debe coincidir con el número de réplicas del StatefulSet. PREFER_HOST_MODE en «hostname» permite que los nodos se identifiquen por nombre DNS estable, esencial para la formación del cluster.

Despliega el cluster de Nacos:

kubectl create -f deploy/nacos/nacos-pvc-nfs.yaml

Verifica que los tres pods se inicien correctamente y formen el cluster. Esto puede tomar varios minutos:

kubectl get statefulset nacos
kubectl get pods -l app=nacos
kubectl logs nacos-0 | grep "Nacos started"

Paso 5: Instalar Nacos Kubernetes con Helm

Helm ofrece una forma más declarativa y mantenible de gestionar despliegues de Nacos Kubernetes. El repositorio nacos-k8s incluye Helm charts oficiales. Primero, agrega el repositorio:

helm repo add nacos https://nacos-group.github.io/nacos-k8s/
helm repo update

Crea un archivo values.yaml personalizado para tu despliegue:

replicaCount: 3

nacos:
  storage:
    type: mysql
    db:
      host: mysql-service
      port: 3306
      name: nacos_devtest
      username: nacos
      password: nacos

persistence:
  enabled: true
  storageClass: "nfs-client"
  size: 10Gi

service:
  type: ClusterIP
  port: 8848

Instala Nacos usando Helm:

helm install nacos nacos/nacos -f values.yaml -n nacos --create-namespace

Helm gestiona automáticamente las actualizaciones y rollbacks. Para actualizar la configuración:

helm upgrade nacos nacos/nacos -f values.yaml -n nacos

Paso 6: Usar Nacos Operator para Gestión Avanzada

El Nacos Operator es el método recomendado para gestión avanzada de Nacos Kubernetes. Permite definir clusters de Nacos mediante Custom Resources (CRDs), simplificando operaciones como escalado, actualización y backup.

Instala el Nacos Operator en tu cluster:

kubectl apply -f https://raw.githubusercontent.com/nacos-group/nacos-k8s/master/operator/deploy/crds.yaml
kubectl apply -f https://raw.githubusercontent.com/nacos-group/nacos-k8s/master/operator/deploy/operator.yaml

Crea un Custom Resource para definir tu cluster de Nacos:

apiVersion: nacos.io/v1alpha1
kind: Nacos
metadata:
  name: nacos-cluster
spec:
  type: cluster
  replicas: 3
  database:
    type: mysql
    mysqlHost: mysql-service
    mysqlDb: nacos_devtest
    mysqlUser: nacos
    mysqlPassword: nacos
  storage:
    storageClass: nfs-client
    requests:
      storage: 10Gi

Aplica el CR y el Operator gestionará todo el ciclo de vida:

kubectl apply -f nacos-cluster.yaml
kubectl get nacos nacos-cluster -o yaml

El Operator facilita el escalado declarativo, similar a cómo Crossplane Kubernetes gestiona infraestructura multi-cloud mediante CRDs. Para escalar el cluster, simplemente actualiza el campo replicas:

kubectl patch nacos nacos-cluster --type='json' -p='[{"op": "replace", "path": "/spec/replicas", "value":5}]'

Paso 7: Integrar Aplicaciones con Nacos Kubernetes

Con Nacos desplegado, puedes integrar tus microservicios. Para aplicaciones Spring Cloud, agrega la dependencia de Nacos Discovery:

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2023.0.1.0</version>
</dependency>

Configura la conexión a Nacos en application.yaml:

spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: nacos-cs.nacos.svc.cluster.local:8848
        namespace: production
        group: microservices

Para configuración dinámica, usa Nacos Config. Los cambios en la configuración se propagan automáticamente sin reiniciar los pods:

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>2023.0.1.0</version>
</dependency>

En bootstrap.yaml:

spring:
  cloud:
    nacos:
      config:
        server-addr: nacos-cs.nacos.svc.cluster.local:8848
        file-extension: yaml
        namespace: production
        group: microservices

Para gestión segura de secretos y configuración sensible, combina Nacos con External Secrets Operator Kubernetes, que sincroniza secretos desde HashiCorp Vault o AWS Secrets Manager directamente a Kubernetes Secrets que tus aplicaciones pueden consumir.

Monitoreo y Observabilidad

Nacos expone métricas en formato Prometheus en el endpoint /nacos/actuator/prometheus. Configura ServiceMonitor para que Prometheus las recolecte:

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: nacos-metrics
spec:
  selector:
    matchLabels:
      app: nacos
  endpoints:
  - port: http
    path: /nacos/actuator/prometheus
    interval: 30s

Métricas clave a monitorear incluyen nacos_monitor{module=»naming»} para service discovery, nacos_monitor{module=»config»} para configuración, y nacos_exception_total para errores. Configura alertas para detectar problemas antes de que afecten a producción.

Para networking avanzado y observabilidad de tráfico entre microservicios, considera integrar Cilium Kubernetes, que proporciona políticas de red basadas en eBPF y visibilidad profunda de las comunicaciones L3-L7.

Seguridad en Nacos Kubernetes

En producción, habilita autenticación y autorización en Nacos. Edita la configuración para requerir autenticación:

nacos.core.auth.enabled=true
nacos.core.auth.plugin.nacos.token.secret.key=YOUR_SECRET_KEY_HERE

Crea usuarios con roles específicos desde la consola web. Usa NetworkPolicies para restringir el acceso a los pods de Nacos solo desde namespaces autorizados:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: nacos-access
  namespace: nacos
spec:
  podSelector:
    matchLabels:
      app: nacos
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          access-nacos: "true"
    ports:
    - protocol: TCP
      port: 8848

Habilita TLS para cifrar las comunicaciones entre los microservicios y Nacos. Genera certificados con cert-manager y configura Nacos para usar HTTPS:

server.ssl.enabled=true
server.ssl.key-store=/path/to/keystore.p12
server.ssl.key-store-password=password
server.ssl.key-store-type=PKCS12

Casos de Uso Reales de Nacos Kubernetes

Alibaba, el creador de Nacos, lo utiliza en producción gestionando decenas de miles de microservicios durante eventos como el Singles’ Day, procesando millones de configuraciones dinámicas por segundo. El ICBC (Industrial and Commercial Bank of China) migró su arquitectura de microservicios a Nacos Kubernetes, reduciendo el tiempo de despliegue de nuevas versiones de 2 horas a 15 minutos mediante configuración dinámica.

Huya, plataforma de streaming de video, usa Nacos para gestionar service discovery de más de 5.000 servicios en múltiples regiones, con health checks automáticos que detectan y eliminan instancias fallidas en menos de 5 segundos, garantizando alta disponibilidad del servicio.

En e-commerce, se utiliza Nacos para feature flags y configuración dinámica de precios durante campañas, permitiendo ajustar parámetros en tiempo real sin redeploys. Combinado con herramientas de CI/CD como ArgoCD, logran despliegues blue-green completamente automatizados.

Comparación: Nacos vs Consul vs Eureka

Nacos Kubernetes se diferencia de Consul y Eureka en varios aspectos. Mientras Consul es excelente para service mesh y KV store, Nacos ofrece mejor integración con el ecosistema Spring Cloud y Alibaba Cloud. Eureka, aunque popular en Netflix OSS, está en mantenimiento y carece de desarrollo activo desde 2020.

En términos de configuración dinámica, Nacos supera a ambos con su consola web intuitiva y APIs REST completas para gestión programática. Consul requiere Vault para gestión de secretos, mientras que Nacos integra configuración sensible nativamente con cifrado.

Para clusters grandes (+1000 servicios), Nacos demuestra mejor rendimiento y menor latencia en health checks comparado con Eureka. La arquitectura CP de Nacos (Consistency-Partition tolerance usando Raft) garantiza consistencia fuerte del registro de servicios, crítico en fintech y sistemas transaccionales.

Troubleshooting Común

Si los pods de Nacos no forman cluster, verifica que NACOS_REPLICAS coincida con el número de réplicas del StatefulSet y que PREFER_HOST_MODE esté configurado. Revisa logs para errores de conexión a MySQL:

kubectl logs nacos-0 | grep -i "database"
kubectl describe pod nacos-0

Para problemas de persistencia, verifica que los PVCs estén bound y que el StorageClass esté configurado correctamente:

kubectl get pvc -n nacos
kubectl get storageclass

Si los microservicios no se registran, verifica conectividad de red desde los pods de aplicación a los pods de Nacos y confirma que el Service DNS resuelve correctamente:

kubectl run -it --rm debug --image=busybox --restart=Never -- nslookup nacos-cs.nacos.svc.cluster.local
kubectl run -it --rm debug --image=curlimages/curl --restart=Never -- curl http://nacos-cs.nacos.svc.cluster.local:8848/nacos/v1/console/health/readiness

Preguntas Frecuentes (FAQ)

¿Cuál es la diferencia entre Nacos Kubernetes y Consul?

Nacos Kubernetes se integra nativamente con Spring Cloud y Dubbo, ofrece configuración dinámica más potente mediante su consola web, y tiene mejor rendimiento en clusters grandes con arquitectura CP usando Raft. Consul es más orientado a service mesh con Envoy, mientras que Nacos se enfoca en service discovery y configuración para microservicios Java/Spring.

¿Puedo usar Nacos Kubernetes sin MySQL?

Sí, Nacos soporta modo standalone con base de datos embebida Derby para desarrollo y testing. Sin embargo, para producción y modo cluster, se requiere MySQL o PostgreSQL externo para sincronizar el estado entre nodos y garantizar alta disponibilidad.

¿Cómo escalo horizontalmente Nacos en Kubernetes?

Usa kubectl scale para aumentar las réplicas del StatefulSet. El mecanismo peer-finder de Nacos detecta automáticamente los nuevos nodos y los agrega al cluster sin intervención manual. Asegúrate de actualizar la variable NACOS_REPLICAS para que coincida con el nuevo número de réplicas.

¿Nacos Kubernetes soporta multi-tenancy?

Sí, Nacos implementa multi-tenancy mediante namespaces lógicos. Puedes crear namespaces diferentes para dev, staging y production, aislando completamente las configuraciones y el registro de servicios entre entornos. Cada namespace tiene su propio conjunto de permisos y políticas de acceso.

¿Qué requisitos de recursos tiene Nacos en Kubernetes?

Para producción, se recomienda mínimo 2 CPU cores y 4GB RAM por pod de Nacos. Para clusters que gestionan más de 1000 servicios, considera 4 CPU cores y 8GB RAM. El almacenamiento depende del número de configuraciones, pero 10GB por nodo es un buen punto de partida.

Conclusión

Nacos Kubernetes representa la evolución natural de la gestión de microservicios en entornos cloud-native, combinando service discovery, health checking, configuración dinámica y DNS en una única plataforma robusta y escalable. Con más de 32.500 estrellas en GitHub y adopción por gigantes tecnológicos como Alibaba, ICBC y Huya, Nacos Kubernetes ha demostrado su capacidad para gestionar arquitecturas de miles de microservicios en producción.

La integración nativa con Kubernetes mediante StatefulSets, Helm charts y el Nacos Operator simplifica enormemente el despliegue y la gestión operativa. Las capacidades de configuración dinámica sin redeploys, health checks automáticos en menos de 5 segundos, y el soporte para namespaces multi-tenant lo convierten en una opción superior frente a alternativas como Consul o Eureka para ecosistemas Spring Cloud y Dubbo.

En 2026, con el lanzamiento del programa Certified Kubernetes AI Conformance de CNCF y la creciente adopción de arquitecturas de microservicios AI-native, herramientas como Nacos Kubernetes se vuelven esenciales para gestionar la complejidad de servicios inteligentes distribuidos. Su capacidad para manejar configuración dinámica y service discovery a escala lo posiciona como componente fundamental en stacks modernos de DevOps y platform engineering.

¿Listo para implementar Nacos Kubernetes en tu infraestructura? Comienza con el modo quick start para experimentar, evoluciona a despliegues con Helm para gestión declarativa, y finalmente adopta el Nacos Operator para operaciones avanzadas en producción. La comunidad activa y la documentación completa en nacos.io te acompañarán en cada paso del camino.