Questa pagina mostra come configurare i deployment Autopilot di Google Kubernetes Engine (GKE) per richiedere nodi supportati dall'architettura ARM.
Informazioni sull'architettura ARM in Autopilot
I cluster Autopilot offrono classi di calcolo per carichi di lavoro che hanno requisiti hardware specifici. Alcune di queste classi di calcolo supportano più architetture di CPU, come amd64
e arm64
.
Casi d'uso per i nodi ARM
I nodi con architettura ARM offrono prestazioni più convenienti rispetto a nodi x86 simili. Seleziona ARM per i carichi di lavoro Autopilot in situazioni come le seguenti:
- Il tuo ambiente si basa sull'architettura ARM per la creazione e i test.
- Stai sviluppando applicazioni per dispositivi Android che vengono eseguite su CPU ARM.
- Utilizzi immagini multi-arch e vuoi ottimizzare i costi durante l'esecuzione dei carichi di lavoro.
Come richiedere nodi Arm in Autopilot
Per richiedere nodi Arm per i tuoi pod, devi richiedere nodi con l'architettura ARM e una classe di computing che supporti i nodi ARM. Le seguenti sezioni mostrano come richiedere la classe di computing e l'architettura ARM utilizzando un selettore di nodi o una regola di affinità dei nodi nella specifica del pod.
Per un elenco di classi di computing che supportano l'architettura ARM, consulta Classi di computing in Autopilot.
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti attività:
- Abilita l'API Google Kubernetes Engine. Abilita l'API Google Kubernetes Engine
- Se vuoi utilizzare Google Cloud CLI per questa attività, installa e initialize gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo
gcloud components update
.
- Assicurati di avere un cluster GKE Autopilot che esegue GKE versione 1.24.1-gke.1400 o successive. Per impostare la versione, utilizza il flag
--cluster-version
nel comando create o upgrade. - Assicurati di disporre di una quota per il tipo di macchina Compute Engine
T2A
. - Assicurati di avere un pod con un'immagine container creata per l'architettura ARM.
Richiedi una classe di computing e un'architettura ARM
Per indicare ad Autopilot di posizionare i pod in una classe di computing che supporta l'architettura Arm, specifica entrambe le seguenti etichette in una regola nodeSelector o Affinità nodo:
cloud.google.com/compute-class: COMPUTE_CLASS
kubernetes.io/arch: arm64
Sostituisci COMPUTE_CLASS
con il nome di una classe di computing che supporta l'architettura ARM, ad esempio Scale-Out
.
Quando esegui il deployment del tuo carico di lavoro, Autopilot effettua le seguenti operazioni:
- Esegui automaticamente il provisioning dei nodi ARM per l'esecuzione dei pod.
- Incompatibilità automatica dei nuovi nodi per impedire la pianificazione di pod non ARM su questi nodi.
- Aggiunge automaticamente una tolleranza ai pod ARM per consentire la pianificazione sui nuovi nodi.
Puoi anche richiedere l'architettura ARM per i pod spot.
Esempio di richiesta per l'architettura ARM
Le specifiche di esempio seguenti mostrano come utilizzare un selettore di nodi o una regola di affinità dei nodi per richiedere l'architettura ARM in Autopilot.
nodeSelector
Il seguente manifest di esempio mostra come richiedere nodi Arm in un nodeSelector:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-arm
spec:
replicas: 3
selector:
matchLabels:
app: nginx-arm
template:
metadata:
labels:
app: nginx-arm
spec:
nodeSelector:
cloud.google.com/compute-class: Scale-Out
kubernetes.io/arch: arm64
containers:
- name: nginx-arm
image: nginx
resources:
requests:
cpu: 2000m
memory: 2Gi
nodeAffinity
Puoi utilizzare l'affinità nodo per richiedere i nodi ARM. Puoi anche specificare il tipo di affinità nodo da utilizzare:
requiredDuringSchedulingIgnoredDuringExecution
: deve utilizzare la classe e l'architettura di computing specificate.preferredDuringSchedulingIgnoredDuringExecution
: utilizza la classe e l'architettura di computing specificate secondo il criterio del "best effort". Ad esempio, se un nodo x86 esistente è allocabile, GKE posiziona il pod sul nodo x86 anziché eseguire il provisioning di un nuovo nodo ARM. A meno che non utilizzi un manifest di immagini multi-archetto, il pod si arresta in modo anomalo. Ti consigliamo vivamente di richiedere esplicitamente l'architettura specifica desiderata.
Il seguente manifest di esempio richiede la classe Scale-Out
e i nodi ARM:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-arm
spec:
replicas: 3
selector:
matchLabels:
app: nginx-arm
template:
metadata:
labels:
app: nginx-arm
spec:
terminationGracePeriodSeconds: 25
containers:
- name: nginx-arm
image: nginx
resources:
requests:
cpu: 2000m
memory: 2Gi
ephemeral-storage: 1Gi
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: cloud.google.com/compute-class
operator: In
values:
- Scale-Out
- key: kubernetes.io/arch
operator: In
values:
- arm64
Suggerimenti
- Crea e utilizza immagini multi-arch come parte della pipeline. Le immagini multi-archetto assicurano l'esecuzione dei pod anche se si trovano su nodi x86.
- Richiedi esplicitamente l'architettura e le classi di calcolo nei manifest dei tuoi carichi di lavoro. Se non lo fai, Autopilot utilizza l'architettura predefinita della classe di computing selezionata, che potrebbe non essere ARM.
Disponibilità
Puoi eseguire il deployment di carichi di lavoro Autopilot sull'architettura ARM nelle seguenti regioni di Google Cloud:
- us-central1
- europe-west4
- asia-southeast1
Risoluzione dei problemi
Per errori comuni e informazioni sulla risoluzione dei problemi, consulta Risoluzione dei problemi relativi ai carichi di lavoro ARM.
Passaggi successivi
- Scopri di più sull'architettura dei cluster Autopilot.
- Scopri di più sul ciclo di vita dei pod.
- Scopri di più sulle classi di calcolo Autopilot disponibili.
- Scopri di più sulle richieste di risorse predefinite, minime e massime per ogni piattaforma.