StatefulSet

Cette page décrit les objets StatefulSet de Kubernetes et leur utilisation dans Google Kubernetes Engine (GKE). Vous pouvez également apprendre à Déployer une application avec état.

Présentation

Un objet StatefulSet représente un ensemble de pods dotés d'identités uniques et persistantes et de noms d'hôtes stables que GKE conserve, quel que soit l'endroit où ils sont planifiés. Les informations d'état et autres données résilientes relatives à un pod d'un objet StatefulSet donné sont conservées dans un stockage sur disque persistant associé à l'objet StatefulSet.

Les StatefulSets utilisent un index ordinal pour l'identité et l'ordre de leurs pods. Par défaut, les pods StatefulSet sont déployés en ordre séquentiel et arrêtés en ordre inverse. Par exemple, un StatefulSet nommé web comporte des pods nommés web-0, web-1 et web-2. Lorsque la spécification de pod web est modifiée, ses pods sont arrêtés et recréés de manière ordonnée. Dans cet exemple, le pod web-2 s'arrête en premier, puis web-1 s'arrête, et ainsi de suite. Vous pouvez également spécifier le champ podManagementPolicy: Parallel pour qu'un StatefulSet lance ou arrête tous ses pods en parallèle plutôt que d'attendre que chaque pod atteigne l'état En cours d'exécution et prêt ou soit arrêté avant de lancer ou d'arrêter un autre pod.

Les StatefulSets utilisent un modèle de pod qui contient une spécification pour les pods correspondants. La spécification de pod détermine la configuration de chaque pod : quelles applications doivent s'exécuter dans ses conteneurs, quels volumes il doit installer, ses libellés et ses sélecteurs, etc.

Schémas d'utilisation

Les objets StatefulSet sont conçus pour déployer des applications avec état et des applications en cluster qui enregistrent des données sur un espace de stockage persistant, comme des disques persistants Compute Engine. Les objets StatefulSet conviennent au déploiement de Kafka, MySQL, Redis, ZooKeeper ainsi que d'autres applications nécessitant des identités uniques et persistantes, et des noms d'hôtes stables. Pour les applications sans état, utilisez les objets Déploiement.

Créer des StatefulSets

Vous pouvez créer un StatefulSet à l'aide de kubectl apply.

Une fois créé, le StatefulSet garantit que le nombre souhaité de pods est en cours d'exécution et que ces pods sont disponibles en permanence. Le StatefulSet remplace automatiquement les pods qui échouent ou sont évincés de leurs nœuds et associe automatiquement de nouveaux pods aux ressources de stockage, aux demandes de ressources et aux limites, ainsi qu'aux autres éléments de configuration définis dans la spécification de pod du StatefulSet.

Voici un exemple de fichier manifeste d'un Service et d'un StatefulSet :

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 # Label selector that determines which Pods belong to the StatefulSet
                 # Must match spec: template: metadata: labels
  serviceName: "nginx"
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx # Pod template's label selector
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: k8s.gcr.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Dans cet exemple :

  • Un objet Service nommé nginx est créé, comme indiqué par le champ metadata: name. L'objet Service cible une application appelée nginx, définie par les champs labels: app: nginx et selector: app: nginx. Le Service exploite le port 80 et le nomme web. Ce service contrôle le domaine de réseau et achemine le trafic Internet vers l'application en conteneur déployée par l'objet StatefulSet.
  • Un StatefulSet nommé web est créé avec trois pods répliqués (replicas: 3).
  • Le modèle de pod (spec: template) indique que ses pods sont associés au libellé app: nginx.
  • La spécification de pod (template: spec) indique que les pods de l'objet StatefulSet exécutent un conteneur, nginx, qui exécute l'image nginx-slim dans sa version 0.8. L'image du conteneur est hébergée par Container Registry.
  • La spécification de pod utilise le port web ouvert par le Service.
  • template: spec: volumeMounts spécifie un chemin mountPath, nommé www. Le mountPath est le chemin, au sein du conteneur, sur lequel un volume de stockage doit être installé.
  • L'objet StatefulSet provisionne une ressource PersistentVolumeClaim, nommée www et dotée de 1 Go d'espace de stockage.

En résumé, la spécification de pod contient les instructions suivantes :

  • Attribuer le libellé app: nginx à chaque pod.
  • Dans chaque pod, exécuter un conteneur nommé nginx.
  • Exécuter l'image nginx-slim dans sa version 0.8.
  • Indiquer aux pods qu'ils doivent utiliser le port 80.
  • Enregistrer les données sur le chemin d'accès à l'installation.

Pour plus d'informations sur les configurations StatefulSet, reportez-vous à la documentation de référence de l'API StatefulSet.

.

Mettre à jour les StatefulSets

Vous pouvez mettre à jour un StatefulSet en modifiant sa spécification de pod, qui inclut les images et les volumes de son conteneur. Vous pouvez également mettre à jour les demandes de ressources, les limites, les libellés et les annotations de l'objet. Pour mettre à jour un StatefulSet, vous pouvez utiliser kubectl, l'API Kubernetes ou le menu des charges de travail GKE dans Google Cloud Console.

Pour déterminer le mode de gestion des mises à jour, les objets StatefulSet utilisent une stratégie de mise à jour définie dans spec: updateStrategy. Il existe deux stratégies, OnDelete et RollingUpdate :

  • OnDelete ne supprime pas ni ne recrée automatiquement les pods lorsque la configuration de l'objet est modifiée. Au lieu de cela, les pods doivent être supprimés manuellement pour forcer le contrôleur à créer des pods qui intègrent vos modifications.
  • RollingUpdate supprime et recrée automatiquement les pods lorsque la configuration de l'objet est modifiée. Les nouveaux pods doivent atteindre l'état En cours d'exécution et prêt avant que leurs prédécesseurs ne soient supprimés. Avec cette stratégie, tout changement dans la spécification de pod déclenche automatiquement un redéploiement. C'est la stratégie de mise à jour par défaut pour les StatefulSets.

Les StatefulSets mettent à jour les pods en ordre séquentiel inverse. Vous pouvez surveiller le déploiement des mises à jour en exécutant la commande suivante :

kubectl rollout status statefulset statefulset-name

Partitionner les mises à jour progressives

Vous pouvez partitionner les mises à jour progressives. Le partitionnement est utile si vous souhaitez organiser une mise à jour, déployer un système de test, ou effectuer un déploiement progressif.

Lorsque vous partitionnez une mise à jour, tous les pods dont le numéro d'ordre est supérieur ou égal à la valeur de la partition sont mis à jour lorsque vous mettez à jour la spécification de pod du StatefulSet. Les pods dont le numéro d'ordre est inférieur à la valeur de la partition ne sont pas mis à jour et, même s'ils sont supprimés, ils sont recréés sur la base de la version précédente de la spécification. Si la valeur de la partition est supérieure au nombre d'instances dupliquées, les mises à jour ne sont pas propagées aux pods.

Étapes suivantes