Grunnleggende Kubernetes · leksjon

Ressursforespørsler og -grenser

Definer CPU- og minneforespørsler og -grenser for Pods for å sikre effektiv ressursallokering og hindre ressursmangel.

Leksjon 1 av 412 trinn

Ressursforespørsler og -grenser er en gratis leksjon i Grunnleggende Kubernetes på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Grunnleggende Kubernetes, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Grunnleggende Kubernetes inneholder totalt 4 leksjoner.

Ressursbehov i Kubernetes

Akkurat som alle applikasjoner trenger Pods ressurser for å kjøre. Kubernetes bidrar til å administrere disse ressursene effektivt ved hjelp av ressursforespørsler og ressursgrenser.

Disse innstillingene forteller Kubernetes hvor mye CPU og minne Pods trenger, og hvor mye de har lov til å bruke. Slik sikres en rettferdig fordeling av ressursene.

CPU-forespørsler: garantert CPU

En CPU-forespørsel forteller Kubernetes den minste mengden CPU Pod-en trenger for å kjøre problemfritt. Det er en garanti!

Kubernetes bruker forespørsler til å planlegge Pods på noder med tilstrekkelige tilgjengelige ressurser.
Hvis en node ikke har nok CPU til forespørselen, blir Pod-en ikke planlagt på den.
Dette bidrar til å hindre ressursmangel for kritiske applikasjoner.

CPU-enheter og eksempel på forespørsel

CPU måles i «kjerner» eller «millicores» (m). 1000m tilsvarer 1 CPU-kjerne. 500m er altså en halv kjerne.

Slik ber De om 0,5 CPU-kjerner i en Pod-definisjon:

apiVersion: v1
kind: Pod
metadata:
  name: cpu-request-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      requests:
        cpu: "500m"

CPU-grenser: hindre overforbruk

En CPU-grense angir den maksimale mengden CPU en Pod kan bruke. Det er et tak.

Hvis en Pod prøver å bruke mer CPU enn grensen, vil Kubernetes strupes den.
Det betyr at Pod-ens CPU-bruk begrenses, slik at den ikke beslaglegger ressurser fra andre Pods på samme node.

CPU-grensen i praksis

Her er et eksempel på hvordan man angir en CPU-grense. Hvis denne Pod-en prøver å bruke mer enn én CPU-kjerne, blir den strupet, noe som betyr at ytelsen begrenses.

apiVersion: v1
kind: Pod
metadata:
  name: cpu-limit-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      limits:
        cpu: "1"

Minneforespørsler: garantert RAM

I likhet med CPU angir en minneforespørsel den minste mengden RAM Pod-en trenger for å fungere.

Kubernetes bruker dette til å finne en node med nok ledig minne til Pod-en.
Hvis en node går tom for minne, blir Pods uten forespørsler ofte avsluttet først (evicted) for å frigjøre plass.

Minneenheter og eksempel på forespørsel

Minne måles i byte. Vanlige enheter er Mi (mebibyte) og Gi (gibibyte).

100Mi er 100 mebibyte. Slik ber De om 256 MiB minne:

apiVersion: v1
kind: Pod
metadata:
  name: mem-request-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      requests:
        memory: "256Mi"

Minnnegrenser: Unngå OOM

En minnegrense definerer hvor mye minne en Pod maksimalt kan bruke.

Hvis en Pod overskrider minnegrensen, avsluttes den umiddelbart av operativsystemet med feilen «Out Of Memory» (OOM). Dette vises ofte som «OOMKilled».
Dette hindrer én enkelt Pod som løper løpsk, i å bruke opp alt minnet på noden og få hele noden til å krasje.

Minnengrenser i praksis

Denne Pod-en har en minnegrense på 512 MiB. Hvis den prøver å bruke mer, avsluttes den (OOMKilled) for å beskytte andre arbeidsbelastninger og noden.

apiVersion: v1
kind: Pod
metadata:
  name: mem-limit-pod
spec:
  containers:
  - name: my-container
    image: nginx
    resources:
      limits:
        memory: "512Mi"

Beste praksis: Requests og limits

Det er beste praksis å definere både requests og limits for alle Pods. Dette gir stabilitet og forutsigbarhet i klyngen.

Requests sikrer at Pod-ene får minimumsressurser ved planlegging.
Limits hindrer at andre Pods og selve noden blir fratatt ressurser.

Her er et komplett eksempel:

apiVersion: v1
kind: Pod
metadata:
  name: full-resource-pod
spec:
  containers:
  - name: my-app
    image: my-registry/my-app:1.0
    resources:
      requests:
        cpu: "200m"
        memory: "128Mi"
      limits:
        cpu: "500m"
        memory: "256Mi"

Ressurssjekk

De har definert en Pod med en CPU-request på 200m og en CPU-limit på 1 (som er 1000m).

Hva skjer hvis denne Pod-en prøver å bruke 1.5 CPU-kjerner?

Besvar den i den interaktive leksjonen

Oppsummering: Ressursstyring

I denne leksjonen lærte De om Resource Requests og Resource Limits i Kubernetes.

Requests (CPU og minne) garanterer minimumsressurser ved planlegging av Pods.
Limits (CPU og minne) begrenser maksimal bruk for å hindre ressurskonflikter.
Overskridelse av CPU-limits fører til struping; overskridelse av minnegrenser fører til avslutning (OOMKilled).
Definer alltid både requests og limits for stabil og forutsigbar ytelse i applikasjonene!

Gratis å komme i gang

Lær deg Grunnleggende Kubernetes med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Ressursforespørsler og -grenser» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Grunnleggende Kubernetes, inkludert «Ressursforespørsler og -grenser», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Grunnleggende Kubernetes inneholder totalt 4 leksjoner.

Hva lærer jeg i «Ressursforespørsler og -grenser»?

Definer CPU- og minneforespørsler og -grenser for Pods for å sikre effektiv ressursallokering og hindre ressursmangel. Du øver på Grunnleggende Kubernetes med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Grunnleggende Kubernetes?

Ingen tidligere erfaring er nødvendig. Grunnleggende Kubernetes på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Ressursforespørsler og -grenser»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Grunnleggende Kubernetes-leksjonen?

Ja. Alle Grunnleggende Kubernetes-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Grunnleggende Kubernetes