Guide du débutant sur les Statefulsets Kubernetes

StatefulSets sont des objets API dans Kubernetes qui sont utilisés pour gérer les applications avec état. Il existe deux types d'applications dans Kubernetes : les applications avec état et les applications sans état. Il existe deux manières de déployer ces applications :

• Déploiement (pour les applications sans état)
• StatefulSets (pour les applications avec état)

Que sont les applications avec état ?

Les applications qui conservent une certaine forme d'état ou de données persistantes sont appelées applications avec état. La principale caractéristique qui les différencie des applications sans état est que ces applications ne reposent pas sur le stockage de données localement et ne traitent pas chaque requête comme indépendante. Ils gèrent les données entre les interactions. Parfois, les applications sans état se connectent à l'application avec état pour transmettre les requêtes vers une base de données.

Que sont les demandes apatrides ?

Les applications qui ne conservent aucune forme d'état ou de données persistantes localement sont appelées applications sans état. Dans les applications sans état, chaque demande ou interaction est traitée indépendamment. Ces applications sont conçues pour être hautement évolutives, faciles à gérer et tolérantes aux pannes car, contrairement aux applications avec état, elles n'ont pas besoin de suivre les interactions ou les demandes passées.

Les applications sans état sont déployées à l'aide du composant de déploiement. Le déploiement est une abstraction de pods et vous permet de répliquer l'application, ce qui signifie qu'il vous permet d'exécuter sur 1, 5, 10 ou n pods identiques de la même application sans état.

Que sont les StatefulSets ?

En termes les plus simples, les StatefulSets sont un composant Kubernetes utilisé spécifiquement pour les applications avec état. Il s'agit d'objets API de charge de travail utilisés pour gérer les applications avec état. Ils gèrent le déploiement et la mise à l'échelle d'un ensemble de pods (en créant plus de répliques ou en les supprimant), et les StatefulSets sont également responsables de l'ordre et de l'unicité de ces pods. StatefulSet a été publié dans la version Kubernetes 1.9.

StatefulSets représentera l'ensemble des pods avec des identités différentes (uniques) persistantes et des noms d'hôtes élastiques (stables). Cela vous permet de vous assurer de l’ordre de la mise à l’échelle et des déploiements. Avant de comprendre StatefulSets, vous devez comprendre le déploiement de Kubernetes.

Voici un exemple de StatefulSet nommé web :

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 4
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: registry.k8s.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

Quand utiliser les StatefulSets

Les StatefulSets dans Kubernetes sont idéaux pour déployer des applications avec état qui nécessitent des identifiants réseau stables et uniques, un stockage persistant, ainsi qu'un déploiement et une mise à l'échelle ordonnés et gracieux. Ils conviennent aux applications telles que les bases de données, les magasins clé-valeur et les files d'attente de messagerie qui nécessitent une identité et un stockage cohérents.

Exemple d'applications avec et sans état

Considérez une application node.js connectée à une base de données MongoDB. Lorsqu'une requête parvient à l'application node.js, elle gère la requête de manière indépendante et ne dépend pas des données précédentes pour ce faire. Il gère la requête en fonction de la charge utile de la requête elle-même. Cette application node.js est un exemple d'application sans état. Désormais, la requête mettra à jour certaines données de la base de données ou interrogera certaines données de la base de données. Lorsque node.js transmet cette demande à MongoDB, MongoDB met à jour les données en fonction de l'état précédent des données ou interroge les données de leur stockage. Pour chaque requête, il doit gérer les données et cela dépend des données ou de l'état les plus à jour disponibles, tandis que node.js n'est qu'un intermédiaire pour les mises à jour ou les requêtes de données et traite simplement le code. Par conséquent, l'application node.js doit être une application sans état tandis que l'application MongoDB doit être une application avec état.

Parfois, les applications sans état se connectent à l'application avec état pour transmettre les requêtes vers une base de données. Il s'agit d'un bon exemple de demande de transfert d'application sans état vers une application avec état.

Comment créer un StatefulSet dans Kubernetes

Voici un tutoriel étape par étape sur la façon d'utiliser StatefulSets et quelques opérations de base sur StatefulSets.

Créer une application Nginx StatefulSet

Étape 1. Créez un fichier StatefulSet. vous pouvez le faire en entrant la commande suivante :

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 4
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: registry.k8s.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

Étape 2. Ouvrez ce fichier dans un éditeur de code et écrivez-y le code suivant :

touch example-statefulset.yaml

Étape 3. Nous devons maintenant créer un fichier de service et un fichier PersistentVolumeClaim.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: gfg-example-statefulset
  annotations:
    description: "This is an example statefulset"
spec:
  selector:
    matchLabels:
      app: nginx
  serviceName: "gfg-example-service"
  replicas: 3 # remember this, we will have 3 identical pods running
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
      volumes:
      - name: www
        persistentVolumeClaim:
          claimName: myclaim

Créer un service pour l'application StatefulSet

Étape 4. Entrez le code suivant dans le fichier de service :

touch example-service.yaml
touch example-persistentVolumeChain.yaml

Créer une PersistentVolumeClaim pour l'application

Étape 5. Entrez le code suivant dans le fichier PersistentVolumeClaim :

apiVersion: v1
kind: Service
metadata:
  name: gfg-example-service
  annotations:
    description: "this is an example service"
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx

Appliquons maintenant ces modifications.

Étape 6. Entrez la commande suivante dans votre terminal pour créer le gfg-example-statefulset :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: myclaim
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 8Gi # This means we are requesting for 8 GB of storage

Cela créera notre gfg-example-statefulset, vous obtiendrez un résultat similaire :

maintenant si nous recherchons nos StatefulSets dans notre terminal par la commande

kubectl create -f example-statefulset.yaml

nous retrouverons notre gfg-example-statefulset dans la liste.

Étape 7. Entrez la commande suivante dans votre terminal pour créer le gfg-example-service.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 4
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: registry.k8s.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

cela créera un service avec le nom "gfg-example-service"

Étape 8. Vérifions nos pods et services, pour obtenir la liste des pods, entrez la commande suivante dans votre terminal :

touch example-statefulset.yaml

Vous obtiendrez la liste des trois gfg-pods que nous créons en définissant trois répliques dans le fichier example-stateful-set.yaml. Vous obtiendrez un résultat similaire :

pour consulter la liste des services, saisissez la commande suivante dans votre terminal :

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: gfg-example-statefulset
  annotations:
    description: "This is an example statefulset"
spec:
  selector:
    matchLabels:
      app: nginx
  serviceName: "gfg-example-service"
  replicas: 3 # remember this, we will have 3 identical pods running
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
      volumes:
      - name: www
        persistentVolumeClaim:
          claimName: myclaim

Cela vous donnera un résultat similaire :

Quelques opérations sur StatefulSets

Ajout d'un StatefulSet : Pour ajouter un StatefulSet à votre cluster Kubernetes, utilisez la commande kubectl create -f [StatefulSet file name], en remplaçant [StatefulSet file name] par le nom de votre fichier manifeste StatefulSet.

touch example-service.yaml
touch example-persistentVolumeChain.yaml

Suppression d'un StatefulSet : Pour supprimer un StatefulSet dans Kubernetes, vous pouvez utiliser la commande kubectl delete statefulset [name], où [name] est le nom du StatefulSet souhaité à supprimer.

apiVersion: v1
kind: Service
metadata:
  name: gfg-example-service
  annotations:
    description: "this is an example service"
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx

Modifier un StatefulSet : La commande kubectl edit statefulset [name] permet de modifier la configuration d'un StatefulSet directement depuis la ligne de commande en ouvrant un éditeur.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: myclaim
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 8Gi # This means we are requesting for 8 GB of storage

Mise à l'échelle des répliques : La commande kubectl scale met à l'échelle le nombre de répliques dans un StatefulSet nommé [StatefulSet name] au [Nombre de répliques] spécifié.

kubectl create -f example-statefulset.yaml

Étape 9. Agrandissons maintenant nos pods et vérifions si cela fonctionne ! pour faire évoluer les pods jusqu'à 6 pods, entrez la commande suivante :

kubectl get statefulsets

Cela créera 3 pods supplémentaires et le nombre de pods est désormais de 6, pour obtenir la liste des pods, entrez la commande suivante :

kubectl apply -f example-service.yaml

Vous obtiendrez un résultat similaire :

Étape 10. Maintenant, réduisons les pods à 3, pour cela, entrez la même commande, modifiez simplement le nombre de répliques à 3 :

kubectl get pods

maintenant si on vérifie la liste des pods par

kubectl get services

vous ne verrez que 3 pods en cours d'exécution :

De cette façon, nous pouvons créer des StatefulSets, les augmenter, puis les réduire également. Assurez-vous de supprimer StatefulSet et le service avant de fermer le terminal. Pour en savoir plus sur les commandes de kubectl, reportez-vous à l'aide-mémoire des commandes Kubectl.

Comment fonctionnent les applications avec état ?

Dans les applications avec état comme MySQL, plusieurs pods ne peuvent pas lire et écrire simultanément des données pour éviter toute incohérence des données.
Un pod est désigné comme pod maître, responsable de l'écriture et de la modification des données, tandis que d'autres sont désignés comme pods esclaves, uniquement autorisés à lire les données.
Chaque pod possède sa propre réplique du stockage de données, garantissant l'isolation et l'indépendance des données.
Des mécanismes de synchronisation sont utilisés pour garantir que tous les pods ont le même état de données, les pods esclaves mettant à jour leur stockage de données lorsque le pod maître modifie les données.
Une synchronisation continue est nécessaire pour maintenir la cohérence des données entre tous les pods des applications avec état.

Exemple :
Disons que nous avons un pod maître et deux pods esclaves de MySQL. Maintenant, que se passe-t-il lorsqu'une nouvelle réplique de pod rejoint la configuration existante ? car maintenant, ce nouveau pod doit également créer son propre stockage et prendre soin de le synchroniser. Ce qui se passe, c'est qu'il clone d'abord les données du pod précédent, puis il démarre la synchronisation continue pour écouter les mises à jour du pod maître. puisque chaque pod possède son propre stockage de données (volume persistant) qui est sauvegardé par son propre stockage physique qui comprend les données synchronisées et l'état du pod. Chaque pod a son propre état qui contient des informations indiquant s'il s'agit d'un pod maître ou d'un pod esclave ainsi que d'autres caractéristiques individuelles. Tout cela est stocké dans le propre stockage des pods. Par conséquent, lorsqu'un pod meurt et est remplacé, le pod persistant. Les identifiants garantissent que le volume de stockage est réattaché au pod de remplacement. De cette façon, même si le cluster tombe en panne, on s'assure que les données ne seront pas perdues.

Conclusion

Dans cet article, nous avons expliqué comment utiliser Kubernetes StatefulSets. Les StatefulSets sont des composants Kubenetes utilisés pour déployer des applications avec état. Les applications avec état sont les applications qui conservent une certaine forme d'état ou de données persistantes. Un bon exemple serait n’importe quelle application dotée d’une base de données. Nous avons expliqué comment déployer une application avec état à l'aide de StatefulSets. Après cela, nous avons discuté du fonctionnement des applications avec état ? À la fin, nous avons discuté de la différence entre StatefulSet et le déploiement, qui se déplace essentiellement autour du point où le déploiement est utilisé pour déployer une application sans état et les StatefulSets sont utilisés pour déployer des applications avec état. Nous terminerons cet article en abordant quelques FAQ.

Kubernetes StatefulSets - FAQ

Comment augmenter la taille du volume dans Kubernetes ?

Pour augmenter la taille du volume dans Kubernetes, vous devez modifier la spécification PersistentVolumeClaim (PVC) en changeant la taille de stockage. Ensuite, Kubernetes provisionne automatiquement un stockage supplémentaire pour répondre à la nouvelle exigence de taille, à condition que la classe de stockage sous-jacente prenne en charge le provisionnement dynamique.

Quand utiliser hostPath dans Kubernetes ?

Le type de volume hostPath dans Kubernetes convient aux scénarios dans lesquels vous devez accéder à des fichiers ou des répertoires sur le système de fichiers du nœud directement dans un pod. Il est couramment utilisé pour accéder à des ressources spécifiques à un nœud ou pour partager des données entre des conteneurs sur le même nœud.

Quelle est la différence entre PVC StatefulSet et le déploiement ?

Les PersistentVolumeClaims (PVC) dans StatefulSets sont utilisés pour fournir un stockage stable et persistant pour les pods individuels, garantissant ainsi la persistance et l'identité des données lors des redémarrages des pods. En revanche, les déploiements utilisent généralement des volumes éphémères, adaptés aux applications sans état où la persistance des données n'est pas une exigence.

Pouvons-nous déployer une application sans état à l’aide de StatefulSets ?

Bien que techniquement possible, il n'est pas recommandé de déployer des applications sans état à l'aide de StatefulSets. Les StatefulSets sont spécialement conçus pour les applications avec état nécessitant des identifiants stables et uniques et un stockage persistant. Le déploiement d'applications sans état avec StatefulSets peut introduire une complexité et une surcharge de ressources inutiles.

L'apatride est-il préférable à l'apatride ?

Cela dépend des exigences spécifiques de l'application. Les applications sans état sont plus simples à gérer et à évoluer horizontalement, tandis que les applications avec état préservent l'intégrité des données et sont mieux adaptées à certaines charges de travail comme les bases de données ou les systèmes de messagerie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!