Despliega un Clúster de Kubernetes Gestionado en CubePath

Kubernetes Gestionado te da un clúster de Kubernetes real sin tener que llevar tú la parte difícil. CubePath gestiona el control plane (el API server y todo lo que mantiene sano el clúster), y tus workers corren en VPS de CubePath que tú dimensionas y escalas. Recibes un kubeconfig, apuntas kubectl a él, y despliegas.

Es la forma de correr contenedores en producción: aplicaciones web, APIs, procesos en segundo plano, y todo lo que de otro modo montarías a mano sobre un montón de servidores.

Cómo funciona

Creas un clúster en un proyecto y una ubicación, eligiendo una versión de Kubernetes y uno o más node pools. Un node pool es un grupo de servidores worker idénticos (mismo plan); CubePath los aprovisiona como VPS, los une al clúster, y mantiene el control plane gestionado por delante. Los workers pueden tener IPs públicas o estar en una red privada, y los pods y servicios tienen sus propias redes internas. Cuando el clúster está listo descargas su kubeconfig y lo usas con kubectl o cualquier herramienta de Kubernetes, igual que cualquier otro clúster. Gestionas el clúster, sus node pools y los add-ons desde el panel o la API.

Antes de empezar

• En el panel: my.cubepath.com → Kubernetes.
• Por la API: URL base https://api.cubepath.com, autentica con Authorization: Bearer <token> (scopes kubernetes:read / kubernetes:write) y añade X-Requested-With: XMLHttpRequest en las escrituras. Consigue un token en Cuenta → Tokens de API.
• Tu organización debe estar verificada, sin suspensión y con saldo positivo. Cada worker es un VPS del plan que elijas y se factura como cualquier VPS.
• Ten kubectl instalado en local para hablar con el clúster una vez levantado.

Crear un clúster

Lista primero las versiones disponibles (GET /kubernetes/versions) y los planes de worker (GET /kubernetes/plans), y luego crea el clúster con al menos un node pool:

curl -X POST https://api.cubepath.com/kubernetes/ \
  -H "Authorization: Bearer $CUBEPATH_TOKEN" \
  -H "X-Requested-With: XMLHttpRequest" \
  -H "Content-Type: application/json" \
  -d '{
    "project_id": 1,
    "name": "prod",
    "location_name": "us-mia-1",
    "version": "v1.30",
    "ha_control_plane": true,
    "node_pools": [
      { "name": "default", "plan": "ck2-2-4", "count": 3, "auto_scale": true }
    ]
  }'

Las opciones:

• version: déjala fuera para usar la versión por defecto actual.
• ha_control_plane: un control plane redundante y de alta disponibilidad. Recomendado para producción; déjalo en false para dev/test.
• allocate_ipv4 / allocate_ipv6: da IPs públicas a los workers (ambas por defecto true). Si desactivas la IPv6 pública, el clúster necesita una red privada (abajo).
• network: opcional. Conéctalo a una red privada existente con network_id, o haz que se cree una pasando un node_cidr. Los pods y servicios usan sus propios rangos (pod_cidr por defecto 10.42.0.0/16, service_cidr por defecto 10.43.0.0/16); no deben solaparse.
• node_pools: de uno a diez pools, cada uno con un plan y un count de nodos (de 1 a 100).

El clúster se aprovisiona en segundo plano. Sigue su estado con GET /kubernetes/{uuid}.

Node pools

Un node pool es un conjunto de workers que comparten plan y ajustes de planificación. Dividir los workers en pools te permite mezclar tamaños (por ejemplo un pool general pequeño más un pool grande de memoria) y dirigir cargas con labels y taints.

• Crear un pool: POST /kubernetes/{cluster_uuid}/node-pools.
• Escalar o reajustar: PATCH /kubernetes/{cluster_uuid}/node-pools/{pool_uuid} para cambiar desired_nodes, activar o desactivar auto_scale, fijar min_nodes / max_nodes, o actualizar labels y taints. Con el autoescalado activo, el pool crece y se reduce entre el mínimo y el máximo según la demanda.
• Añadir o quitar workers individuales: POST .../node-pools/{pool_uuid}/nodes y DELETE .../node-pools/{pool_uuid}/nodes/{vps_id}.
• Eliminar un pool: DELETE /kubernetes/{cluster_uuid}/node-pools/{pool_uuid}.

Conectar con kubectl

Descarga el kubeconfig del clúster y apunta kubectl a él:

curl https://api.cubepath.com/kubernetes/<cluster_uuid>/kubeconfig \
  -H "Authorization: Bearer $CUBEPATH_TOKEN" -o kubeconfig.yaml

export KUBECONFIG=$PWD/kubeconfig.yaml
kubectl get nodes

A partir de aquí es un clúster estándar: aplica manifests, instala charts de Helm, corre lo que quieras.

Add-ons

CubePath tiene un catálogo de add-ons de un clic (controladores de ingress, monitorización y más) que puedes instalar en un clúster en lugar de montar Helm a mano.

• Explora el catálogo: GET /kubernetes/addons (y GET /kubernetes/addons/{slug} para los detalles).
• Instala en un clúster: POST /kubernetes/{cluster_uuid}/addons/{slug}/install, opcionalmente con custom_values para sobrescribir los valores por defecto.
• Mira lo instalado: GET /kubernetes/{cluster_uuid}/addons.
• Desinstala: DELETE /kubernetes/{cluster_uuid}/addons/{addon_uuid}.

Exponer tus aplicaciones

Para llevar tráfico desde internet a los servicios del clúster, pon un Load Balancer delante; puedes ver los balanceadores que apuntan a un clúster con GET /kubernetes/{cluster_uuid}/loadbalancers. Para clústeres solo internos, conecta una red privada al crearlo y omite las IPs públicas de los workers.

Gestionar el clúster

• Renombrar: PATCH /kubernetes/{uuid} (nombre y label).
• Proteger: POST /kubernetes/{uuid}/protection bloquea el borrado hasta que lo desactives.
• Mover de proyecto: POST /kubernetes/{uuid}/move.
• Eliminar: DELETE /kubernetes/{uuid} destruye el clúster y sus workers. Desactiva la protección antes si está activa.

Límites

Lo que esto no hace

• No gestionas el control plane ni tienes SSH a él. Lo lleva CubePath. Interactúas con el clúster a través de la API de Kubernetes (kubeconfig), no entrando en las máquinas del control plane.
• No expone tus aplicaciones por sí solo. Un clúster recién creado no tiene ingress público hasta que añades un add-on de ingress y un Load Balancer.
• Un clúster vive en una sola ubicación. La colocación de los workers y su red privada están dentro de una única ubicación.

Referencia de la API

GET    /kubernetes/versions                               Listar versiones de Kubernetes.   (scope: kubernetes:read)
GET    /kubernetes/plans                                  Listar planes de worker.          (scope: kubernetes:read)
POST   /kubernetes/   { project_id, name, location_name, node_pools }  Crear un clúster.    (scope: kubernetes:write)
GET    /kubernetes/                                       Listar tus clústeres.             (scope: kubernetes:read)
GET    /kubernetes/{uuid}                                 Ver un clúster.                   (scope: kubernetes:read)
PATCH  /kubernetes/{uuid}   { name, label }               Renombrar un clúster.             (scope: kubernetes:write)
DELETE /kubernetes/{uuid}                                 Eliminar un clúster.              (scope: kubernetes:write)
POST   /kubernetes/{uuid}/protection   { enabled }        Activar/desactivar protección.    (scope: kubernetes:write)
GET    /kubernetes/{uuid}/kubeconfig                      Descargar el kubeconfig.          (scope: kubernetes:read)
POST   /kubernetes/{uuid}/move   { project_id }           Mover a otro proyecto.            (scope: kubernetes:write)
GET    /kubernetes/{uuid}/loadbalancers                   Balanceadores que lo apuntan.     (scope: kubernetes:read)
GET    /kubernetes/{cluster_uuid}/node-pools              Listar node pools.                (scope: kubernetes:read)
POST   /kubernetes/{cluster_uuid}/node-pools   { name, plan, count }  Crear un node pool.   (scope: kubernetes:write)
PATCH  /kubernetes/{cluster_uuid}/node-pools/{pool_uuid}  Escalar o actualizar un pool.     (scope: kubernetes:write)
DELETE /kubernetes/{cluster_uuid}/node-pools/{pool_uuid}  Eliminar un pool.                 (scope: kubernetes:write)
POST   /kubernetes/{cluster_uuid}/node-pools/{pool_uuid}/nodes   { count }  Añadir workers. (scope: kubernetes:write)
DELETE /kubernetes/{cluster_uuid}/node-pools/{pool_uuid}/nodes/{vps_id}  Quitar un worker.  (scope: kubernetes:write)
GET    /kubernetes/addons                                 Explorar el catálogo de add-ons.  (scope: kubernetes:read)
GET    /kubernetes/{cluster_uuid}/addons                  Listar add-ons instalados.        (scope: kubernetes:read)
POST   /kubernetes/{cluster_uuid}/addons/{slug}/install   Instalar un add-on.               (scope: kubernetes:write)
DELETE /kubernetes/{cluster_uuid}/addons/{addon_uuid}     Desinstalar un add-on.            (scope: kubernetes:write)

Todas las peticiones se autentican con Authorization: Bearer <token> (o X-API-Key). Las peticiones de escritura necesitan además X-Requested-With: XMLHttpRequest.