Crea cargas de trabajo con estado

En este documento, se explica cómo crear y administrar cargas de trabajo con estado dentro de un clúster de Kubernetes aislado de Google Distributed Cloud (GDC). Las cargas de trabajo con 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, sin importar dónde se programen sus cargas de trabajo.

Este documento está dirigido 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 Públicos de la documentación de GDC aislado.

Antes de comenzar

Para completar las tareas de este documento, debes solicitar los permisos necesarios y preparar tu entorno.

Solicita roles de IAM

Debes tener roles específicos para obtener los permisos que necesitas para crear cargas de trabajo con estado. Los roles que necesitas dependen de si trabajas en un clúster compartido con permiso de organización o en un clúster estándar con permiso de proyecto. Para obtener más información, consulta Parámetros de configuración de clústeres de Kubernetes.

Roles de clúster compartidos

Para crear, borrar, editar o ver cargas de trabajo con estado en un clúster compartido, pídele a tu administrador de IAM del proyecto que te otorgue el rol de administrador de espacio de nombres (namespace-admin). Este rol está vinculado al espacio de nombres de tu proyecto.

Roles de clúster estándar

Para crear, borrar, editar o ver cargas de trabajo con estado en un clúster estándar, pídele al administrador de IAM del proyecto que te otorgue el rol de desarrollador de clústeres (cluster-developer). Este rol está vinculado al espacio de nombres de tu proyecto.

Prepara el entorno

Para ejecutar comandos en un clúster de Kubernetes con la API, asegúrate de tener los siguientes recursos:

  • Busca el nombre del clúster de Kubernetes o pregúntale a un miembro del grupo de administradores de la plataforma cuál es el nombre del clúster.

  • Accede y genera el archivo kubeconfig para el clúster de Kubernetes.

  • Usa la ruta de acceso de kubeconfig del clúster de Kubernetes para reemplazar KUBERNETES_CLUSTER_KUBECONFIG en estas instrucciones.

Crea un recurso StatefulSet

Escribe un manifiesto de StatefulSetStatefulSet y ejecuta kubectl apply para crear el recurso. Para proporcionar una forma estable de que los clientes envíen solicitudes a los Pods de tu recurso StatefulSet, también debes crear un objeto Service.

El comando kubectl apply usa archivos de manifiesto para crear, actualizar y borrar recursos en tu clúster de Kubernetes. Este es un método declarativo de configuración de objetos. Con este método, se retienen las escrituras realizadas en objetos activos sin combinar los cambios en los archivos de configuración del objeto.

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

Reemplaza lo siguiente:

  • KUBERNETES_CLUSTER_KUBECONFIG: Es el archivo kubeconfig del clúster en el que implementas las cargas de trabajo de contenedores.

  • NAMESPACE: Es el espacio de nombres en el que se implementarán las cargas de trabajo de contenedores. En el caso de los clústeres compartidos, debe ser un espacio de nombres del proyecto. Para los clústeres estándar, puede ser cualquier espacio de nombres.

  • SERVICE_NAME: el nombre del objeto Service. Asegúrate de que el objeto StatefulSet también establezca el objeto Service en su serviceName.

  • APP_NAME: Es el nombre de la aplicación que se ejecutará dentro de la implementación.

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

  • STATEFULSET_NAME: Es el nombre del objeto StatefulSet.

  • NUMBER_OF_REPLICAS: Es la cantidad de objetos Pod replicados que administra la implementación.

  • CONTAINER_NAME: Es el nombre del contenedor.

  • CONTAINER_IMAGE por el nombre de la imagen de contenedor Debes incluir la ruta de acceso al Container Registry y la versión de la imagen, como REGISTRY_PATH/nginx:1.23. Para obtener más información sobre cómo configurar la ruta de acceso del registro de contenedores, consulta la descripción general del servicio de Harbor administrado.

  • CONTAINER_STORAGE_VOLUME_PATH: Es la ruta de acceso dentro del contenedor en la que se activa un volumen de almacenamiento.

Por ejemplo, el siguiente objeto StatefulSet y el objeto Service correspondiente crean cargas de trabajo de contenedores 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 orienta a una app llamada nginx, indicada por labels.app: nginx y selector.app: nginx. El objeto Service expone el puerto 80 y lo nombra web. Este objeto Service controla el dominio de red y enruta el tráfico de Internet a la aplicación alojada en contenedores que implementa el objeto StatefulSet.
  • Se crea un StatefulSet llamado web con tres objetos Pod replicados, como lo establece el campo replicas: 3.
  • La plantilla Pod, establecida por la sección .spec.template, indica que sus objetos Pod están etiquetados como app: nginx.
  • La especificación Pod, establecida por 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 de Pod usa el puerto web que abrió el objeto Service.
  • En la sección .template.spec.volumeMounts, se especifica un campo mountPath, que se llama www. mountPath es la ruta de acceso en el contenedor en la que se activa un volumen de almacenamiento.
  • El StatefulSet aprovisiona tres objetos PersistentVolumeClaim, llamados web-www-0, web-www-1 y web-www-2, con 1 GB de almacenamiento aprovisionado cada uno.

Después de crearlo, el StatefulSet se asegura de que la cantidad objetivo de objetos Pod esté en ejecución y disponible en todo momento. El StatefulSet reemplaza de forma automática los objetos Pod que fallan o que son expulsados de sus nodos, y asocia nuevos objetos Pod con los recursos de almacenamiento, las solicitudes y límites de recursos y otras opciones de configuración definidas en la especificación de Pod del objeto StatefulSet.

Solicita almacenamiento persistente en un recurso StatefulSet

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

Por lo general, 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 obtiene su propio objeto PersistentVolumeClaim.

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

¿Qué sigue?