K3s: La Distribución Ligera de Kubernetes para Edge, IoT y Desarrollo

Actualizado: July 2026 • 10 min de lectura

Kubernetes se ha consolidado como el estándar para la orquestación de contenedores, pero su instalación completa puede resultar excesiva para muchos escenarios: nodos Edge con recursos limitados, dispositivos IoT, entornos de desarrollo local o clústeres pequeños de producción. K3s nació precisamente para resolver este problema: es una distribución certificada de Kubernetes que empaqueta todo lo necesario en un único binario de menos de 100 MB.

Desarrollado originalmente por Rancher Labs (ahora parte de SUSE), K3s es un proyecto graduado de la CNCF que ofrece compatibilidad total con la API de Kubernetes, pero con una huella de recursos drásticamente reducida.

¿Qué hace diferente a K3s?

K3s no es un “mini Kubernetes” ni una versión recortada. Es una distribución certificada y conforme al 100% con la API de Kubernetes, lo que significa que cualquier manifiesto, Helm chart o herramienta que funcione en un clúster estándar funcionará en K3s sin cambios.

Las principales diferencias respecto a una instalación estándar de Kubernetes son:

Característica	Kubernetes estándar	K3s
Binarios	Múltiples componentes (kubelet, kube-apiserver, etcd, etc.)	Un solo binario (`k3s`)
Almacenamiento de estado	etcd (requiere clúster separado)	SQLite por defecto (soporta etcd, MySQL, PostgreSQL)
Requisitos de RAM	~2 GB mínimo por nodo	~512 MB por nodo
Componentes integrados	Requiere instalación separada de CNI, ingress, etc.	Flannel (CNI), Traefik (Ingress), CoreDNS, ServiceLB incluidos
Certificados TLS	Configuración manual o con herramientas externas	Autogeneración y rotación automática
Tamaño del binario	Varios GB con dependencias	< 100 MB

Arquitectura de K3s

K3s simplifica drásticamente la arquitectura de Kubernetes consolidando los componentes del plano de control en un único proceso:

┌─────────────────────────────────────────────────────────┐
│                    Nodo Server (Master)                  │
│                                                          │
│  ┌────────────────────────────────────────────────────┐  │
│  │              Proceso k3s server                     │  │
│  │  ┌──────────┐ ┌────────────┐ ┌──────────────────┐  │  │
│  │  │ API      │ │ Controller │ │ Scheduler         │  │  │
│  │  │ Server   │ │ Manager    │ │                    │  │  │
│  │  └──────────┘ └────────────┘ └──────────────────┘  │  │
│  │  ┌──────────┐ ┌────────────┐ ┌──────────────────┐  │  │
│  │  │ Kubelet  │ │ Kube-proxy │ │ Flannel (CNI)    │  │  │
│  │  └──────────┘ └────────────┘ └──────────────────┘  │  │
│  └────────────────────────────────────────────────────┘  │
│  ┌──────────────────┐  ┌───────────────────────────┐     │
│  │ SQLite / etcd /   │  │ Traefik Ingress           │     │
│  │ MySQL / PostgreSQL│  │ Controller                │     │
│  └──────────────────┘  └───────────────────────────┘     │
└─────────────────────────────────────────────────────────┘
                            │
              ┌─────────────┼─────────────┐
              ▼             ▼             ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│  Nodo Agent 1    │ │  Nodo Agent 2    │ │  Nodo Agent N    │
│  ┌────────────┐  │ │  ┌────────────┐  │ │  ┌────────────┐  │
│  │ k3s agent  │  │ │  │ k3s agent  │  │ │  │ k3s agent  │  │
│  │ (kubelet + │  │ │  │ (kubelet + │  │ │  │ (kubelet + │  │
│  │ kube-proxy)│  │ │  │ kube-proxy)│  │ │  │ kube-proxy)│  │
│  └────────────┘  │ │  └────────────┘  │ │  └────────────┘  │
└──────────────────┘ └──────────────────┘ └──────────────────┘

Server (Master): Ejecuta el plano de control completo más un agente integrado. Puede actuar como nodo worker simultáneamente.
Agent (Worker): Solo ejecuta kubelet y kube-proxy. Se conecta al server mediante un token compartido.

Instalación en 30 segundos

Una de las grandes ventajas de K3s es la velocidad de instalación. Un clúster funcional se levanta con un solo comando.

Instalar el nodo Server

curl -sfL https://get.k3s.io | sh -

Este script descarga el binario, lo instala como servicio systemd, genera los certificados TLS, configura kubectl y arranca todos los componentes. En menos de 30 segundos tendrás un clúster operativo.

Verifica la instalación:

sudo k3s kubectl get nodes
# NAME          STATUS   ROLES                  AGE   VERSION
# mi-servidor   Ready    control-plane,master   30s   v1.31.4+k3s1

El fichero kubeconfig se genera automáticamente en /etc/rancher/k3s/k3s.yaml. Para usar kubectl sin sudo:

mkdir -p ~/.kube
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
sudo chown $(id -u):$(id -g) ~/.kube/config
export KUBECONFIG=~/.kube/config

Añadir nodos Agent (Workers)

Primero, obtén el token del server:

sudo cat /var/lib/rancher/k3s/server/node-token
# K10xxxxxxxxxxxxxxxxxxxxxxxxxxxxx::server:xxxxxxxxxxxxxxxx

En cada nodo worker, ejecuta:

curl -sfL https://get.k3s.io | K3S_URL=https://IP_DEL_SERVER:6443 K3S_TOKEN=TOKEN_AQUI sh -

Verifica desde el server que los nodos se han unido:

sudo k3s kubectl get nodes
# NAME          STATUS   ROLES                  AGE   VERSION
# mi-servidor   Ready    control-plane,master   10m   v1.31.4+k3s1
# worker-01     Ready    <none>                 30s   v1.31.4+k3s1
# worker-02     Ready    <none>                 25s   v1.31.4+k3s1

Opciones de instalación avanzada

K3s permite personalizar la instalación mediante variables de entorno y flags del binario.

Desactivar componentes integrados

Si prefieres usar tu propio CNI (como Calico o Cilium), tu propio ingress controller (como NGINX) o no necesitas el balanceador de carga integrado:

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server \
  --disable traefik \
  --disable servicelb \
  --flannel-backend=none" sh -

Usar una base de datos externa (Alta Disponibilidad)

Para entornos de producción que requieren alta disponibilidad, puedes usar una base de datos externa en lugar de SQLite:

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server \
  --datastore-endpoint='postgres://usuario:password@db.ejemplo.com:5432/k3s'" sh -

K3s soporta PostgreSQL, MySQL y etcd como backends de datos para HA.

Clúster HA con etcd embebido

Desde la versión v1.19, K3s soporta etcd embebido para alta disponibilidad sin dependencias externas:

# Primer nodo server (inicializa el clúster)
curl -sfL https://get.k3s.io | K3S_TOKEN=MI_TOKEN_SEGURO \
  INSTALL_K3S_EXEC="server --cluster-init" sh -

# Segundo y tercer nodo server (se unen al clúster)
curl -sfL https://get.k3s.io | K3S_TOKEN=MI_TOKEN_SEGURO \
  K3S_URL=https://IP_PRIMER_SERVER:6443 \
  INSTALL_K3S_EXEC="server" sh -

Desplegar una aplicación de ejemplo

Con K3s ya funcionando, desplegar aplicaciones es idéntico a cualquier clúster Kubernetes estándar:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-ejemplo
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-ejemplo
  template:
    metadata:
      labels:
        app: nginx-ejemplo
    spec:
      containers:
        - name: nginx
          image: nginx:alpine
          ports:
            - containerPort: 80
          resources:
            requests:
              memory: "64Mi"
              cpu: "100m"
            limits:
              memory: "128Mi"
              cpu: "250m"
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-ejemplo
  namespace: default
spec:
  type: LoadBalancer
  selector:
    app: nginx-ejemplo
  ports:
    - port: 80
      targetPort: 80

Gracias al ServiceLB integrado en K3s (antes conocido como Klipper), el Service de tipo LoadBalancer funciona incluso en servidores bare-metal sin necesidad de un cloud provider o MetalLB.

Helm en K3s

K3s incluye un controlador de Helm que permite desplegar charts sin tener la CLI de Helm instalada, usando un CRD nativo llamado HelmChart:

apiVersion: helm.cattle.io/v1
kind: HelmChart
metadata:
  name: prometheus
  namespace: kube-system
spec:
  repo: https://prometheus-community.github.io/helm-charts
  chart: kube-prometheus-stack
  targetNamespace: monitoring
  createNamespace: true
  valuesContent: |-
    grafana:
      adminPassword: "mi-password-seguro"
    prometheus:
      prometheusSpec:
        retention: 7d
        resources:
          requests:
            memory: 512Mi

Este enfoque es especialmente útil para automatizar la configuración inicial del clúster: basta con colocar los ficheros YAML en /var/lib/rancher/k3s/server/manifests/ y K3s los aplicará automáticamente al arrancar.

Casos de uso ideales para K3s

Edge Computing y ubicaciones remotas

K3s brilla en escenarios Edge donde los recursos son limitados y la conectividad puede ser intermitente:

Tiendas retail: Cada tienda ejecuta un nodo K3s local que procesa pagos y gestiona inventario, sincronizando con la nube cuando hay conexión.
Estaciones base de telecomunicaciones: Procesan datos en el borde de la red con latencia mínima.
Plataformas industriales: Fábricas y plantas de producción que necesitan procesamiento local de datos IoT.

Desarrollo local

K3s es una alternativa excelente a Minikube o Kind para desarrollo local:

# Levantar un clúster de desarrollo en segundos
curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server \
  --write-kubeconfig-mode 644 \
  --disable traefik" sh -

IoT y dispositivos ARM

K3s tiene soporte nativo para arquitecturas ARM (ARMv7 y ARM64), lo que lo hace perfecto para:

Raspberry Pi: Ideal para clústeres de laboratorio o proyectos de home automation.
NVIDIA Jetson: Machine Learning en el Edge con orquestación Kubernetes.
Dispositivos embebidos: Cualquier dispositivo ARM con Linux puede ejecutar K3s.

CI/CD efímeros

Crear clústeres Kubernetes desechables para pipelines de CI/CD:

# En tu pipeline de CI
curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server --disable traefik" sh -
export KUBECONFIG=/etc/rancher/k3s/k3s.yaml

# Ejecutar tests de integración contra el clúster
kubectl apply -f manifests/
./run-integration-tests.sh

# El clúster se destruye al finalizar el pipeline

K3s vs alternativas ligeras

Característica	K3s	Minikube	Kind	MicroK8s
Enfoque principal	Producción ligera, Edge	Desarrollo local	CI/CD, testing	Desarrollo y Edge
Multi-nodo	✅ Nativo	⚠️ Experimental	✅ Docker containers	✅ Con clustering
Alta disponibilidad	✅ etcd embebido	❌	❌	✅
ARM nativo	✅	⚠️ Limitado	⚠️ Limitado	✅
Producción ready	✅	❌	❌	✅
Apto para Edge/IoT	✅	❌	❌	⚠️
Requiere Docker	❌ (usa containerd)	✅	✅	❌ (usa containerd)
CNCF	✅ Graduado	✅	✅	❌ (Canonical)

Buenas prácticas para producción con K3s

Usa etcd embebido para HA: Despliega al menos 3 nodos server con --cluster-init para tolerancia a fallos sin dependencias externas.
Configura copias de seguridad automáticas: K3s incluye snapshots automáticos de etcd. Verifica que están habilitados:
```
k3s etcd-snapshot list
```
Limita los recursos del plano de control: En nodos con recursos limitados, usa --kube-apiserver-arg para configurar límites:
```
k3s server --kube-apiserver-arg="max-requests-inflight=100"
```
Monitoriza con Prometheus: Usa el HelmChart CRD para desplegar el stack de monitorización de forma declarativa.
Actualiza de forma controlada: K3s se puede actualizar con el system-upgrade-controller, que permite actualizaciones automatizadas y progresivas:
```
kubectl apply -f https://github.com/rancher/system-upgrade-controller/releases/latest/download/system-upgrade-controller.yaml
```
Asegura el acceso al API Server: Usa firewalls para restringir el puerto 6443 y configura RBAC adecuado.

Desinstalación limpia

K3s incluye scripts de desinstalación que eliminan todos los componentes, reglas de red y datos:

# En nodos Server
/usr/local/bin/k3s-uninstall.sh

# En nodos Agent
/usr/local/bin/k3s-agent-uninstall.sh

Conclusión

K3s ha democratizado el acceso a Kubernetes al eliminar la barrera de entrada que suponía la complejidad de instalación y los requisitos de recursos. Con un binario de menos de 100 MB, instalación en 30 segundos y compatibilidad total con el ecosistema Kubernetes, K3s es la opción ideal para escenarios donde un clúster completo de Kubernetes resulta excesivo.

Ya sea para un clúster de producción en el Edge, desarrollo local en una Raspberry Pi, o entornos efímeros de CI/CD, K3s ofrece el mismo poder de Kubernetes con una fracción de la complejidad. Su graduación como proyecto CNCF confirma su madurez y respaldo por la comunidad, convirtiéndolo en una apuesta segura para cualquier equipo que necesite orquestación de contenedores ligera pero profesional.