Kubernetes Primeros pasos

Note

Este artículo se cotejó inicialmente con las notas de la versión de Ubuntu 26.04 LTS de abril de 2026. Las versiones de los componentes Kubernetes y los detalles de implementación de producción aún necesitan una validación continua con MicroK8 y actualizaciones ascendentes.

Kubernetes (abreviado como K8s) es la plataforma de orquestación de contenedores más popular en la actualidad, de código abierto de Google y donada a la CNCF (Cloud Native Computing Foundation). Automatiza la implementación, el escalado y la gestión de aplicaciones en contenedores y es la piedra angular de la arquitectura moderna nativa de la nube.

Ubuntu es una de las principales distribuciones de Linux para ejecutar Kubernetes. Canonical también ofrece MicroK8s, una distribución Kubernetes liviana y fácil de instalar que es ideal para escenarios de desarrollo, pruebas y computación de vanguardia.

¿Qué es el K8 y por qué lo necesita?

Puntos débiles antes de los K8

En la era de la contenedorización, Docker resolvió el problema de “empaquetar y ejecutar aplicaciones”. Pero cuando hay que gestionar decenas o incluso cientos de contenedores, surgen nuevos desafíos:

Si un contenedor falla, ¿quién lo reinicia automáticamente?
Cuando el tráfico aumenta, ¿cómo se escala automáticamente?
¿Cómo se descubren y se comunican los contenedores entre sí?
¿Cómo se realizan actualizaciones continuas sin interrupción del servicio?
¿Cómo se programan contenedores en varios servidores?

Lo que resuelve el K8

Kubernetes fue creado para abordar estos problemas exactos:

Característica	Descripción
Autosanación	Reinicia automáticamente los contenedores estrellados; migra cargas de trabajo cuando fallan los nodos
Escala horizontal	Aumenta o disminuye automáticamente las instancias de contenedores según la carga.
Descubrimiento de servicios	Los contenedores se registran automáticamente y acceden entre sí a través de nombres DNS
Actualizaciones continuas	Reemplaza gradualmente las versiones antiguas para implementaciones sin tiempo de inactividad
Equilibrio de carga	Distribuye automáticamente el tráfico entre múltiples instancias de contenedores.
Gestión de configuración	Gestión centralizada de configuraciones y secretos de aplicaciones.

Instalación de MicroK8

MicroK8s es el Kubernetes liviano de Canonical, instalado a través de Snap con un solo comando.

Instalación de MicroK8


# Install MicroK8s
# Choose the latest stable channel; check snap info microk8s for available versions
sudo snap install microk8s --classic --channel=1.33/stable
 
# Add current user to the microk8s group (avoid sudo every time)
sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube
 
# Re-login for group permissions to take effect
newgrp microk8s
 
# Check installation status
microk8s status --wait-ready

Habilitar complementos comunes

MicroK8s viene con muchos complementos integrados:


# Enable DNS (internal cluster name resolution -- almost always required)
microk8s enable dns
 
# Enable local storage
microk8s enable hostpath-storage
 
# Enable Dashboard (web management interface)
microk8s enable dashboard
 
# Enable Ingress (HTTP reverse proxy)
microk8s enable ingress
 
# Enable container image registry
microk8s enable registry
 
# Enable multiple add-ons at once
microk8s enable dns hostpath-storage dashboard ingress
 
# View all available add-ons
microk8s status

Configurando el alias kubectl

MicroK8s incluye microk8s kubectl, pero escribirlo cada vez es tedioso. Puede configurar un alias:


# Option 1: Use an alias
alias kubectl='microk8s kubectl'
echo "alias kubectl='microk8s kubectl'" >> ~/.bashrc
 
# Option 2: Export config for a standalone kubectl installation
microk8s config > ~/.kube/config

Operaciones básicas de kubectl

kubectl es la herramienta de línea de comandos para interactuar con los clústeres Kubernetes.

Información del clúster


# View cluster information
kubectl cluster-info
 
# View all nodes
kubectl get nodes
 
# View node details
kubectl describe node <node-name>
 
# View cluster component status
kubectl get componentstatuses

Ver recursos


# View all Pods
kubectl get pods
 
# View Pods across all namespaces
kubectl get pods --all-namespaces
# Or shorthand
kubectl get pods -A
 
# View Pod details (wide output)
kubectl get pods -o wide
 
# View all Deployments
kubectl get deployments
 
# View all Services
kubectl get services
# Or shorthand
kubectl get svc
 
# View all resources
kubectl get all

Detalles y registros de recursos


# View Pod details
kubectl describe pod <pod-name>
 
# View Pod logs
kubectl logs <pod-name>
 
# Follow logs in real-time
kubectl logs -f <pod-name>
 
# View logs for a specific container in a multi-container Pod
kubectl logs <pod-name> -c <container-name>
 
# Execute commands inside a Pod
kubectl exec -it <pod-name> -- /bin/bash

Conceptos básicos

Vaina

Un Pod es la unidad desplegable más pequeña en Kubernetes. Un Pod contiene uno o más contenedores que comparten redes y almacenamiento.


# pod-example.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80


# Create a Pod
kubectl apply -f pod-example.yaml
 
# Check Pod status
kubectl get pod nginx-pod
 
# Delete a Pod
kubectl delete pod nginx-pod

Despliegue

Una implementación gestiona el recuento de réplicas de Pod, las actualizaciones continuas y las reversiones. En la práctica, casi nunca creará Pods directamente; en cambio, los administrará a través de Implementaciones.


# deployment-example.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.27
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"


# Deploy the application
kubectl apply -f deployment-example.yaml
 
# View deployment status
kubectl get deployment nginx-deployment
 
# Scale up/down
kubectl scale deployment nginx-deployment --replicas=5
 
# View rolling update status
kubectl rollout status deployment nginx-deployment
 
# Update image version
kubectl set image deployment/nginx-deployment nginx=nginx:1.28
 
# Rollback to previous version
kubectl rollout undo deployment nginx-deployment
 
# View update history
kubectl rollout history deployment nginx-deployment

Servicio

Un Servicio proporciona un punto final de red estable para un conjunto de Pods. Las IP de los pods cambian dinámicamente, mientras que un Servicio proporciona un punto de acceso fijo.


# service-example.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Descripciones de tipos de servicios:

Tipo	Descripción
IP de clúster	Por defecto; accesible sólo dentro del clúster
Puerto de nodo	Abre un puerto en cada nodo; accesible externamente
Equilibrador de carga	Utiliza el balanceador de carga del proveedor de la nube.


# Create a Service
kubectl apply -f service-example.yaml
 
# View the Service
kubectl get svc nginx-service
 
# Expose a service with NodePort
kubectl expose deployment nginx-deployment --type=NodePort --port=80

Implementación de su primera aplicación

Implementemos una aplicación web completa de principio a fin.

Paso 1: crear una implementación


# Quickly create using the command line
kubectl create deployment hello-app --image=gcr.io/google-samples/hello-app:1.0
 
# Verify the Pod is running
kubectl get pods -l app=hello-app

Paso 2: exponer el servicio


# Create a NodePort Service
kubectl expose deployment hello-app --type=NodePort --port=8080
 
# View the assigned port
kubectl get svc hello-app

Paso 3: Accede a la Aplicación


# Get the access URL
# MicroK8s runs locally by default, so use localhost
NODE_PORT=$(kubectl get svc hello-app -o jsonpath='{.spec.ports[0].nodePort}')
echo "Access URL: http://localhost:$NODE_PORT"
 
# Test access
curl http://localhost:$NODE_PORT

Paso 4: Ampliar


# Scale to 3 replicas
kubectl scale deployment hello-app --replicas=3
 
# View all Pods
kubectl get pods -l app=hello-app

Paso 5: Limpiar


# Delete the Service and Deployment
kubectl delete svc hello-app
kubectl delete deployment hello-app

Gestión de paquetes de timón

Helm es el administrador de paquetes para Kubernetes, similar a apt de Ubuntu. Utiliza Gráficos (paquetes) para definir, instalar y actualizar aplicaciones Kubernetes complejas.

Instalación del timón


# Option 1: Install via Snap
sudo snap install helm --classic
 
# Option 2: Install via official script
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
 
# Verify installation
helm version

Usando el timón


# Add the official stable repository
helm repo add bitnami https://charts.bitnami.com/bitnami
 
# Update repository index
helm repo update
 
# Search for Charts
helm search repo nginx
helm search repo mysql
 
# Install an application (Redis example)
helm install my-redis bitnami/redis
 
# View installed Releases
helm list
 
# View Release status
helm status my-redis
 
# Install with custom configuration
helm install my-nginx bitnami/nginx \
  --set replicaCount=3 \
  --set service.type=NodePort
 
# Install with a values file for custom configuration
helm install my-app bitnami/nginx -f custom-values.yaml
 
# Upgrade a Release
helm upgrade my-redis bitnami/redis --set auth.enabled=false
 
# Rollback
helm rollback my-redis 1
 
# Uninstall a Release
helm uninstall my-redis

Creando tu propio gráfico


# Create a new Chart template
helm create my-chart
 
# Directory structure
# my-chart/
#   Chart.yaml      # Chart metadata
#   values.yaml     # Default configuration values
#   templates/       # K8s resource templates
#     deployment.yaml
#     service.yaml
#     ingress.yaml
 
# Validate the Chart
helm lint my-chart/
 
# Dry-run install (no actual deployment)
helm install my-release my-chart/ --dry-run --debug
 
# Package the Chart
helm package my-chart/

Tabla de comandos de referencia rápida

Operación	Dominio
Ver el estado del clúster	`kubectl cluster-info`
Ver todos los pods	`kubectl get pods -A`
Ver registros de pod	`kubectl logs POD_NAME`
Ingrese una cápsula	`kubectl exec -it POD_NAME -- bash`
Crear un recurso	`kubectl apply -f file.yaml`
Eliminar un recurso	`kubectl delete -f file.yaml`
Aumentar proporcionalmente	`kubectl scale deployment NAME --replicas=N`
Actualizar imagen	`kubectl set image deployment/NAME container=image`
Revertir	`kubectl rollout undo deployment/NAME`
Puerto hacia adelante	`kubectl port-forward pod/NAME 8080:80`
Ver uso de recursos	`kubectl top pods`
Estado del MicroK8	`microk8s status`
Inicio del MicroK8	`microk8s start`
Parada de MicroK8	`microk8s stop`

Consideraciones de producción

Warning

MicroK8s es excelente para el aprendizaje y el desarrollo, pero cuando utilice Kubernetes en producción, tenga en cuenta estos puntos:

Clúster de alta disponibilidad: la producción requiere al menos 3 nodos del plano de control para evitar puntos únicos de falla.
Límites de recursos: configure siempre resources.requests y resources.limits para cada contenedor para evitar que una aplicación consuma todos los recursos del nodo.
Políticas de red: configure NetworkPolicy para restringir la comunicación de pod a pod siguiendo el principio de privilegio mínimo
Permisos RBAC: no ejecute aplicaciones con privilegios de administrador de clúster; crear cuentas de servicio dedicadas para cada servicio
Seguridad de imágenes: utilice únicamente registros de imágenes confiables, escanee imágenes periódicamente en busca de vulnerabilidades y evite el uso de la etiqueta latest
Copia de seguridad de etcd: etcd almacena todos los datos del estado del clúster; las copias de seguridad periódicas son fundamentales
Monitoreo y alertas: implemente Prometheus + Grafana para monitorear el estado del clúster
Recopilación de registros: use EFK (Elasticsearch + Fluentd + Kibana) o Loki para la agregación de registros

Para soporte de nivel empresarial, considere Charmed Kubernetes de Canonical o servicios K8 administrados de proveedores de nube (por ejemplo, AWS EKS, Google GKE, Azure AKS).

Solución de problemas comunes


# Pod stuck in Pending state
kubectl describe pod <pod-name>
# Usually caused by insufficient resources or node selector mismatch
 
# Pod in CrashLoopBackOff
kubectl logs <pod-name> --previous
# View logs from the previous crash
 
# Cannot pull image (ImagePullBackOff)
kubectl describe pod <pod-name>
# Check if the image name is correct and whether image pull credentials are needed
 
# Service inaccessible
kubectl get endpoints <service-name>
# Verify that the Service selector matches the Pod labels
 
# DNS resolution failure
kubectl run test --image=busybox --rm -it -- nslookup kubernetes.default
# Check if CoreDNS is running properly

Después de dominar el contenido anterior, podrá ejecutar y administrar cargas de trabajo básicas de Kubernetes en Ubuntu. A medida que su experiencia crezca, podrá explorar más a fondo ConfigMap, Secret, PersistentVolume, Ingress, CronJob y otros tipos de recursos.