Crear cargas de trabajo con reconocimiento del estado

En esta página se explica cómo crear y gestionar cargas de trabajo con estado en un clúster de Kubernetes aislado de Google Distributed Cloud (GDC). Las cargas de trabajo con reconocimiento del estado te permiten escalar la implementación de tu aplicación con almacenamiento persistente. El almacenamiento persistente proporciona a tu aplicación identidades coherentes y nombres de host estables, independientemente de dónde se programen sus cargas de trabajo.

Esta página está dirigida a los desarrolladores del grupo de operadores de aplicaciones, que son responsables de crear cargas de trabajo de aplicaciones para su organización. Para obtener más información, consulta Audiencias de la documentación aislada de GDC.

Antes de empezar

Para ejecutar comandos en un clúster de Kubernetes, asegúrate de que tienes los siguientes recursos:

  1. Busca el nombre del clúster de Kubernetes o pregunta a tu administrador de la plataforma cuál es.

  2. Inicia sesión y genera el archivo kubeconfig del clúster de Kubernetes si no tienes uno.

  3. Usa la ruta kubeconfig del clúster de Kubernetes para sustituir KUBERNETES_CLUSTER_KUBECONFIG en estas instrucciones.

Para obtener los permisos necesarios para crear cargas de trabajo con estado, pide a tu administrador de gestión de identidades y accesos de la organización que te conceda el rol de administrador de espacio de nombres (namespace-admin) en el espacio de nombres de tu proyecto.

Crear un recurso StatefulSet

Crea un objeto StatefulSet escribiendo un manifiesto StatefulSet y ejecutando kubectl apply para crear el recurso. Para que los clientes puedan enviar solicitudes a los pods de tu recurso StatefulSet de forma estable, también debes crear un objeto Service.

El comando kubectl apply usa archivos de manifiesto para crear, actualizar y eliminar recursos en tu clúster de Kubernetes. Es un método declarativo de configuración de objetos. Este método conserva las escrituras realizadas en objetos activos sin combinar los cambios en los archivos de configuración de objetos.

Para crear un recurso StatefulSet y Service, ejecuta el siguiente comando:

kubectl --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG -n NAMESPACE \
    apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: SERVICE_NAME
  labels:
    app: APP_NAME
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: APP_NAME
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: STATEFULSET_NAME
spec:
  selector:
    matchLabels:
      app: APP_LABEL_NAME
  serviceName: "SERVICE_NAME"
  replicas: NUMBER_OF_REPLICAS
  template:
    metadata:
      labels:
        app: APP_LABEL_NAME
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: CONTAINER_NAME
        image: CONTAINER_IMAGE
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: CONTAINER_STORAGE_VOLUME_PATH
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi
EOF

Haz los cambios siguientes:

  • KUBERNETES_CLUSTER_KUBECONFIG: el archivo kubeconfig del clúster en el que vas a implementar cargas de trabajo de contenedores.

  • NAMESPACE: el espacio de nombres del proyecto en el que se van a desplegar las cargas de trabajo del contenedor.

  • SERVICE_NAME: el nombre del objeto Service. Comprueba que el objeto StatefulSet también defina el objeto Service en su serviceName.

  • APP_NAME: el nombre de la aplicación que se va a ejecutar en la implementación.

  • APP_LABEL_NAME: el selector de etiquetas que determina qué pods pertenecen al objeto StatefulSet.

  • STATEFULSET_NAME: el nombre del objeto StatefulSet.

  • NUMBER_OF_REPLICAS: número de objetos Pod replicados que gestiona la implementación.

  • CONTAINER_NAME: el nombre del contenedor.

  • CONTAINER_IMAGE: el nombre de la imagen del contenedor. Debes incluir la ruta del registro de contenedores y la versión de la imagen, como REGISTRY_PATH/nginx:1.23.

  • CONTAINER_STORAGE_VOLUME_PATH: la ruta del contenedor en la que se monta un volumen de almacenamiento.

Por ejemplo, el siguiente objeto StatefulSet y el objeto Service correspondiente crean cargas de trabajo de contenedor con estado:

apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  selector:
    matchLabels:
      app: nginx
  serviceName: "nginx"
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: REGISTRY_PATH/nginx:1.23
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

En este ejemplo:

  • Se crea un objeto Service llamado nginx, indicado por el campo metadata: name. El objeto Service se dirige a una aplicación llamada nginx, indicada por labels.app: nginx y selector.app: nginx. El objeto Service expone el puerto 80 y le asigna el nombre web. Este objeto Service controla el dominio de red y dirige el tráfico de Internet a la aplicación contenerizada implementada por el objeto StatefulSet.
  • Se crea un StatefulSet llamado web con tres objetos Pod replicados, tal como se establece en el campo replicas: 3.
  • La plantilla Pod, definida por la sección .spec.template, indica que sus objetos Pod se etiquetan como app: nginx.
  • La especificación Pod, definida en la sección .template.spec, indica que los pods de StatefulSet ejecutan un contenedor, nginx, que ejecuta la imagen nginx en la versión 1.23.
  • La especificación Pod usa el puerto web abierto por el objeto Service.
  • La sección .template.spec.volumeMounts especifica un campo mountPath, que se llama www. mountPath es la ruta del contenedor en la que se monta un volumen de almacenamiento.
  • StatefulSet aprovisiona tres objetos PersistentVolumeClaim, llamados web-www-0, web-www-1 y web-www-2, con 1 GB de almacenamiento aprovisionado cada uno.

Una vez creado, el StatefulSet se asegura de que el número deseado de objetos Pod se ejecuten y estén disponibles en todo momento. StatefulSet sustituye automáticamente los objetos Pod que fallan o se eliminan de sus nodos, y asocia nuevos objetos Pod con los recursos de almacenamiento, las solicitudes y los límites de recursos, y otras configuraciones definidas en la especificación Pod del objeto StatefulSet.

Solicitar almacenamiento persistente en un recurso StatefulSet

El almacenamiento persistente se puede aprovisionar de forma dinámica para que los volúmenes subyacentes se creen bajo demanda. Las aplicaciones pueden solicitar almacenamiento persistente con un objeto PersistentVolumeClaim.

Normalmente, debes crear objetos PersistentVolumeClaim además de crear el objeto Pod. Sin embargo, los objetos StatefulSet incluyen un array volumeClaimTemplates que genera los objetos PersistentVolumeClaim. Cada réplica de StatefulSet tiene su propio objeto PersistentVolumeClaim.

Para obtener más información, consulta Configurar el almacenamiento de contenedores.