Implementa una aplicación con estado

En esta página, se explica cómo implementar una aplicación con estado mediante Google Kubernetes Engine (GKE).

Descripción general

Las aplicaciones con estado guardan datos en el almacenamiento de discos persistentes para que los usen el servidor, los clientes y otras aplicaciones. Un ejemplo de aplicación con estado es una base de datos o un almacén de clave-valor en el que otras aplicaciones guardan y recuperan datos.

El almacenamiento continuo se puede aprovisionar de forma dinámica, por lo que los volúmenes subyacentes se crean a pedido. En Kubernetes, configuras el aprovisionamiento dinámico mediante la creación de una StorageClass. En GKE, una StorageClass predeterminada te permite aprovisionar de forma dinámica los discos persistentes de Compute Engine.

Kubernetes usa el controlador StatefulSet para implementar aplicaciones con estado como objetos de StatefulSet. Los pods de StatefulSets no son intercambiables: cada uno usa un identificador único que se conserva más allá de dónde se programe.

Las aplicaciones con estado son diferentes de las aplicaciones sin estado, en las que los datos del cliente no se guardan en el servidor entre sesiones.

Puedes obtener más información sobre el almacenamiento continuo en clústeres multizonales y regionales.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

  • Usa gcloud init si deseas ver una explicación sobre cómo configurar parámetros predeterminados.
  • Usa gcloud config para establecer el ID, la zona y la región del proyecto de manera individual.

Usa gcloud init

Si recibes el error One of [--zone, --region] must be supplied: Please specify location, completa esta sección.

  1. Ejecuta gcloud init y sigue las instrucciones:

    gcloud init

    Si usas SSH en un servidor remoto, usa la marca --console-only para evitar que el comando abra un navegador:

    gcloud init --console-only
  2. Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
  3. Crea una configuración nueva o selecciona una existente.
  4. Elige un proyecto de Google Cloud.
  5. Elige una zona predeterminada de Compute Engine.

Usa gcloud config

  • Establece tu ID del proyecto predeterminado:
    gcloud config set project project-id
  • Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
    gcloud config set compute/zone compute-zone
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada:
    gcloud config set compute/region compute-region
  • Actualiza gcloud a la versión más reciente:
    gcloud components update
  • Asegúrate de que tu aplicación en contenedores se almacene en un registro de imagen, como Container Registry.

Puedes seguir la Guía de inicio rápido para habilitar la API de GKE, crear un clúster y obtener más información sobre GKE.

Solicita almacenamiento continuo en StatefulSet

Las aplicaciones pueden solicitar almacenamiento continuo con un objeto PersistentVolumeClaim.

Por lo general, el usuario debe crear los objetos PersistentVolumeClaim aparte del pod. Sin embargo, StatefulSets incluye un arreglo volumeClaimTemplates que genera de forma automática los objetos PersistentVolumeClaim. Cada réplica de StatefulSet recibe su propio objeto PersistentVolumeClaim.

También puedes usar un disco preexistente en un StatefulSet.

Crea un StatefulSet

Para crear un StatefulSet, usa el comando kubectl apply.

El comando kubectl apply usa archivos de manifiesto para crear, actualizar y borrar recursos en tu clúster. 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.

Linux

El siguiente archivo de manifiesto es un ejemplo simple de un StatefulSet regido por un Service que se creó por separado:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-name
spec:
  selector:
    matchLabels:
      app: app-name
  serviceName: "service-name"
  replicas: 3
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: app-name
    spec:
      containers:
      - name: container-name
        image: ...
        ports:
        - containerPort: 80
          name: port-name
        volumeMounts:
        - name: pvc-name
          mountPath: ...
  volumeClaimTemplates:
  - metadata:
      name: pvc-name
      annotations:
        ...
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

En el ejemplo anterior, se ilustra lo siguiente:

  • statefulset-name es el nombre del StatefulSet.
  • service-name es el nombre del Service.
  • app-name es el nombre de la aplicación que se ejecuta en los Pods.
  • container-name es el nombre de los contenedores en los Pods.
  • port-name es el nombre del puerto que abrió el StatefulSet.
  • pvc-name es el nombre de PersistentVolumeClaim.

En este archivo, el campo kind especifica que se debe crear un objeto StatefulSet con las especificaciones definidas en el archivo. En este ejemplo, StatefulSet genera tres pods replicados y abre el puerto 80 para exponer StatefulSet en Internet.

Windows

Cuando usas clústeres con grupos de nodos de Windows Server, debes crear un StorageClass, ya que el predeterminado usa ext4 como tipo de sistema de archivos, que solo funciona para contenedores de Linux. Si usas un disco persistente de Compute Engine, debes usar NTFS como el tipo de almacenamiento de archivos, como se muestra en el siguiente ejemplo:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: storageclass-name
parameters:
  type: pd-standard
  fstype: NTFS
provisioner: kubernetes.io/gce-pd
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer

El siguiente manifiesto de StatefulSet usa el StorageClass que definiste con anterioridad. Crea cuatro pares de PersistentVolume y PersistentVolumeClaim para representar cuatro discos persistentes de Compute Engine. Cada pod en StatefulSet consume un disco persistente.

Para asegurarte de que los pods se programen de forma correcta en los nodos de Windows Server, debes agregar un selector de nodos a tu especificación de pods:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-name
spec:
  replicas: 4
  selector:
    matchLabels:
      app: app-name
  template:
    metadata:
      labels:
        app: app-name
      name: container-name
    spec:
      nodeSelector:
        kubernetes.io/os: windows
      containers:
      - name: container-name
        image: ...
        ports:
        - containerPort: 80
          name: port-name
        volumeMounts:
        - name: pvc-name
          mountPath: C:\mnt\state
  volumeClaimTemplates:
  - metadata:
      name: pvc-name
    spec:
      storageClassName: storageclass-name
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

En el ejemplo anterior, se ilustra lo siguiente:

  • app-name es el nombre de la aplicación que se ejecuta en los Pods.
  • statefulset-name es el nombre del StatefulSet.
  • container-name es el nombre de los contenedores en los Pods.
  • port-name es el nombre del puerto que abrió el StatefulSet.
  • pvc-name es el nombre de PersistentVolumeClaim.
  • storageclass-name es el nombre de StorageClass.

Para crear un StatefulSet, ejecuta el siguiente comando:

kubectl apply -f statefulset-file

En el comando anterior, statefulset-file es el archivo de manifiesto.

También puedes usar kubectl apply -f directory/ para crear todos los objetos (excepto los existentes) definidos en los archivos de configuración almacenados en un directorio.

Inspecciona un StatefulSet

kubectl

Para inspeccionar StatefulSet, ejecuta el siguiente comando:

kubectl get statefulset statefulset-name -o yaml

Este comando muestra la configuración activa de StatefulSet en formato YAML.

Para enumerar los Pods creados con el StatefulSet, ejecuta el siguiente comando:

kubectl get pods -l app=app-name

En este comando, la marca -l le indica a kubectl que etiquete todos los Pods con app-name.

El resultado es similar al siguiente:

NAME                                READY     STATUS    RESTARTS   AGE
pod-name                            1/1       Running   0          1m
pod-name                            1/1       Running   0          1m

Para obtener información detallada sobre el StatefulSet, ejecuta el siguiente comando:

kubectl describe statefulset statefulset-name

en el que statefulset-name es el nombre de StatefulSet.

Para obtener información sobre un Pod específico, usa este comando:

kubectl describe pod pod-name

Para enumerar los PersistentVolumeClaims que se crearon, ejecuta el siguiente comando:

kubectl get pvc

El resultado es similar al siguiente:

NAME                            STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
statefulset-name-pvc-name-0     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800002   1G         RWO            standard        9s
statefulset-name-pvc-name-1     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800003   1G         RWO            standard        9s
statefulset-name-pvc-name-2     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800004   1G         RWO            standard        9s

Para obtener información sobre un PersistentVolumeClaim específico, ejecuta el siguiente comando:

kubectl describe pvc statefulset-name-pvc-name-0

Para obtener información sobre PersistentVolume en específico, ejecuta el siguiente comando:

kubectl describe pv pv-name

Console

A fin de inspeccionar StatefulSet, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Google Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada del menú.

El menú de cargas de trabajo ofrece varias opciones:

  • Para ver la configuración en vivo de StatefulSet, haz clic en YAML.
  • Para ver todos los eventos relacionados con StatefulSet, haz clic en Eventos.
  • Para ver el historial de revisión de StatefulSet, haz clic en Historial de revisión.

Actualizar StatefulSet

Existen varias formas de actualizar StatefulSets. El método declarativo común es kubectl apply. Para actualizar StatefulSet directamente desde tu shell o en un editor de tu preferencia, puedes usar kubectl edit. También puedes usar el editor YAML desde el menú Cargas de trabajo de GKE en Cloud Console.

Puedes implementar actualizaciones en la especificación de pods de StatefulSet, como su imagen, solicitud o uso de recursos, o configuración.

kubectl apply

Para actualizar StatefulSet, puedes aplicar un archivo de manifiesto nuevo o actualizado. Esto es útil para aplicar varios cambios en StatefulSet, como cuando escalas o quieres especificar una versión nueva de tu aplicación.

Para actualizar un StatefulSet, ejecuta el siguiente comando:

kubectl apply -f statefulset-file

En el comando anterior, statefulset-file es el archivo de manifiesto actualizado.

El comando kubectl apply aplica un archivo de manifiesto a un recurso. Si el recurso especificado no existe, el comando lo crea.

Para obtener más información sobre kubectl apply, consulta la documentación de referencia de kubectl.

Console

Para editar la configuración activa de StatefulSet, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Google Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo que desees.

  3. Haz clic en Editar.

  4. Usa el editor para realizar los cambios que desees en el objeto.

  5. Haz clic en Guardar.

Inspeccionar el lanzamiento de actualizaciones

kubectl

Para inspeccionar el lanzamiento de StatefulSet, ejecuta el siguiente comando:

kubectl rollout status statefulset statefulset-name

Para ver el historial de lanzamiento de StatefulSet, ejecuta el siguiente comando:

kubectl rollout history statefulset statefulset-name

Para deshacer un lanzamiento, ejecuta el siguiente comando:

kubectl rollout undo statefulset statefulset-name

Console

Para ver el historial de revisión de StatefulSet, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Google Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada del menú.

  3. Haz clic en el Historial de revisión.

  4. Selecciona la revisión que desees.

Actualiza estrategias

El campo updateStrategy de StatefulSet te permite configurar y, además, inhabilitar las actualizaciones progresivas automatizadas para contenedores, etiquetas, límites o solicitudes de recursos, y anotaciones destinadas a los pods en un StatefulSet.

Puedes obtener más información sobre las estrategias de actualización para StatefulSets en la documentación de Kubernetes.

Escala StatefulSet

kubectl

kubectl scale se puede usar en cualquier momento para escalar StatefulSet.

Para escalar de forma manual un StatefulSet, ejecuta el comando siguiente:

kubectl scale statefulset statefulset-name --replicas number-of-replicas

en el que number-of-replicas es la cantidad de pods replicados que deseas.

Console

Para escalar StatefulSet, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Google Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada del menú.

  3. Haz clic en Acciones, y luego en Escalar.

  4. En el campo Réplicas, ingresa la cantidad de réplicas deseadas.

  5. Haz clic en Escalar.

Borrar StatefulSet

kubectl

Para borrar StatefulSet, ejecuta el siguiente comando:

kubectl delete statefulset statefulset-name

Console

Para borrar un StatefulSet, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Google Console.

    Visitar el menú Cargas de trabajo

  2. En el menú, selecciona la carga de trabajo deseada.

  3. Haz clic en Borrar.

  4. Haz clic en Borrar en el menú de diálogo de confirmación.

Próximos pasos