Einsteigerleitfaden zu Kubernetes Statefulsets

StatefulSets sind API-Objekte in Kubernetes, die zur Verwaltung zustandsbehafteter Anwendungen verwendet werden. In Kubernetes gibt es zwei Arten von Anwendungen: Stateful-Anwendungen und Stateless-Anwendungen. Es gibt zwei Möglichkeiten, diese Anwendungen bereitzustellen:

• Bereitstellung (für zustandslose Anwendungen)
• StatefulSets (für zustandsbehaftete Anwendungen)

Was sind Stateful Applications?

Die Anwendungen, die einen dauerhaften Zustand oder Daten aufrechterhalten, werden als zustandsbehaftete Anwendungen bezeichnet. Das Hauptmerkmal, das sie von zustandslosen Anwendungen unterscheidet, besteht darin, dass diese Anwendungen nicht auf die lokale Speicherung von Daten angewiesen sind und nicht jede Anfrage als unabhängig behandeln. Sie verwalten Daten zwischen Interaktionen. Manchmal stellen zustandslose Anwendungen eine Verbindung zur zustandsbehafteten Anwendung her, um die Anfragen an eine Datenbank weiterzuleiten.

Was sind staatenlose Anwendungen?

Die Anwendungen, die lokal keinen dauerhaften Zustand oder Daten beibehalten, werden als zustandslose Anwendungen bezeichnet. In zustandslosen Anwendungen wird jede Anfrage oder Interaktion unabhängig behandelt. Diese Anwendungen sind so konzipiert, dass sie hoch skalierbar, einfach zu verwalten und fehlertolerant sind, da sie im Gegensatz zu Stateful-Anwendungen keine vergangenen Interaktionen oder Anfragen nachverfolgen müssen.

Zustandslose Anwendungen werden mithilfe der Bereitstellungskomponente bereitgestellt. Die Bereitstellung ist eine Abstraktion von Pods und ermöglicht Ihnen die Replikation der Anwendung, d. h. die Ausführung auf 1, 5, 10 oder n identischen Pods derselben zustandslosen Anwendung.

Was sind StatefulSets?

Im einfachsten Sinne handelt es sich bei StatefulSets um Kubernetes-Komponenten, die speziell für zustandsbehaftete Anwendungen verwendet werden. Hierbei handelt es sich um Workload-API-Objekte, die zur Verwaltung zustandsbehafteter Anwendungen verwendet werden. Sie verwalten die Bereitstellung und Skalierung einer Reihe von Pods (Erstellen oder Löschen weiterer Replikate), und StatefulSets sind auch für die Reihenfolge und Einzigartigkeit dieser Pods verantwortlich. StatefulSet wurde in der Kubernetes-Version 1.9 veröffentlicht.

StatefulSets stellen den Satz von Pods mit unterschiedlichen (eindeutigen), dauerhaften Identitäten und elastischen Hostnamen (stabil) dar. Dadurch können Sie sich auf die Reihenfolge der Skalierung und Bereitstellung verlassen. Bevor Sie StatefulSets verstehen, müssen Sie die Kubernetes-Bereitstellung verstehen.

Hier ist ein Beispiel für ein StatefulSet mit dem Namen 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

Wann StatefulSets verwendet werden sollten

StatefulSets in Kubernetes eignen sich ideal für die Bereitstellung zustandsbehafteter Anwendungen, die stabile, eindeutige Netzwerkkennungen, dauerhaften Speicher sowie eine geordnete, ordnungsgemäße Bereitstellung und Skalierung erfordern. Sie eignen sich für Anwendungen wie Datenbanken, Schlüsselwertspeicher und Messaging-Warteschlangen, die eine konsistente Identität und Speicherung erfordern.

Beispiel für zustandsbehaftete und zustandslose Anwendungen

Stellen Sie sich eine node.js-Anwendung vor, die mit einer MongoDB-Datenbank verbunden ist. Wenn eine Anfrage bei der node.js-Anwendung eingeht, verarbeitet sie die Anfrage unabhängig und ist dazu nicht auf vorherige Daten angewiesen. Es verarbeitet die Anfrage basierend auf der Nutzlast in der Anfrage selbst. Diese node.js-Anwendung ist ein Beispiel für eine zustandslose Anwendung. Jetzt aktualisiert die Anfrage entweder einige Daten in der Datenbank oder fragt einige Daten aus der Datenbank ab. Wenn node.js diese Anfrage an MongoDB weiterleitet, aktualisiert MongoDB die Daten basierend auf dem vorherigen Status der Daten oder fragt die Daten aus seinem Speicher ab. Für jede Anfrage muss es Daten verarbeiten und hängt davon ab, dass die aktuellsten Daten oder der aktuellste Status verfügbar sind, während node.js nur ein Pass-Through für Datenaktualisierungen oder -abfragen ist und lediglich Code verarbeitet. Daher sollte die node.js-Anwendung eine zustandslose Anwendung sein, während die MongoDB-Anwendung eine zustandsbehaftete Anwendung sein muss.

Manchmal stellen zustandslose Anwendungen eine Verbindung zur zustandsbehafteten Anwendung her, um die Anforderungen an eine Datenbank weiterzuleiten. Dies ist ein gutes Beispiel für eine Weiterleitungsanforderung einer zustandslosen Anwendung an eine zustandsbehaftete Anwendung.

So erstellen Sie ein StatefulSet in Kubernetes

Hier finden Sie eine Schritt-für-Schritt-Anleitung zur Verwendung von StatefulSets und einigen grundlegenden Vorgängen für StatefulSets.

Erstellen Sie eine Nginx StatefulSet-Anwendung

Schritt 1. Erstellen Sie eine StatefulSet-Datei. Sie können dies tun, indem Sie den folgenden Befehl eingeben:

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

Schritt 2. Öffnen Sie diese Datei in einem Code-Editor und schreiben Sie den folgenden Code hinein:

touch example-statefulset.yaml

Schritt 3. Jetzt müssen wir eine Servicedatei und eine PersistentVolumeClaim-Datei erstellen.

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

Erstellen Sie einen Dienst für die StatefulSet-Anwendung

Schritt 4. Geben Sie den folgenden Code in die Servicedatei ein:

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

Erstellen Sie einen PersistentVolumeClaim für die Anwendung

Schritt 5. Geben Sie den folgenden Code in die PersistentVolumeClaim-Datei ein:

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

Jetzt können wir diese Änderungen anwenden.

Schritt 6. Geben Sie den folgenden Befehl in Ihr Terminal ein, um das gfg-example-statefulset zu erstellen:

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

Dadurch wird unser gfg-example-statefulset erstellt, Sie erhalten ein ähnliches Ergebnis:

Wenn wir jetzt unsere StatefulSets in unserem Terminal mit dem Befehl durchsuchen

kubectl create -f example-statefulset.yaml

Wir finden unser gfg-example-statefulset in der Liste.

Schritt 7. Geben Sie den folgenden Befehl in Ihr Terminal ein, um den gfg-example-service zu erstellen.

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

Dadurch wird ein Dienst mit dem Namen „gfg-example-service“ erstellt

Schritt 8. Lassen Sie uns unsere Pods und Dienste überprüfen. Um die Liste der Pods zu erhalten, geben Sie den folgenden Befehl in Ihr Terminal ein:

touch example-statefulset.yaml

Sie erhalten die Liste der drei gfg-Pods, die wir erstellen, indem wir drei Replikate in der Datei example-stateful-set.yaml definieren. Sie erhalten eine ähnliche Ausgabe:

Um die Liste der Dienste zu überprüfen, geben Sie den folgenden Befehl in Ihr Terminal ein:

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

Dadurch erhalten Sie eine ähnliche Ausgabe:

Einige Operationen auf StatefulSets

Hinzufügen eines StatefulSets: Um ein StatefulSet zu Ihrem Kubernetes-Cluster hinzuzufügen, verwenden Sie den Befehl kubectl create -f [StatefulSet-Dateiname] und ersetzen Sie dabei [StatefulSet-Dateiname] durch den Namen Ihrer StatefulSet-Manifestdatei.

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

Löschen eines StatefulSets: Um ein StatefulSet in Kubernetes zu löschen, können Sie den Befehl kubectl delete statefulset [name] verwenden, wobei [name] der Name des gewünschten StatefulSets ist löschen.

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

Bearbeiten eines StatefulSets: Mit dem Befehl kubectl edit statefulset [name] können Sie die Konfiguration eines StatefulSets direkt über die Befehlszeile ändern, indem Sie einen Editor öffnen.

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

Skalierung von Replikaten: Der Befehl kubectl scale skaliert die Anzahl der Replikate in einem StatefulSet mit dem Namen [StatefulSet-Name] auf die angegebene [Anzahl der Replikate].

kubectl create -f example-statefulset.yaml

Schritt 9. Jetzt skalieren wir unsere Pods und prüfen, ob es funktioniert! Um die Pods auf 6 Pods zu skalieren, geben Sie den folgenden Befehl ein:

kubectl get statefulsets

Dadurch werden 3 weitere Pods erstellt und die Anzahl der Pods beträgt jetzt 6. Um eine Liste der Pods zu erhalten, geben Sie den folgenden Befehl ein:

kubectl apply -f example-service.yaml

Sie erhalten eine ähnliche Ausgabe:

Schritt 10. Nun skalieren wir die Pods auf 3 herunter. Geben Sie dazu denselben Befehl ein, ändern Sie einfach die Anzahl der Replikate wieder auf 3:

kubectl get pods

Jetzt überprüfen wir die Liste der Pods nach

kubectl get services

Sie werden sehen, dass nur 3 Pods ausgeführt werden:

Auf diese Weise können wir StatefulSets erstellen, sie vergrößern und dann auch verkleinern. Stellen Sie sicher, dass Sie das StatefulSet und den Dienst löschen, bevor Sie das Terminal schließen. Weitere Befehle von kubectl finden Sie im Kubectl Command Cheat Sheet.

Wie funktionieren zustandsbehaftete Anwendungen?

In zustandsbehafteten Anwendungen wie MySQL können mehrere Pods nicht gleichzeitig Daten lesen und schreiben, um Dateninkonsistenzen zu vermeiden.
Ein Pod ist als Master-Pod bestimmt und für das Schreiben und Ändern von Daten verantwortlich, während andere als Slave-Pods bestimmt sind und nur Daten lesen dürfen.
Jeder Pod verfügt über eine eigene Replik des Datenspeichers, wodurch Datenisolation und Unabhängigkeit gewährleistet werden.
Synchronisierungsmechanismen werden eingesetzt, um sicherzustellen, dass alle Pods den gleichen Datenstatus haben, wobei Slave-Pods ihren Datenspeicher aktualisieren, wenn der Master-Pod Daten ändert.
Eine kontinuierliche Synchronisierung ist erforderlich, um die Datenkonsistenz zwischen allen Pods in den zustandsbehafteten Anwendungen aufrechtzuerhalten.

Beispiel:
Nehmen wir an, wir haben einen Master- und zwei Slave-Pods von MySQL. Was passiert nun, wenn ein neues Pod-Replikat dem bestehenden Setup beitritt? Denn jetzt muss dieser neue Pod auch seinen eigenen Speicher erstellen und sich um die Synchronisierung kümmern. Was passiert, ist, dass er zuerst die Daten vom vorherigen Pod klont und dann mit der kontinuierlichen Synchronisierung beginnt, um auf Aktualisierungen durch den Master-Pod zu warten. da jeder Pod über einen eigenen Datenspeicher (persistentes Volume) verfügt, der durch einen eigenen physischen Speicher gesichert wird, der die synchronisierten Daten und den Status des Pods enthält. Jeder Pod verfügt über einen eigenen Status, der Informationen darüber enthält, ob es sich um einen Master-Pod oder einen Slave-Pod handelt, sowie weitere individuelle Merkmale. All dies wird im eigenen Speicher der Pods gespeichert. Wenn also ein Pod stirbt und ersetzt wird, wird der persistente Pod ersetzt. Identifikatoren stellen sicher, dass das Speichervolume wieder mit dem Ersatz-Pod verbunden wird. Auf diese Weise wird auch bei einem Clusterabsturz sichergestellt, dass keine Daten verloren gehen.

Abschluss

In diesem Artikel haben wir die Verwendung von Kubernetes StatefulSets besprochen. StatefulSets sind Kubenetes-Komponenten, die zur Bereitstellung zustandsbehafteter Anwendungen verwendet werden. Zustandsbehaftete Anwendungen sind solche Anwendungen, die eine Form von persistentem Zustand oder Daten aufrechterhalten. Ein gutes Beispiel wäre jede Anwendung mit einer Datenbank. Wir haben darüber gesprochen, wie man eine zustandsbehaftete Anwendung mithilfe von StatefulSets bereitstellt. Danach haben wir besprochen, wie Stateful-Anwendungen funktionieren? Am Ende haben wir den Unterschied zwischen StatefulSet und Deployment besprochen, der sich im Wesentlichen um den Punkt bewegt, dass Deployment zur Bereitstellung zustandsloser Anwendungen und StatefulSets zur Bereitstellung zustandsbehafteter Anwendungen verwendet werden. Wir beenden diesen Artikel mit der Behandlung einiger häufig gestellter Fragen.

Kubernetes StatefulSets – FAQs

Wie erhöhe ich die Volume-Größe in Kubernetes?

Um die Volume-Größe in Kubernetes zu erhöhen, müssen Sie die PersistentVolumeClaim (PVC)-Spezifikation ändern, indem Sie die Speichergröße ändern. Anschließend stellt Kubernetes automatisch zusätzlichen Speicher bereit, um die neue Größenanforderung zu erfüllen, sofern die zugrunde liegende Speicherklasse die dynamische Bereitstellung unterstützt.

Wann sollte hostPath in Kubernetes verwendet werden?

Der Datenträgertyp „hostPath“ in Kubernetes eignet sich für Szenarien, in denen Sie direkt innerhalb eines Pods auf Dateien oder Verzeichnisse im Dateisystem des Knotens zugreifen müssen. Es wird häufig für den Zugriff auf knotenspezifische Ressourcen oder für die gemeinsame Nutzung von Daten zwischen Containern auf demselben Knoten verwendet.

Was ist der Unterschied zwischen PVC StatefulSet und der Bereitstellung?

PersistentVolumeClaims (PVCs) in StatefulSets werden verwendet, um stabilen, dauerhaften Speicher für einzelne Pods bereitzustellen und so die Datenpersistenz und Identität über Pod-Neustarts hinweg sicherzustellen. Im Gegensatz dazu nutzen Bereitstellungen typischerweise kurzlebige Volumes, die für zustandslose Anwendungen geeignet sind, bei denen Datenpersistenz nicht erforderlich ist.

Können wir eine zustandslose Anwendung mithilfe von StatefulSets bereitstellen?

Obwohl technisch möglich, wird die Bereitstellung zustandsloser Anwendungen mithilfe von StatefulSets nicht empfohlen. StatefulSets wurden speziell für zustandsbehaftete Anwendungen entwickelt, die stabile, eindeutige Kennungen und dauerhaften Speicher erfordern. Die Bereitstellung zustandsloser Anwendungen mit StatefulSets kann zu unnötiger Komplexität und Ressourcenaufwand führen.

Ist staatenlos besser als staatsbehaftet?

Das hängt von den spezifischen Anforderungen der Anwendung ab. Zustandslose Anwendungen lassen sich einfacher verwalten und horizontal skalieren, während zustandsbehaftete Anwendungen die Datenintegrität wahren und sich besser für bestimmte Arbeitslasten wie Datenbanken oder Messaging-Systeme eignen.

Das obige ist der detaillierte Inhalt vonEinsteigerleitfaden zu Kubernetes Statefulsets. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!