Programación con Selectores de Nodos (Node Selectors)

Introducción

En este laboratorio, comenzaremos creando una implementación (deployment) simple y luego le asignaremos Selectores de Nodos (Node Selectors). Luego, pasaremos a escenarios más complejos donde utilizaremos diferentes selectores para programar pods en nodos específicos.

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

Navegar a tu directorio de trabajo:

Abre la terminal y navega hasta la carpeta de proyecto predeterminada:
```
cd /home/labex/project
```
Iniciar Minikube:

Inicia Minikube para inicializar un clúster de Kubernetes:
```
minikube start
```
- Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
- Minikube puede tardar unos minutos en iniciar, dependiendo del rendimiento de tu sistema.
Verificar que Minikube esté en ejecución:

Comprueba el estado del clúster de Minikube:
```
minikube status
```
- Busca componentes como kubelet y apiserver listados como Running (En ejecución).
- Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Crear una implementación (deployment) simple

En este paso, crearemos una implementación (deployment) simple con un solo pod.

Crea un archivo llamado simple-deployment.yaml con el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: simple-app
  template:
    metadata:
      labels:
        app: simple-app
    spec:
      containers:
        - name: simple-container
          image: nginx:latest

Utiliza kubectl para crear la implementación (deployment):

kubectl apply -f simple-deployment.yaml

Verifica que la implementación (deployment) se haya creado:

kubectl get deployments

Asignar Selectores de Nodos (Node Selectors) a una Implementación (Deployment)

En este paso, asignaremos un Selector de Nodos (Node Selector) a la implementación (deployment) que creamos en el Paso 1.

Crea los nodos con una etiqueta (label):

kubectl label nodes minikube disk=ssd

Edita el archivo node-selector-deployment.yaml y agrega el campo nodeSelector en la sección spec.template.spec:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: selector-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: selector-app
  template:
    metadata:
      labels:
        app: selector-app
    spec:
      nodeSelector:
        disk: ssd
      containers:
        - name: selector-container
          image: nginx:latest

Utiliza kubectl para aplicar los cambios:

kubectl apply -f node-selector-deployment.yaml

Verifica que el pod se haya programado en un nodo con la etiqueta (label) disk=ssd:

kubectl get pods -o wide | grep selector-deployment

Usar diferentes Selectores de Nodos (Node Selectors)

En este paso, utilizaremos diferentes Selectores de Nodos (Node Selectors) para programar pods en nodos específicos basados en las etiquetas (labels) asignadas a esos nodos.

Crea tres nodos con diferentes etiquetas (labels):

kubectl label nodes minikube resigon=labex
kubectl label nodes minikube gpu=true

Crea un archivo llamado multi-selector-deployment.yaml con el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multi-selector-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: multi-selector-app
  template:
    metadata:
      labels:
        app: multi-selector-app
    spec:
      containers:
        - name: multi-selector-container
          image: nginx:latest
      nodeSelector:
        resigon: labex
        gpu: "true"

Aplica los cambios:

kubectl apply -f multi-selector-deployment.yaml

Verifica que los pods se hayan programado en nodos con las etiquetas (labels) adecuadas:

kubectl get pods -o wide | grep multi-selector-deployment

Resumen

En este laboratorio, aprendimos cómo programar pods en nodos específicos utilizando Selectores de Nodos (Node Selectors) y Afinidad de Nodos (Node Affinity). Comenzamos con una implementación (deployment) simple y luego pasamos a escenarios más complejos en los que utilizamos diferentes selectores y reglas de afinidad para programar pods en nodos específicos basados en las etiquetas (labels) asignadas a esos nodos.

¡Felicidades! Has completado con éxito este laboratorio.