Talos OS — Sistema Operativo 100% Kubernetes¶

Tipo: Investigación técnica Audiencia: Equipo de infraestructura y DevOps Fecha: 20 marzo 2026

1. ¿Qué es Talos OS?¶

Talos Linux es una distribución Linux open source, mínima e inmutable, diseñada exclusivamente para ejecutar Kubernetes. Desarrollada por Sidero Labs, elimina todo lo que no sea estrictamente necesario para correr kubelet y componentes de Kubernetes.

Características fundamentales¶

Aspecto	Detalle
Licencia	Open Source (MPL 2.0)
Kernel	Linux hardened
Userland	Escrito en Go
Tamaño imagen	~80 MB
Binarios únicos	~12 (vs >2300 en Flatcar)
Contenedor runtime	containerd (OCI compliant)
Arquitecturas	amd64 (x86_64) y arm64 (aarch64)
Gestión	100% API (gRPC) vía `talosctl`

Principios de diseño¶

graph LR
    A["Inmutable"] --> B["SquashFS read-only"]
    C["Sin SSH"] --> D["API-only via talosctl"]
    E["Mínimo"] --> F["Solo kubelet + containerd"]
    G["Declarativo"] --> H["Config YAML reproducible"]
    I["Atómico"] --> J["Upgrades A/B con rollback"]

[!IMPORTANT] Talos NO tiene SSH, ni shell, ni gestor de paquetes. Todo se gestiona mediante la API con talosctl. Esto reduce drásticamente la superficie de ataque.

2. Requisitos de memoria y recursos¶

2.1 Requisitos mínimos¶

Recurso	Control Plane	Worker
RAM	2 GB (ajustado)	1 GB
CPU	2 cores	1 core
Disco	10 GB	10 GB

2.2 Requisitos recomendados (producción)¶

Recurso	Control Plane	Worker
RAM	4-8 GB	4+ GB
CPU	4 cores	2+ cores
Disco	50-100 GB (SSD)	50-100 GB

2.3 Consumo base real (sin workloads)¶

Nodo	RAM base consumida
Control Plane	~800 MB – 1 GB (etcd + API server + controller + scheduler)
Worker	~300-400 MB (kubelet + containerd)

[!WARNING] Con 2 GB en un nodo control plane, apenas queda memoria para aplicaciones. El mínimo práctico para un nodo control plane con workloads es 4 GB.

2.4 Análisis para tu entorno¶

Máquina	Specs	¿Es viable?	Rol recomendado
Linux local	(verificar RAM)	✅ Sí, para desarrollo	Control plane + worker (single node)
MacBook 16 GB	16 GB RAM	✅ Excelente	Cluster Docker local o VM con múltiples nodos
Hetzner CX23	2 vCPU, 4 GB RAM	✅ Sí	Control plane básico o worker
Hetzner CAX11	2 vCPU ARM, 4 GB RAM	✅ Sí	Worker (ARM nativo)

3. ¿Se pueden crear imágenes Docker en local?¶

Respuesta corta: SÍ, absolutamente¶

Hay una distinción importante que hacer:

3.1 Imágenes Docker para TUS aplicaciones (las que correrán en Talos)¶

Talos ejecuta imágenes OCI estándar a través de containerd. Puedes construir tus imágenes Docker en cualquier máquina con Docker instalado:

# En tu Linux local o MacBook — workflow normal
docker build -t mi-app:v1 .
docker tag mi-app:v1 registry.ejemplo.com/mi-app:v1
docker push registry.ejemplo.com/mi-app:v1

# Talos (containerd) las descarga del registry y las ejecuta

Opciones de registry: - Docker Hub, GitHub Container Registry (GHCR), etc. - Registry local para desarrollo (sin depender de Internet):

# Levantar registry local en tu Linux
docker run -d -p 5000:5000 --restart always --name registry registry:2

# Pushear imágenes al registry local
docker tag mi-app:v1 localhost:5000/mi-app:v1
docker push localhost:5000/mi-app:v1

3.2 Imágenes del propio Talos OS (personalización del sistema)¶

Si necesitas personalizar Talos (extensiones de kernel, drivers, etc.):

# Clonar el repositorio de Talos
git clone https://github.com/siderolabs/talos.git
cd talos

# Construir componentes (requiere Docker, Go 1.21+, Make)
make kernel
make initramfs
make installer

# Pushear a registry
make installer PUSH=true IMAGE_REGISTRY=ghcr.io USERNAME=tu-usuario

Alternativa sin compilar: Usar el Image Factory de Sidero Labs: - Web: factory.talos.dev - Define extensiones en un YAML schematic y genera imágenes custom online

3.3 Herramienta `imager` (generar discos custom)¶

# Generar imagen de disco con extensiones custom
docker run --rm -v /dev:/dev --privileged \
  ghcr.io/siderolabs/imager:latest \
  --output-kind raw \
  --system-extension ghcr.io/siderolabs/iscsi-tools:latest

Formatos de salida: raw, qcow2, vmdk, vhd, ISO.

4. Desarrollo local: tu Linux + MacBook 16 GB¶

4.1 Opción A: Cluster Talos en Docker (más rápida)¶

La forma más rápida de tener un cluster Kubernetes con Talos en local:

# Instalar talosctl
curl -sL https://talos.dev/install | sh

# Crear cluster single-node en Docker
talosctl cluster create \
  --provisioner docker \
  --name dev \
  --controlplanes 1 \
  --workers 0

# Verificar
kubectl get nodes

[!TIP] Cada nodo Talos corre como un contenedor Docker que internamente ejecuta containerd, kubelet, apid, machined — comportamiento idéntico a producción.

Requisitos para esta opción: - Docker instalado en el Linux o MacBook - ~1.5-2 GB RAM por nodo - En el MacBook de 16 GB podrías correr hasta 4-6 nodos cómodamente

4.2 Opción B: Cluster Talos con QEMU (bare-metal simulado)¶

Para probar cosas de bajo nivel (módulos kernel, operaciones de disco):

talosctl cluster create \
  --provisioner qemu \
  --name qemu-lab \
  --controlplanes 1 \
  --workers 1

Requiere: qemu-system-x86_64 instalado + KVM habilitado.

4.3 Opción C: VM en VirtualBox/Parallels (MacBook)¶

# 1. Descargar ISO de Talos
wget https://github.com/siderolabs/talos/releases/latest/download/talos-amd64.iso

# 2. Crear VM en VirtualBox (≥2 GB RAM, 2 CPU, red bridged)
# 3. Bootear con la ISO — entra en modo mantenimiento
# 4. Obtener IP de la VM y generar configuración:
talosctl gen config dev-cluster https://<IP_VM>:6443

# 5. Aplicar configuración
talosctl apply-config --insecure \
  --nodes <IP_VM> \
  --file controlplane.yaml

# 6. Bootstrap
talosctl bootstrap --nodes <IP_VM>

# 7. Obtener kubeconfig
talosctl kubeconfig --nodes <IP_VM>

4.4 Escenario híbrido: Linux + MacBook en LAN¶

graph TB
    subgraph LAN["Red Local LAN"]
        L["Linux<br/>Registry local :5000<br/>Docker build"]
        M["MacBook 16GB<br/>Cluster Talos Docker<br/>o VM con Talos"]
        L <-->|"push/pull imágenes"| M
    end
    L -->|"docker build + push"| R["Registry Local<br/>localhost:5000"]
    M -->|"containerd pull"| R

Flujo de trabajo práctico:

Linux: Construyes imágenes Docker de tus aplicaciones
Linux: Las pusheas a un registry local (puerto 5000)
MacBook: Corres Talos en Docker con --controlplanes 1 --workers 1
MacBook: Talos descarga imágenes del registry en tu Linux via LAN
O viceversa — el cluster también puede correr en el Linux

[!NOTE] Para que el MacBook acceda al registry en el Linux, la configuración de Talos necesita apuntar al IP del Linux en la LAN (ej: 192.168.1.X:5000).

5. Despliegue en Hetzner Cloud¶

5.1 ¿Por qué Hetzner?¶

Ventaja	Detalle
Precio	El más barato de Europa para VPS con buen rendimiento
Lo que incluye	20 TB tráfico/mes gratis
Ubicación	Datacenters en Alemania y Finlandia (baja latencia para Europa)
ARM	Servidores Ampere Altra (CAX) muy económicos

5.2 Precios relevantes (marzo 2026)¶

Plan	vCPU	RAM	Disco	Precio/mes	Uso recomendado
CX23 (x86)	2	4 GB	40 GB NVMe	~€3.49	Control plane básico
CX33 (x86)	2	8 GB	80 GB NVMe	~€6.49	Control plane recomendado
CAX11 (ARM)	2	4 GB	40 GB NVMe	~€3.79	Workers ARM
CAX21 (ARM)	4	8 GB	80 GB NVMe	~€6.49	Workers con más capacidad
Load Balancer	—	—	—	~€5.39	Necesario para HA

[!TIP] A partir de abril 2026 hay subida de precios: CX23 sube a €3.99 y CAX11 a €4.49.

5.3 Estimaciones de coste para clusters Talos en Hetzner¶

Configuración	Composición	Coste estimado/mes
Mínima (dev/staging)	1× CX23 (CP) + LB	~€9
Básica	1× CX23 (CP) + 1× CX23 (worker) + LB	~€12
Producción ligera	1× CX33 (CP) + 2× CAX11 (workers) + LB	~€22
Producción HA	3× CX33 (CP) + 3× CAX21 (workers) + LB	~€58

5.4 Pasos para desplegar Talos en Hetzner¶

# 1. Instalar herramientas
brew install hcloud talosctl kubectl  # macOS
# o equivalente en Linux

# 2. Configurar hcloud CLI
hcloud context create mi-proyecto
# (introduce tu API token de Hetzner)

# 3. Subir imagen de Talos a Hetzner (no hay imagen nativa)
# Opción A: Modo Rescue
hcloud server create --name talos-imager --type cx23 --image ubuntu-24.04
hcloud server enable-rescue talos-imager
hcloud server reboot talos-imager
# SSH al servidor en rescue y:
# wget <URL_imagen_talos_raw.xz>
# xz -d talos-amd64.raw.xz
# dd if=talos-amd64.raw of=/dev/sda bs=4M
# Apagar y crear snapshot

# Opción B: Con Packer (automatizado)
packer build talos-hetzner.pkr.hcl

# Opción C: Con Terraform provider (terraform-provider-imager)

# 4. Crear red privada
hcloud network create --name k8s-net --ip-range 10.0.0.0/16
hcloud network add-subnet k8s-net --type cloud --network-zone eu-central --ip-range 10.0.1.0/24

# 5. Crear load balancer
hcloud load-balancer create --name talos-lb --type lb11 --network-zone eu-central

# 6. Generar configuración de Talos
talosctl gen config mi-cluster https://<LB_IP>:6443

# 7. Crear nodos con la snapshot de Talos
hcloud server create --name cp-1 --type cx33 \
  --image <snapshot-id> --network k8s-net

# 8. Aplicar configuración y bootstrap
talosctl apply-config --insecure --nodes <CP_IP> --file controlplane.yaml
talosctl bootstrap --nodes <CP_IP>

# 9. Instalar CNI y Hetzner Cloud Controller
kubectl apply -f cilium.yaml
kubectl apply -f hcloud-controller-manager.yaml

6. Seguridad: comparación¶

Aspecto	Talos OS	Ubuntu/Debian	k3s (sobre Linux)	Flatcar
SSH	❌ No existe	✅ Disponible	✅ Disponible	✅ Disponible
Shell	❌ No existe	✅ Disponible	✅ Disponible	✅ Disponible
Gestor paquetes	❌ No existe	✅ apt/yum	✅ apt/yum	❌ No existe
Filesystem	🔒 Read-only (SquashFS)	🔓 Read-write	🔓 Read-write	🔒 `/usr` read-only
CVEs no parcheados	Mínimos (~12 binarios)	Muchos	Depende del host	Medio (~2300 binarios)
Upgrades	Atómico A/B	Manual/desatendido	Manual	Atómico A/B
Config drift	Imposible	Posible	Posible	Parcialmente posible
Gestión	API declarativa	SSH + scripts	SSH + kubectl	SSH + Ignition

7. Talos vs alternativas¶

7.1 Talos OS vs k3s¶

Criterio	Talos OS	k3s
Qué es	Sistema operativo para Kubernetes	Distribución ligera de Kubernetes
Corre sobre	Metal/VM directamente	Cualquier Linux
RAM mínima (cluster)	~2 GB (CP)	~512 MB
Seguridad	Extrema (sin SSH, inmutable)	Depende del host OS
Curva aprendizaje	Alta (paradigma nuevo)	Baja (familiar)
Ideal para	Producción segura, compliance	Edge, IoT, homelabs
Se complementan	Sí — k3s puede correr sobre Flatcar, Talos es el OS completo

7.2 Talos OS vs Flatcar Container Linux¶

Criterio	Talos OS	Flatcar
SSH	No	Sí
Inmutabilidad	Total (SquashFS)	Parcial (`/usr` read-only)
K8s integrado	Sí	No (instalar aparte)
Binarios	~12	~2300+
Gestión	API gRPC	SSH + Ignition/Afterburn
CNCF	No (Sidero Labs)	Sí (incubating, 2024)

8. Conclusiones y recomendaciones¶

✅ ¿Para el proyecto IEO es viable?¶

Pregunta	Respuesta
¿Puedo crear imágenes Docker en mi Linux?	Sí, con `docker build` normal. Talos consume OCI estándar.
¿Puedo usar mi MacBook de 16 GB?	Sí, perfecto para cluster local Docker con 4+ nodos Talos.
¿Puedo provisionar en Hetzner barato?	Sí, desde ~€9/mes (dev) hasta ~€22/mes (producción ligera).
¿Los requisitos de memoria son altos?	No, 4 GB por nodo es suficiente para empezar.

🎯 Recomendación de arquitectura de desarrollo¶

graph TB
    subgraph DEV["Desarrollo Local"]
        L["Linux local<br/>docker build<br/>registry :5000"]
        MB["MacBook 16GB<br/>talosctl cluster create<br/>--provisioner docker"]
    end

    subgraph HETZNER["Hetzner Cloud ~€22/mes"]
        CP["CX33 Control Plane<br/>8 GB RAM"]
        W1["CAX11 Worker 1<br/>4 GB ARM"]
        W2["CAX11 Worker 2<br/>4 GB ARM"]
        LB["Load Balancer"]
        LB --> CP
        CP --> W1
        CP --> W2
    end

    L -->|"Push imágenes"| GHCR["GitHub Container Registry"]
    GHCR -->|"Pull imágenes"| HETZNER
    L <-->|LAN| MB

📋 Pasos siguientes recomendados¶

Instalar talosctl en el Linux local
Probar un cluster Docker con talosctl cluster create --provisioner docker
Desplegar una app de prueba (nginx o similar)
Evaluar Hetzner con un CX23 para un nodo single de staging (~€3.49/mes)
Escalar cuando se necesite producción

Documentos relacionados¶

Nivel	Documento	Descripción
Infraestructura	Arquitectura del sistema	Arquitectura general del proyecto
Investigación	Análisis tecnológico	Stack técnico evaluado