El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Ejecución de Aplicaciones con Estado

Siguiente ►
►

En este módulo, aprenderemos sobre la ejecución de aplicaciones con estado en Kubernetes. Las aplicaciones con estado son aquellas que mantienen datos persistentes y requieren que los datos se conserven entre reinicios y actualizaciones. Kubernetes proporciona varios mecanismos para gestionar estas aplicaciones de manera eficiente.

Contenido

  1. Introducción a las Aplicaciones con Estado
  2. StatefulSets
  3. Volúmenes Persistentes
  4. Ejemplo Práctico: Despliegue de una Base de Datos MySQL
  5. Ejercicios Prácticos
  6. Conclusión

Introducción a las Aplicaciones con Estado

Las aplicaciones con estado requieren que los datos se mantengan a lo largo del tiempo y no se pierdan cuando los contenedores se reinician o se reprograman. Algunos ejemplos comunes de aplicaciones con estado incluyen bases de datos, sistemas de mensajería y aplicaciones de almacenamiento de archivos.

Características de las Aplicaciones con Estado

  • Persistencia de Datos: Los datos deben sobrevivir a los reinicios y actualizaciones.
  • Identidad Estable: Cada instancia de la aplicación debe tener una identidad única y estable.
  • Orden de Despliegue y Escalado: El orden en el que se despliegan y escalan las instancias puede ser importante.

StatefulSets

StatefulSets es el recurso de Kubernetes diseñado específicamente para gestionar aplicaciones con estado. Proporciona garantías sobre el orden y la estabilidad de las identidades de los pods.

Características de StatefulSets

  • Identidad Estable: Cada pod en un StatefulSet tiene un nombre único y estable.
  • Persistencia de Almacenamiento: Los volúmenes persistentes se asocian con los pods y se mantienen incluso si los pods se eliminan.
  • Orden de Despliegue y Escalado: Los pods se despliegan y escalan en un orden específico.

Ejemplo de StatefulSet

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: "mysql"
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
  volumeClaimTemplates:
  - metadata:
      name: mysql-persistent-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Explicación del Ejemplo

  • serviceName: Define el nombre del servicio que gestionará el acceso a los pods del StatefulSet.
  • replicas: Número de réplicas del StatefulSet.
  • selector: Selector de etiquetas para identificar los pods gestionados por el StatefulSet.
  • template: Plantilla de pod que define la configuración de los contenedores.
  • volumeClaimTemplates: Plantilla para crear PersistentVolumeClaims (PVC) para cada pod.

Volúmenes Persistentes

Los volúmenes persistentes (Persistent Volumes, PV) y las reclamaciones de volúmenes persistentes (Persistent Volume Claims, PVC) son los mecanismos que Kubernetes utiliza para gestionar el almacenamiento persistente.

Ejemplo de PersistentVolume y PersistentVolumeClaim

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-mysql
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

---

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-mysql
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Explicación del Ejemplo

  • PersistentVolume: Define un volumen persistente con una capacidad de 1Gi y un modo de acceso ReadWriteOnce.
  • PersistentVolumeClaim: Solicita un volumen persistente con una capacidad de 1Gi y un modo de acceso ReadWriteOnce.

Ejemplo Práctico: Despliegue de una Base de Datos MySQL

Vamos a desplegar una base de datos MySQL utilizando StatefulSets y volúmenes persistentes.

Paso 1: Crear el StatefulSet

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: "mysql"
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        ports:
        - containerPort: 3306
          name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "rootpassword"
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
  volumeClaimTemplates:
  - metadata:
      name: mysql-persistent-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Paso 2: Crear el Servicio

apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  ports:
  - port: 3306
    name: mysql
  clusterIP: None
  selector:
    app: mysql

Despliegue

  1. Crear el StatefulSet: kubectl apply -f statefulset.yaml
  2. Crear el Servicio: kubectl apply -f service.yaml

Ejercicios Prácticos

  1. Despliegue de una Base de Datos PostgreSQL:

    • Cree un StatefulSet para una base de datos PostgreSQL.
    • Asegúrese de que los datos se mantengan persistentes entre reinicios.

  2. Escalado de StatefulSets:

    • Escale el StatefulSet de MySQL a 5 réplicas.
    • Verifique que cada pod tenga su propio volumen persistente.

Soluciones

  1. Despliegue de una Base de Datos PostgreSQL:
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgresql
spec:
  serviceName: "postgresql"
  replicas: 3
  selector:
    matchLabels:
      app: postgresql
  template:
    metadata:
      labels:
        app: postgresql
    spec:
      containers:
      - name: postgresql
        image: postgres:12
        ports:
        - containerPort: 5432
          name: postgresql
        env:
        - name: POSTGRES_PASSWORD
          value: "postgrespassword"
        volumeMounts:
        - name: postgresql-persistent-storage
          mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
  - metadata:
      name: postgresql-persistent-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi
  1. Escalado de StatefulSets:
kubectl scale statefulset mysql --replicas=5

Conclusión

En esta sección, hemos aprendido sobre la ejecución de aplicaciones con estado en Kubernetes utilizando StatefulSets y volúmenes persistentes. Hemos visto cómo desplegar una base de datos MySQL y cómo gestionar el almacenamiento persistente. Estos conceptos son fundamentales para gestionar aplicaciones con estado en un entorno de Kubernetes.

En el próximo módulo, exploraremos cómo gestionar múltiples clústeres de Kubernetes y las mejores prácticas para la gestión multi-clúster.

◄ Anterior
◄
Siguiente ►
►

Curso de Kubernetes

Módulo 1: Introducción a Kubernetes

Módulo 2: Componentes Principales de Kubernetes

Módulo 3: Gestión de Configuración y Secretos

Módulo 4: Redes en Kubernetes

Módulo 5: Almacenamiento en Kubernetes

Módulo 6: Conceptos Avanzados de Kubernetes

Módulo 7: Monitoreo y Registro

Módulo 8: Seguridad en Kubernetes

Módulo 9: Escalado y Rendimiento

Módulo 10: Ecosistema y Herramientas de Kubernetes

Módulo 11: Estudios de Caso y Aplicaciones del Mundo Real

Módulo 12: Preparación para la Certificación de Kubernetes

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados