Deployment di un'applicazione stateful

Questa pagina spiega come eseguire il deployment di un'applicazione stateful utilizzando Google Kubernetes Engine (GKE).

Panoramica

Le applicazioni stateful salvano i dati nello spazio di archiviazione su disco permanente per l'utilizzo da parte del server, dei client e di altre applicazioni. Un'applicazione stateful è un database o un archivio chiavi-valore in cui i dati vengono salvati e recuperati da altre applicazioni.

L'archiviazione permanente può essere eseguita con provisioning dinamico, per far sì che i volumi sottostanti vengano creati on demand. In Kubernetes, configurerai il provisioning dinamico creando un StorageClass. In GKE, un oggetto StorageClass predefinito consente di eseguire il provisioning dinamico dei dischi permanenti di Compute Engine.

Kubernetes utilizza il controller StatefulSet per il deployment di applicazioni stateful come oggetti StatefulSet. I pod negli oggetti StatefulSet non sono intercambiabili: ogni pod ha un identificatore univoco gestito a prescindere dalla relativa pianificazione.

Le applicazioni stateful sono diverse dalle applicazioni stateless, in cui i dati dei client non vengono salvati sul server tra una sessione e l'altra.

Scopri di più sull'archiviazione permanente in cluster multi-zona e a livello di area geografica.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Assicurati di aver abilitato l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Assicurati di aver installato l'interfaccia a riga di comando di Google Cloud.
• Configura le impostazioni dell'interfaccia a riga di comando di Google Cloud predefinite per il tuo progetto utilizzando uno dei seguenti metodi:
• Utilizza gcloud init se vuoi avere istruzioni dettagliate sull'impostazione delle impostazioni predefinite del progetto.
• Utilizza gcloud config per impostare singolarmente l'ID, la zona e l'area geografica del progetto.

gcloud init

1. Esegui gcloud init e segui le istruzioni:

   gcloud init

   Se utilizzi SSH su un server remoto, usa il flag --console-only per impedire l'avvio del comando da parte di un browser:

   gcloud init --console-only

2. Segui le istruzioni per autorizzare l'interfaccia a riga di comando gcloud a utilizzare il tuo account Google Cloud.
3. Crea una nuova configurazione o selezionane una esistente.
4. Scegli un progetto Google Cloud.
5. Scegli una zona Compute Engine predefinita.
6. Scegli un'area geografica di Compute Engine predefinita.

Nota: puoi sostituire queste impostazioni predefinite nell'interfaccia a riga di comando gcloud utilizzando i flag --project, --zone e --region.

gcloud config

1. Imposta l'ID progetto predefinito:

   gcloud config set project PROJECT_ID

2. Imposta l'area geografica di Compute Engine predefinita (ad esempio us-central1):

   gcloud config set compute/region COMPUTE_REGION

3. Imposta la zona Compute Engine predefinita (ad esempio us-central1-c):

   gcloud config set compute/zone COMPUTE_ZONE

4. Aggiorna gcloud alla versione più recente:

   gcloud components update

Nota: puoi sostituire queste impostazioni predefinite nell'interfaccia a riga di comando gcloud utilizzando i flag --project, --zone e --region.

Impostando le posizioni predefinite puoi evitare errori nell'interfaccia a riga di comando gcloud come One of [--zone, --region] must be supplied: Please specify location:

• Assicurati che l'applicazione containerizzata sia archiviata in un registro di immagini, come Artifact Registry.

Puoi seguire la guida rapida per abilitare l'API GKE, creare un cluster e scoprire di più su GKE.

Richiesta di archiviazione permanente in uno StatefulSet

Le applicazioni possono richiedere l'archiviazione permanente con un oggetto PersistentVolumeClaim.

In genere, oltre alla creazione del pod, devi creare oggetti PersistentVolumeClaim. Tuttavia, gli oggetti StatefulSet includono un array volumeClaimTemplates, che genera automaticamente gli oggetti PersistentVolumeClaim. Ogni replica StatefulSet riceve il proprio oggetto PersistentVolumeClaim.

Puoi anche utilizzare un disco preesistente in uno StatefulSet.

Creazione di un oggetto StatefulSet

Per creare una risorsa StatefulSet, utilizza il comando kubectl apply.

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

Linux

Il seguente file manifest è un semplice esempio di uno StatefulSet regolato da un servizio creato separatamente:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: STATEFULSET_NAME
spec:
  selector:
    matchLabels:
      app: APP_NAME
  serviceName: "SERVICE_NAME"
  replicas: 3
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: APP_NAME
    spec:
      containers:
      - name: CONTAINER_NAME
        image: ...
        ports:
        - containerPort: 80
          name: PORT_NAME
        volumeMounts:
        - name: PVC_NAME
          mountPath: ...
  volumeClaimTemplates:
  - metadata:
      name: PVC_NAME
      annotations:
        ...
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Sostituisci quanto segue:

• STATEFULSET_NAME: il nome dello StatefulSet.
• SERVICE_NAME: il nome del servizio.
• APP_NAME: il nome dell'applicazione eseguito nei pod.
• CONTAINER_NAME: il nome dei container nei pod.
• PORT_NAME: nome del trasferimento aperto dallo StatefulSet.
• PVC_NAME: il nome dell'oggetto PersistentVolumeClaim.

In questo file, il campo kind specifica che un oggetto StatefulSet deve essere creato con le specifiche definite nel file. Lo StatefulSet di questo esempio produce tre pod replicati e apre la porta 80 per esporre lo StatefulSet a Internet.

Windows

Quando utilizzi cluster con pool di nodi Windows Server, devi creare un oggetto StorageClass perché il valore predefinito di StorageClass è ext4 come tipo di file system, che funziona solo per i container Linux. Se utilizzi un disco permanente di Compute Engine, devi utilizzare NTFS come tipo di archiviazione file, come illustrato nell'esempio seguente:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: STORAGECLASS_NAME
parameters:
  type: pd-standard
  fstype: NTFS
provisioner: kubernetes.io/gce-pd
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer

Il seguente manifest dello StatefulSet utilizza il valore StorageClass definito sopra. Crea quattro coppie PersistentVolume e PersistentVolumeClaim per rappresentare quattro dischi permanenti di Compute Engine. Ogni pod nello StatefulSet consuma un disco permanente.

Per assicurarti che i tuoi pod vengano programmati correttamente sui nodi Windows Server, devi aggiungere un selettore nodo alla specifica dei pod.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: STATEFULSET_NAME
spec:
  replicas: 4
  selector:
    matchLabels:
      app: APP_NAME
  template:
    metadata:
      labels:
        app: APP_NAME
      name: CONTAINER_NAME
    spec:
      nodeSelector:
        kubernetes.io/os: windows
      containers:
      - name: CONTAINER_NAME
        image: ...
        ports:
        - containerPort: 80
          name: PORT_NAME
        volumeMounts:
        - name: PVC_NAME
          mountPath: C:\mnt\state
  volumeClaimTemplates:
  - metadata:
      name: PVC_NAME
    spec:
      storageClassName: STORAGECLASS_NAME
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Sostituisci quanto segue:

• APP_NAME: il nome dell'applicazione eseguito nei pod.
• STATEFULSET_NAME: il nome dello StatefulSet.
• CONTAINER_NAME: il nome dei container nei pod.
• PORT_NAME: nome del trasferimento aperto dallo StatefulSet.
• PVC_NAME: il nome dell'oggetto PersistentVolumeClaim.
• STORAGECLASS_NAME: il nome dell'oggetto StorageClass.

Per creare una risorsa StatefulSet, esegui il comando seguente sostituendo STATEFULSET_FILE con il nome del file manifest:

kubectl apply -f STATEFULSET_FILE

Puoi anche utilizzare kubectl apply -f DIRECTORY/ per creare tutti gli oggetti (tranne quelli esistenti) definiti nei file di configurazione archiviati in una directory.

Nota: kubectl apply non ha un cluster attivo.

Ispezione di uno StatefulSet

kubectl

Per controllare lo StatefulSet, esegui il comando seguente:

kubectl get statefulset STATEFULSET_NAME -o yaml

Questo comando visualizza la configurazione attiva della risorsa StatefulSet in formato YAML.

Per elencare i pod creati dallo StatefulSet, esegui il comando seguente:

kubectl get pods -l app=APP_NAME

In questo comando, il flag -l indica a kubectl di ottenere l'etichetta di tutti i pod per APP_NAME.

L'output è simile al seguente:

NAME                                READY     STATUS    RESTARTS   AGE
pod-name                            1/1       Running   0          1m
pod-name                            1/1       Running   0          1m

Per ottenere informazioni dettagliate sullo StatefulSet, esegui il comando seguente:

kubectl describe statefulset STATEFULSET_NAME

Per ottenere informazioni su un pod specifico, esegui il comando seguente:

kubectl describe pod POD_NAME

Per elencare gli oggetti PersistentVolumeClaim creati, esegui il comando seguente:

kubectl get pvc

L'output è simile al seguente:

NAME                            STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
STATEFULSET_NAME-PVC_NAME-0     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800002   1G         RWO            standard        9s
STATEFULSET_NAME-PVC_NAME-1     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800003   1G         RWO            standard        9s
STATEFULSET_NAME-PVC_NAME-2     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800004   1G         RWO            standard        9s

Per ottenere informazioni su un oggetto PersistentVolumeClaim specifico, esegui questo comando:

kubectl describe pvc STATEFULSET_NAME-PVC_NAME-0

Per ottenere informazioni su un PersistentVolume specifico, esegui il comando seguente:

kubectl describe pv PV_NAME

console

Per controllare uno StatefulSet, procedi come descritto di seguito:

1. Vai alla pagina Carichi di lavoro nella console.

   Vai a Carichi di lavoro

2. Nell'elenco dei carichi di lavoro, fai clic sul nome dello StatefulSet che vuoi ispezionare.

3. Nella pagina Dettagli set stateful, esegui una delle seguenti operazioni:

   • Fai clic sulla scheda Cronologia delle revisioni per visualizzare la cronologia delle revisioni dello StatefulSet.
   • Fai clic sulla scheda Eventi per visualizzare tutti gli eventi relativi allo StatefulSet.
   • Fai clic sulla scheda Log per visualizzare i log del container per lo StatefulSet.
   • Fai clic sulla scheda YAML per vedere, copiare o scaricare la configurazione YAML per lo StatefulSet.

Aggiornamento di uno StatefulSet

Esistono diversi modi per aggiornare gli StatefulSet. Il metodo dichiarativo comune è kubectl apply. Per aggiornare lo StatefulSet direttamente dalla shell o in un editor preferito, puoi utilizzare kubectl edit. Puoi anche utilizzare l'editor YAML dal menu Carichi di lavoro GKE nella console.

Puoi implementare gli aggiornamenti nella specifica dei pod per una risorsa StatefulSet, ad esempio immagine, utilizzo/richieste delle risorse o configurazione.

kubectl apply

Puoi aggiornare lo StatefulSet applicando un file manifest nuovo o aggiornato. È utile per apportare varie modifiche allo StatefulSet, ad esempio per la scalabilità o per specificare una nuova versione dell'applicazione.

Nota: per aggiornare una risorsa con kubectl apply, è necessario che la risorsa sia stata creata utilizzando kubectl apply o kubectl create --save-config.

Per aggiornare uno StatefulSet, esegui il comando seguente:

kubectl apply -f STATEFULSET_FILE

Sostituisci STATEFULSET_FILE con il file manifest aggiornato.

Il comando kubectl apply applica un file manifest a una risorsa. Se la risorsa specificata non esiste, viene creata dal comando.

Per ulteriori informazioni su kubectl apply, consulta la documentazione di riferimento per kubectl.

console

Per modificare la configurazione attiva di uno StatefulSet, procedi come riportato di seguito:

1. Vai alla pagina Carichi di lavoro nella console.

   Vai a Carichi di lavoro

2. Nell'elenco dei carichi di lavoro, fai clic sul nome dello StatefulSet che vuoi modificare.

3. Fai clic su Modifica.

4. Modifica la configurazione YAML come preferisci.

5. Fai clic su Salva.

Nota: Sebbene sia possibile specificare un oggetto PersistentVolume diverso, non è possibile aggiornare le risorse PersistentVolume esistenti.

Controllo dell'implementazione degli aggiornamenti in corso...

kubectl

Per controllare l'implementazione dello StatefulSet, esegui il comando seguente:

kubectl rollout status statefulset STATEFULSET_NAME

Per visualizzare la cronologia di implementazione dello StatefulSet, esegui il comando seguente:

kubectl rollout history statefulset STATEFULSET_NAME

Per annullare un'implementazione, esegui questo comando:

kubectl rollout undo statefulset STATEFULSET_NAME

console

Per visualizzare la cronologia delle revisioni di uno StatefulSet, procedi nel seguente modo:

1. Vai alla pagina Carichi di lavoro nella console.

   Vai a Carichi di lavoro

2. Nell'elenco dei carichi di lavoro, fai clic sul nome dello StatefulSet che vuoi ispezionare.

3. Fai clic sulla scheda Cronologia delle revisioni.

4. Seleziona la revisione desiderata.

Strategie di aggiornamento

Il campo updateStrategy di StatefulSet consente di configurare e disabilitare gli aggiornamenti automatici in sequenza per container, etichette, richieste di risorse, limiti e annotazioni per i pod in uno StatefulSet.

Per saperne di più sulle strategie di aggiornamento per gli StatefulSet, consulta la documentazione Kubernetes.

Scalabilità di un StatefulSet

kubectl

Il comando kubectl scale può essere utilizzato in qualsiasi momento per scalare lo StatefulSet.

Per scalare manualmente uno StatefulSet, esegui il comando seguente:

kubectl scale statefulset STATEFULSET_NAME --replicas NUMBER_OF_REPLICAS

Sostituisci NUMBER_OF_REPLICAS con il numero desiderato di pod replicati.

console

Per scalare uno StatefulSet, segui questi passaggi:

1. Vai alla pagina Carichi di lavoro nella console.

   Vai a Carichi di lavoro

2. Nell'elenco dei carichi di lavoro, fai clic sul nome dello StatefulSet che vuoi modificare.

3. Fai clic su Azioni > Scala > Modifica repliche.

4. Inserisci il nuovo numero di Repliche per lo StatefulSet.

5. Fai clic su Scala.

Eliminazione di uno StatefulSet

kubectl

Per eliminare uno StatefulSet, esegui il comando seguente:

kubectl delete statefulset STATEFULSET_NAME

console

Per eliminare uno StatefulSet:

1. Vai alla pagina Carichi di lavoro nella console.

   Vai a Carichi di lavoro

2. Nell'elenco dei carichi di lavoro, seleziona uno o più StatefulSet che vuoi eliminare.

3. Fai clic su Elimina.

4. Quando ti viene chiesto di confermare, fai clic su Elimina.

Passaggi successivi

• Informazioni sul deployment di applicazioni stateless.
• Guarda un tutorial sull'upgrade di un cluster che esegue un carico di lavoro stateful.