Questa pagina spiega come eseguire il deployment di un'applicazione stateful utilizzando Google Kubernetes Engine (GKE).
Panoramica
Le applicazioni stateful salvano dati archiviazione su disco permanente per essere utilizzato dal server, dai client e da altre applicazioni. Un esempio di un'applicazione stateful è un database o un archivio chiave-valore in cui vengono salvati i dati recuperate da altre applicazioni.
Per l'archiviazione permanente è possibile eseguire il provisioning dinamico, in modo che i volumi sottostanti vengano creati su richiesta. In Kubernetes, configura il provisioning dinamico creando un StorageClass. In GKE, un oggetto StorageClass predefinito ti consente di eseguire il provisioning dinamico dei dischi permanenti di Compute Engine.
Kubernetes usa lo StatefulSet per il deployment di applicazioni stateful come oggetti StatefulSet. I pod negli StatefulSet non sono intercambiabili: ogni pod ha un identificatore univoco che viene mantenuto indipendentemente da dove è pianificato.
Le applicazioni stateful sono diverse stateless, in cui i dati del client non vengono salvati sul server tra una sessione e l'altra.
Puoi scoprire di più su archiviazione permanente in cluster multi-zona e a livello di regione.
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:
- Attiva l'API Google Kubernetes Engine. Attiva l'API Google Kubernetes Engine
- Se vuoi utilizzare Google Cloud CLI per questa attività,
installa e poi
inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo
gcloud components update
.
- Assicurati che l'applicazione containerizzata sia archiviata in un registro di immagini, come Artifact Registry.
Puoi seguire la guida introduttiva per attivare l'API GKE, creare un cluster e scoprire di più su GKE.
Richiesta di archiviazione permanente in uno StatefulSet
Le applicazioni possono richiedere spazio di archiviazione permanente PersistentVolumeClaim.
In genere, devi creare oggetti PersistentVolumeClaim oltre a creare
all'interno del pod. Tuttavia, gli oggetti StatefulSet includono un array volumeClaimTemplates
,
che genera automaticamente gli oggetti PersistentVolumeClaim. Ogni replica del StatefulSet riceve il proprio oggetto PersistentVolumeClaim.
Puoi anche utilizzare un disco preesistente in uno StatefulSet.
Creazione di uno 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_di_ritiro]
della configurazione dell'oggetto. Questo metodo conserva le scritture apportate agli oggetti attivi senza
unendo 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 eseguita nei pod.CONTAINER_NAME
: il nome dei container nei pod.PORT_NAME
: il nome della porta aperta 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. Questo StatefulSet di 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 poiché quello predefinito utilizza ext4
come
il 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 dei file
come mostrato 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 StatefulSet utilizza il valore di StorageClass definito sopra. Crea quattro coppie di PersistentVolume e PersistentVolumeClaim per rappresentare quattro dischi permanenti Compute Engine. Ogni pod nello StatefulSet consuma un disco permanente.
Per assicurarti che i pod siano pianificati correttamente sui nodi Windows Server, devi aggiungere un selettore di nodi alla specifica del 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 in esecuzione nei pod.STATEFULSET_NAME
: il nome dello StatefulSet.CONTAINER_NAME
: il nome dei container nei pod.PORT_NAME
: il nome della porta aperta dallo StatefulSet.PVC_NAME
: il nome del PersistentVolumeClaim.STORAGECLASS_NAME
: il nome di un oggetto StorageClass.
Per creare una risorsa StatefulSet, esegui questo comando 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.
Ispezione di uno StatefulSet
kubectl
Per ispezionare lo StatefulSet, esegui questo comando:
kubectl get statefulset STATEFULSET_NAME -o yaml
Questo comando mostra la configurazione attiva della risorsa StatefulSet in formato YAML.
Per elencare i pod creati dallo StatefulSet, esegui questo comando:
kubectl get pods -l app=APP_NAME
In questo comando, il flag -l
indica a kubectl
di recuperare tutti i pod etichettati 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 informazioni dettagliate sullo StatefulSet, esegui questo comando:
kubectl describe statefulset STATEFULSET_NAME
Per ottenere informazioni su un pod specifico, esegui il seguente comando:
kubectl describe pod POD_NAME
Per elencare gli oggetti PersistentVolumeClaim creati, esegui il comando seguente comando:
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 PersistentVolumeClaim specifico, esegui questo comando:
kubectl describe pvc STATEFULSET_NAME-PVC_NAME-0
Per ottenere informazioni su un PersistentVolume specifico, esegui il seguente comando:
kubectl describe pv PV_NAME
Console
Per ispezionare uno StatefulSet, segui questi passaggi:
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Nell'elenco dei carichi di lavoro, fai clic sul nome del StatefulSet da ispezionare.
Nella pagina Dettagli set stateful, esegui una delle seguenti operazioni:
- Fai clic sulla scheda Cronologia delle revisioni per vedere la cronologia delle revisioni dello StatefulSet.
- Fai clic sulla scheda Eventi per visualizzare tutti gli eventi correlati allo StatefulSet.
- Fai clic sulla scheda Log per visualizzare i log del contenitore per lo StatefulSet.
- Fai clic sulla scheda YAML per visualizzare, copiare o scaricare la configurazione YAML per lo StatefulSet.
Aggiornamento di un StatefulSet
Esistono diversi modi per aggiornare gli oggetti StatefulSet. Il metodo dichiarativo comune
è kubectl apply
. Per aggiornare il StatefulSet direttamente dalla shell o in un editor preferito, puoi utilizzare kubectl edit
. Puoi anche usare l'editor YAML
dal menu Carichi di lavoro GKE nella console Google Cloud.
Puoi implementare aggiornamenti Specifiche dei pod per una risorsa StatefulSet, ad esempio l'immagine, l'utilizzo/le richieste o la configurazione delle risorse.
kubectl apply
Puoi aggiornare il StatefulSet applicando un file manifest nuovo o aggiornato. È utile per apportare varie modifiche allo StatefulSet, ad esempio quando la scalabilità o la specifica di una nuova versione dell'applicazione.
Per aggiornare uno StatefulSet, esegui il seguente comando:
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 di kubectl
.
Console
Per modificare la configurazione in tempo reale di uno StatefulSet, segui questi passaggi:
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Nell'elenco dei carichi di lavoro, fai clic sul nome del StatefulSet da modificare.
Fai clic su edit Modifica.
Modifica il file YAML di configurazione come preferisci.
Fai clic su Salva.
Controllo dell'implementazione dell'aggiornamento in corso...
kubectl
Per controllare l'implementazione dello StatefulSet, esegui questo comando:
kubectl rollout status statefulset STATEFULSET_NAME
Per visualizzare la cronologia di implementazione dello StatefulSet, esegui il seguente comando:
kubectl rollout history statefulset STATEFULSET_NAME
Per annullare un'implementazione, esegui il seguente comando:
kubectl rollout undo statefulset STATEFULSET_NAME
Console
Per visualizzare la cronologia delle revisioni di uno StatefulSet, segui questi passaggi:
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Nell'elenco dei carichi di lavoro, fai clic sul nome del StatefulSet da ispezionare.
Fai clic sulla scheda Cronologia delle revisioni.
Seleziona la revisione che ti interessa.
Aggiorna le strategie
Il campo updateStrategy
dello StatefulSet consente di configurare e disabilitare
aggiornamenti in sequenza automatici per container, etichette, richieste di risorse,
per i pod in uno StatefulSet.
Puoi scoprire di più sulle strategie di aggiornamento per i StatefulSet nella documentazione di Kubernetes.
Scalabilità di uno StatefulSet
kubectl
Il comando kubectl scale
può essere utilizzato in qualsiasi momento per scalare il StatefulSet.
Per eseguire il ridimensionamento manuale di uno StatefulSet, esegui il seguente comando:
kubectl scale statefulset STATEFULSET_NAME --replicas NUMBER_OF_REPLICAS
Sostituisci NUMBER_OF_REPLICAS
con il numero di pod replicati che preferisci.
Console
Per scalare uno StatefulSet, segui questi passaggi:
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Nell'elenco dei carichi di lavoro, fai clic sul nome del StatefulSet da modificare.
Fai clic su list Azioni > Scala > Modifica repliche.
Inserisci il nuovo numero di Repliche per il StatefulSet.
Fai clic su Scala.
Eliminazione di uno StatefulSet
kubectl
Per eliminare uno StatefulSet, esegui il seguente comando:
kubectl delete statefulset STATEFULSET_NAME
Console
Per eliminare uno StatefulSet:
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Nell'elenco dei carichi di lavoro, seleziona uno o più StatefulSet da eliminare.
Fai clic su delete Elimina.
Quando ti viene richiesto di confermare, fai clic su Elimina.
Passaggi successivi
- Scopri come eseguire il deployment di un cluster MySQL su GKE per l'alta disponibilità
- Scopri di più sul deployment di applicazioni stateless.
- Segui un tutorial sull'upgrade di un cluster che esegue un carico di lavoro stateful.