Panduan pemula untuk Kubernetes Statefulsets

StatefulSets ialah objek API dalam Kubernetes yang digunakan untuk mengurus aplikasi stateful. Terdapat dua jenis aplikasi dalam Kubernetes, aplikasi Stateful dan aplikasi tanpa kewarganegaraan. Terdapat dua cara untuk menggunakan aplikasi ini:

• Pengerahan (untuk aplikasi tanpa kewarganegaraan)
• StatefulSets (untuk aplikasi stateful)

Apakah Permohonan Bernegara?

Aplikasi yang mengekalkan beberapa bentuk keadaan atau data berterusan dipanggil aplikasi stateful. Ciri utama yang membezakannya daripada aplikasi tanpa kewarganegaraan ialah aplikasi ini tidak bergantung pada penyimpanan data secara setempat dan mereka tidak menganggap setiap permintaan sebagai bebas. Mereka menguruskan data antara interaksi. Kadangkala aplikasi tanpa kewarganegaraan bersambung ke aplikasi berstatus untuk memajukan permintaan ke pangkalan data.

Apakah Aplikasi Tanpa Kewarganegaraan?

Aplikasi yang tidak mengekalkan sebarang bentuk keadaan berterusan atau data secara setempat dipanggil aplikasi tanpa kewarganegaraan. Dalam aplikasi tanpa kewarganegaraan, setiap permintaan atau interaksi dilayan secara bebas. Aplikasi ini direka bentuk untuk berskala tinggi, mudah diurus dan tahan terhadap kesalahan kerana, tidak seperti aplikasi Stateful, mereka tidak perlu menjejaki interaksi atau permintaan yang lalu.

Aplikasi tanpa status digunakan menggunakan komponen penempatan. Deployment ialah abstraksi pod dan membolehkan anda meniru aplikasi, bermakna ia membolehkan anda menjalankan ke 1, 5, 10 atau n pod yang sama bagi aplikasi tanpa kewarganegaraan yang sama.

Apakah StatefulSets?

Dalam istilah paling mudah StatefulSets ialah komponen Kubernetes yang digunakan khusus untuk aplikasi stateful. Ini adalah objek API beban kerja yang digunakan untuk mengurus aplikasi stateful. Mereka menguruskan penggunaan dan penskalaan set Pod (Mencipta lebih banyak replika atau memadamkannya), dan StatefulSets juga bertanggungjawab ke atas susunan dan keunikan Pod ini. StatefulSet dikeluarkan dalam keluaran Kubernetes 1.9.

StatefulSets akan mewakili set pod dengan identiti berbeza (unik), berterusan dan nama hos anjal (stabil). Ia membuatkan anda yakin tentang susunan penskalaan dan penggunaan. Sebelum memahami StatefulSets, anda mesti memahami Deployment Kubernetes.

Berikut ialah contoh StatefulSet bernama 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

Bila hendak menggunakan StatefulSets

StatefulSets dalam Kubernetes adalah sesuai untuk menggunakan aplikasi stateful yang memerlukan pengecam rangkaian yang stabil dan unik, storan yang berterusan dan penempatan dan penskalaan yang teratur dan anggun. Ia sesuai untuk aplikasi seperti pangkalan data, stor nilai kunci dan baris gilir pemesejan yang memerlukan identiti dan storan yang konsisten.

Contoh Permohonan Stateful dan Stateless

Pertimbangkan aplikasi node.js yang disambungkan ke pangkalan data MongoDB. Apabila permintaan datang ke aplikasi node.js, ia mengendalikan permintaan secara bebas dan tidak bergantung pada data sebelumnya untuk melakukannya. Ia mengendalikan permintaan berdasarkan muatan dalam permintaan itu sendiri. Aplikasi node.js ini ialah contoh aplikasi Stateless. Sekarang permintaan itu sama ada akan mengemas kini beberapa data dalam pangkalan data atau menanyakan beberapa data daripada pangkalan data. Apabila node.js memajukan permintaan itu kepada MongoDB, MongoDB mengemas kini data berdasarkan keadaan data sebelumnya atau menanyakan data daripada storannya. Untuk setiap permintaan, ia perlu mengendalikan data dan ia bergantung pada data atau keadaan paling terkini yang tersedia manakala node.js hanyalah laluan untuk kemas kini atau pertanyaan data dan ia hanya memproses kod. Oleh itu, aplikasi node.js hendaklah aplikasi tanpa kewarganegaraan manakala aplikasi MongoDB mestilah aplikasi berstatus.

Kadang-kadang aplikasi tanpa status bersambung ke aplikasi stateful untuk memajukan permintaan ke pangkalan data. Ini ialah contoh yang baik bagi permintaan pemajuan aplikasi tanpa kewarganegaraan kepada permohonan berstatus.

Cara Membuat StatefulSet dalam Kubernetes

Berikut ialah tutorial langkah demi langkah tentang cara menggunakan StatefulSets dan beberapa operasi asas pada StatefulSets.

Buat Aplikasi Nginx StatefulSet

Langkah 1. Cipta fail StatefulSet. anda boleh melakukannya dengan memasukkan arahan berikut:

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

Langkah 2. Buka fail ini dalam editor kod dan tulis kod berikut ke dalamnya:

touch example-statefulset.yaml

Langkah 3. Sekarang kita perlu mencipta fail perkhidmatan dan fail 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

Buat Perkhidmatan untuk Aplikasi StatefulSet

Langkah 4. Masukkan kod berikut ke dalam fail perkhidmatan:

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

Cipta PersistentVolumeClaim untuk Permohonan

Langkah 5. Masukkan kod berikut ke dalam fail 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

Sekarang mari gunakan perubahan ini.

Langkah 6. Masukkan arahan berikut dalam terminal anda untuk mencipta 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

Ini akan mencipta gfg-example-statefulset kami, anda akan mendapat hasil yang serupa:

sekarang jika kami mencari StatefulSets kami di terminal kami dengan arahan

kubectl create -f example-statefulset.yaml

kami akan menemui gfg-example-statefulset kami dalam senarai.

Langkah 7. Masukkan arahan berikut dalam terminal anda untuk mencipta 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

ini akan mencipta perkhidmatan dengan nama "gfg-example-service"

Langkah 8. Mari semak pod dan perkhidmatan kami, untuk mendapatkan senarai pod masukkan arahan berikut dalam terminal anda:

touch example-statefulset.yaml

Anda akan mendapat senarai tiga gfg- pod yang kami cipta walaupun mentakrifkan tiga replika dalam fail example-stateful-set.yaml. Anda akan mendapat output yang serupa:

untuk menyemak senarai perkhidmatan, masukkan arahan berikut dalam terminal anda:

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

Ini akan memberi anda output yang serupa:

Beberapa Operasi Pada StatefulSets

Menambah StatefulSet: Untuk menambah StatefulSet pada kelompok Kubernetes anda, gunakan perintah kubectl create -f [StatefulSet file name], menggantikan [StatefulSet file name] dengan nama daripada fail manifes StatefulSet anda.

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

Memadamkan StatefulSet: Untuk memadamkan StatefulSet dalam Kubernetes, anda boleh menggunakan perintah kubectl delete statefulset [name], dengan [name] ialah nama StatefulSet yang anda mahu untuk memadam.

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

Mengedit StatefulSet: Perintah kubectl edit statefulset [nama] membolehkan anda mengubah suai konfigurasi StatefulSet terus daripada baris arahan dengan membuka editor.

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

Penskalaan Replika: Perintah skala kubectl menskalakan bilangan replika dalam StatefulSet bernama [StatefulSet name] kepada [Bilangan replika] yang ditentukan.

kubectl create -f example-statefulset.yaml

Langkah 9. Sekarang mari kita tingkatkan pod kami dan semak sama ada ia berfungsi! untuk meningkatkan pod kepada 6 pod, masukkan arahan berikut:

kubectl get statefulsets

Ini akan mencipta 3 lagi pod dan bilangan pod kini 6, untuk mendapatkan senarai pod masukkan arahan berikut:

kubectl apply -f example-service.yaml

Anda akan mendapat output yang serupa:

Langkah 10. Sekarang mari kita kecilkan pod kepada 3, untuk itu masukkan arahan yang sama, cuma tukar bilangan replika kembali kepada 3:

kubectl get pods

sekarang jika kita menyemak senarai pod oleh

kubectl get services

anda akan melihat hanya 3 pod berjalan:

Dengan cara ini kita boleh mencipta StatefulSets, mempertingkatkannya dan kemudian mengecilkannya juga. Pastikan untuk memadamkan StatefulSet dan perkhidmatan sebelum menutup terminal. Untuk mengetahui lebih banyak arahan kubectl rujuk Lembaran Cheat Perintah Kubectl.

Bagaimana Aplikasi Stateful Berfungsi?

Dalam aplikasi stateful seperti MySQL, beberapa pod tidak boleh membaca dan menulis data secara serentak untuk mengelakkan ketidakkonsistenan data.
Satu pod ditetapkan sebagai pod induk, bertanggungjawab untuk menulis dan menukar data, manakala pod lain ditetapkan sebagai pod hamba, hanya dibenarkan membaca data.
Setiap pod mempunyai replika storan data sendiri, memastikan pengasingan dan kebebasan data.
Mekanisme penyegerakan digunakan untuk memastikan semua pod mempunyai keadaan data yang sama, dengan pod hamba mengemas kini storan datanya apabila pod induk menukar data.
Penyegerakan berterusan diperlukan untuk mengekalkan ketekalan data antara semua pod dalam aplikasi stateful.

Contoh:
Katakan kita mempunyai satu induk dan dua pod hamba MySQL. Sekarang apa yang berlaku apabila replika pod baharu menyertai persediaan sedia ada? kerana sekarang pod baharu itu juga perlu mencipta storannya sendiri dan menjaga penyegerakannya, apa yang berlaku ialah ia mula-mula mengklonkan data daripada pod sebelumnya dan kemudian ia memulakan penyegerakan berterusan untuk mendengar sebarang kemas kini oleh pod induk. kerana setiap pod mempunyai storan data sendiri (volume berterusan) yang disandarkan oleh storan fizikalnya sendiri yang merangkumi data disegerakkan dan keadaan pod. Setiap pod mempunyai keadaan sendiri yang mempunyai maklumat tentang sama ada pod induk atau pod hamba dan ciri individu lain. Semua ini disimpan dalam storan pod sendiri. Oleh itu apabila pod mati dan diganti pod berterusan. Pengecam memastikan volum storan disambungkan semula pada pod gantian. Dengan cara ini walaupun gugusan ranap, ia memastikan data tidak hilang.

Kesimpulan

Dalam artikel ini kami membincangkan tentang cara menggunakan Kubernetes StatefulSets. StatefulSets ialah komponen Kubenetes yang digunakan untuk menggunakan aplikasi stateful. Aplikasi stateful ialah aplikasi yang mengekalkan beberapa bentuk keadaan atau data yang berterusan. Contoh yang baik ialah mana-mana aplikasi dengan pangkalan data. Kami membincangkan tentang cara untuk menggunakan aplikasi stateful menggunakan StatefulSets. Selepas itu kita membincangkan bagaimana aplikasi Stateful berfungsi? Pada akhirnya kami membincangkan perbezaan antara StatefulSet dan deployment yang pada asasnya bergerak di sekitar titik yang deployment digunakan untuk menggunakan stateless application dan StatefulSets digunakan untuk menggunakan statefull applications. Kami akan menamatkan artikel ini dengan menangani beberapa Soalan Lazim.

Kubernetes StatefulSets - Soalan Lazim

Bagaimanakah cara saya meningkatkan saiz volum dalam Kubernetes?

Untuk meningkatkan saiz volum dalam Kubernetes, anda perlu mengubah suai spesifikasi PersistentVolumeClaim (PVC) dengan menukar saiz storan. Kemudian, Kubernetes menyediakan storan tambahan secara automatik untuk memenuhi keperluan saiz baharu, dengan syarat kelas storan asas menyokong peruntukan dinamik.

Bila hendak menggunakan hostPath dalam Kubernetes?

Jenis volum hostPath dalam Kubernetes sesuai untuk senario di mana anda perlu mengakses fail atau direktori pada sistem fail nod terus dalam pod. Ia biasanya digunakan untuk mengakses sumber khusus nod atau untuk berkongsi data antara bekas pada nod yang sama.

Apakah perbezaan antara PVC StatefulSet dan penggunaan?

PersistentVolumeClaims (PVC) dalam StatefulSets digunakan untuk menyediakan storan yang stabil dan berterusan untuk pod individu, memastikan kegigihan data dan identiti merentas pod dimulakan semula. Sebaliknya, penempatan biasanya menggunakan volum sekejap, sesuai untuk aplikasi tanpa kewarganegaraan di mana ketekunan data bukanlah satu keperluan.

Bolehkah Kami Menggunakan Aplikasi Tanpa Kewarganegaraan Menggunakan StatefulSets?

Walaupun boleh dari segi teknikal, tidak disyorkan untuk menggunakan aplikasi tanpa kewarganegaraan menggunakan StatefulSets. StatefulSets direka khusus untuk aplikasi stateful yang memerlukan pengecam unik yang stabil dan storan berterusan. Menggunakan aplikasi tanpa kewarganegaraan dengan StatefulSets boleh memperkenalkan kerumitan yang tidak perlu dan overhed sumber.

Adakah stateless lebih baik daripada stateful?

Ia bergantung pada keperluan khusus permohonan. Aplikasi stateless adalah lebih mudah untuk diurus dan skala secara mendatar, manakala aplikasi stateful mengekalkan integriti data dan lebih sesuai untuk beban kerja tertentu seperti pangkalan data atau sistem pemesejan.

Atas ialah kandungan terperinci Panduan pemula untuk Kubernetes Statefulsets. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!