Crea workload stateful

Questo documento spiega come creare e gestire workload stateful all'interno di un cluster Kubernetes Google Distributed Cloud (GDC) con air gap. I workload stateful ti consentono di scalare il deployment delle applicazioni con l'archiviazione permanente. L'archiviazione permanente fornisce alla tua applicazione identità coerenti e nomi host stabili, indipendentemente da dove sono pianificati i workload.

Questo documento è rivolto agli sviluppatori del gruppo di operatori di applicazioni, responsabili della creazione dei workload delle applicazioni per la propria organizzazione. Per saperne di più, consulta la documentazione relativa ai segmenti di pubblico per GDC con air gap.

Prima di iniziare

Per completare le attività descritte in questo documento, devi richiedere le autorizzazioni necessarie e preparare l'ambiente.

Richiedi ruoli IAM

Per ottenere le autorizzazioni necessarie per creare workload stateful, devi disporre di ruoli specifici. I ruoli necessari dipendono dal fatto che tu stia lavorando all'interno di un cluster condiviso con ambito a livello di organizzazione o di un cluster standard con ambito a livello di progetto. Per saperne di più, consulta Configurazioni dei cluster Kubernetes.

Ruoli cluster condivisi

Per creare, eliminare, modificare o visualizzare workload stateful in un cluster condiviso, chiedi all'amministratore del progetto IAM di concederti il ruolo Namespace Admin (namespace-admin). Questo ruolo è associato allo spazio dei nomi del progetto.

Ruoli cluster standard

Per creare, eliminare, modificare o visualizzare i workload stateful in un cluster standard, chiedi all'amministratore del progetto IAM di concederti il ruolo Sviluppatore cluster (cluster-developer). Questo ruolo è associato allo spazio dei nomi del progetto.

prepara l'ambiente

Per eseguire comandi su un cluster Kubernetes utilizzando l'API, assicurati di disporre delle seguenti risorse:

  • Individua il nome del cluster Kubernetes o chiedi a un membro del gruppo di amministratori della piattaforma qual è il nome del cluster.

  • Accedi e genera il file kubeconfig per il cluster Kubernetes.

  • Utilizza il percorso kubeconfig del cluster Kubernetes per sostituire KUBERNETES_CLUSTER_KUBECONFIG in queste istruzioni.

Crea una risorsa StatefulSet

Crea un oggetto StatefulSet scrivendo un manifest StatefulSet ed eseguendo kubectl apply per creare la risorsa. Per fornire ai client un modo stabile per inviare richieste ai pod della tua risorsa StatefulSet, devi anche creare un oggetto Service.

Il comando kubectl apply utilizza i file manifest per creare, aggiornare ed eliminare le risorse nel cluster Kubernetes. Questo è un metodo dichiarativo di configurazione degli oggetti. Questo metodo conserva le scritture apportate agli oggetti attivi senza unire le modifiche ai file di configurazione degli oggetti.

Per creare una risorsa StatefulSet e Service, esegui:

kubectl --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG -n NAMESPACE \
    apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: SERVICE_NAME
  labels:
    app: APP_NAME
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: APP_NAME
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: STATEFULSET_NAME
spec:
  selector:
    matchLabels:
      app: APP_LABEL_NAME
  serviceName: "SERVICE_NAME"
  replicas: NUMBER_OF_REPLICAS
  template:
    metadata:
      labels:
        app: APP_LABEL_NAME
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: CONTAINER_NAME
        image: CONTAINER_IMAGE
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: CONTAINER_STORAGE_VOLUME_PATH
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi
EOF

Sostituisci quanto segue:

  • KUBERNETES_CLUSTER_KUBECONFIG: il file kubeconfig per il cluster in cui stai eseguendo il deployment dei workload dei container.

  • NAMESPACE: lo spazio dei nomi in cui eseguire il deployment dei workload del container. Per i cluster condivisi, deve essere uno spazio dei nomi del progetto. Per i cluster standard, può essere qualsiasi spazio dei nomi.

  • SERVICE_NAME: il nome dell'oggetto Service. Assicurati che l'oggetto StatefulSet imposti anche l'oggetto Service nel suo serviceName.

  • APP_NAME: il nome dell'applicazione da eseguire all'interno del deployment.

  • APP_LABEL_NAME: il selettore di etichette che determina quali pod appartengono all'oggetto StatefulSet.

  • STATEFULSET_NAME: il nome dell'oggetto StatefulSet.

  • NUMBER_OF_REPLICAS: il numero di oggetti Pod replicati gestiti dal deployment.

  • CONTAINER_NAME: il nome del container.

  • CONTAINER_IMAGE: il nome dell'immagine container. Devi includere il percorso del container registry e la versione dell'immagine, ad esempio REGISTRY_PATH/nginx:1.23. Per saperne di più sull'impostazione del percorso del container registry, consulta la panoramica di Managed Harbor Service.

  • CONTAINER_STORAGE_VOLUME_PATH: il percorso all'interno del container in cui è montato un volume di archiviazione.

Ad esempio, i seguenti oggetti StatefulSet e Service corrispondenti creano workload dei container stateful:

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
  serviceName: "nginx"
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: REGISTRY_PATH/nginx:1.23
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

In questo esempio:

  • Viene creato un oggetto Service denominato nginx, indicato dal campo metadata: name. L'oggetto Service ha come target un'app denominata nginx, indicata da labels.app: nginx e selector.app: nginx. L'oggetto Service espone la porta 80 e la denomina web. Questo oggetto Service controlla il dominio di rete e instrada il traffico internet all'applicazione containerizzata di cui l'oggetto StatefulSet ha eseguito il deployment.
  • Viene creato un StatefulSet denominato web con tre oggetti Pod replicati, come impostato dal campo replicas: 3.
  • Il template Pod, impostato dalla sezione .spec.template, indica che i suoi oggetti Pod sono etichettati come app: nginx.
  • La specifica Pod, impostata dalla sezione .template.spec, indica che i pod di StatefulSet eseguono un container, nginx, che esegue l'immagine nginx nella versione 1.23.
  • La specifica Pod utilizza la porta web aperta dall'oggetto Service.
  • La sezione .template.spec.volumeMounts specifica un campo mountPath, denominato www. mountPath è il percorso nel container in cui è montato un volume di archiviazione.
  • StatefulSet esegue il provisioning di tre oggetti PersistentVolumeClaim, denominati web-www-0, web-www-1 e web-www-2, con 1 GB di spazio di archiviazione sottoposto a provisioning ciascuno.

Dopo la creazione, StatefulSet garantisce che il numero target di oggetti Pod sia in esecuzione e disponibile in qualsiasi momento. StatefulSet sostituisce automaticamente gli oggetti Pod che non vanno a buon fine o vengono rimossi dai relativi nodi e associa i nuovi oggetti Pod alle risorse di archiviazione, alle richieste di risorse e ai limiti delle risorse e ad altre configurazioni definite nella specifica Pod dell'oggetto StatefulSet.

Richiedi l'archiviazione permanente in una risorsa StatefulSet

È possibile eseguire il provisioning dinamico dello spazio di archiviazione permanente in modo che i volumi sottostanti vengano creati on demand. Le applicazioni possono richiedere l'archiviazione permanente con un oggetto PersistentVolumeClaim.

In genere, devi creare oggetti PersistentVolumeClaim oltre all'oggetto Pod. Tuttavia, gli oggetti StatefulSet includono un array volumeClaimTemplates che genera gli oggetti PersistentVolumeClaim. Ogni replica StatefulSet riceve il proprio oggetto PersistentVolumeClaim.

Per saperne di più, consulta Configura lo spazio di archiviazione dei container.

Passaggi successivi