Kubernetes: (auto)scaling

Kubernetes is een krachtig en populair container orchestratie tool. Als je Kubernetes goed toepast, stelt het je in staat om applicaties te deployen op een schaalbare infrastructuur. Dit kan een kostbesparend effect hebben! Een belangrijk onderdeel hiervan is autoscaling. In deze blog zullen we stapsgewijs instructies geven over hoe je een deployment in Kubernetes definieert met behulp van YAML. We beginnen met het maken van een eenvoudige deployment zonder schaal-, resource- en autoscalingconfiguraties. Vervolgens voegen we stap voor stap functionaliteiten toe om schalen, resourcebeheer en autoscaling mogelijk te maken.

Stap 1: Een eenvoudige Deployment maken
Laten we beginnen met het maken van een basisdeployment zonder schaal-, resource- en autoscalingconfiguraties. Dit zal ons uitgangspunt zijn waarop we later functionaliteiten zullen toevoegen. Maak een YAML-bestand genaamd deployment.yaml aan en voeg de volgende code toe:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mijn-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mijn-app
  template:
    metadata:
      labels:
        app: mijn-app
    spec:
      containers:
        - name: mijn-app
          image: jouw-container-image
          ports:
            - containerPort: 80

In deze YAML-definitie definiëren we een deployment met één replica van onze app. De selector en template secties worden gebruikt om de pods te selecteren en te configureren die onderdeel uitmaken van de deployment. De uitdaging van deze configuratie is dat er maar 1 replica van de applicatie is. Bij veel gebruik van de app zal het resource gebruik oplopen en zal de app uiteindelijk crashen. Om dit op te lossen, kunnen we het aantal replicas van de app opschalen.

Stap 2: Opschalen van de Deployment
Om schalen mogelijk te maken, voegen we de configuratie van de replicas toe aan onze deployment. Laten we het aantal replicas bijvoorbeeld verhogen naar 3. Pas de replicas waarde aan in de spec sectie van de deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mijn-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mijn-app
  template:
    metadata:
      labels:
        app: mijn-app
    spec:
      containers:
        - name: mijn-app
          image: jouw-container-image
          ports:
            - containerPort: 80

Op basis hiervan zal Kubernetes 3 replicas aanmaken van de app. Hierdoor verkleinen we de kans op een crash. De volgens uitdaging is dat er geen resource limits zijn gedefineerd voor de applicatie. Dit betekent dat de app alle resource kan gebruiken van de nodes waarop ze gedeployed zijn. Wanneer deze app op een 3 node cluster is gedeployed, zou deze configuratie ervoor kunnen zorgen dat het hele cluster crashed. Het is daarom belangrijk om resource limits te definiëren voor je applicaties.

Stap 3: Resourcebeheer toevoegen
Om efficiënt gebruik te maken van de beschikbare resources, kunnen we limieten en aanvragen instellen voor CPU en geheugen. Voeg de resource definities toe aan de containers sectie van de deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mijn-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mijn-app
  template:
    metadata:
      labels:
        app: mijn-app
    spec:
      containers:
        - name: mijn-app
          image: jouw-container-image
          ports:
            - containerPort: 80
          resources:
            limits:
            cpu: "1"
            memory: "512Mi"
          requests:
            cpu: "0.5"
            memory: "256Mi"

Met deze configuratie beperken we het gebruik van CPU tot 1 core en het geheugengebruik tot 512 MB voor elke replica. We vragen ook minimaal 0,5 cores CPU en 256 MB geheugen aan. Deze configuratie zorgt ervoor dat wij een highly available applicatie kunnen deployen zonder andere processen binnen het cluster in gevaar te brengen. Het enige nadeel is dat de applicatie nu altijd met 3 replicas wordt geployed. Ook als een van de replicas niet wordt gebruikt, gebruiken ze wel resources. En dit brengt kosten met zich mee. Het is dus tijd voor nóg een verbetering! We gaan onze deployment flexibel inrichten door middel van autoscaling.

Stap 4: Autoscaling van de Deployment
Naast handmatig schalen, kunnen we ook autoscaling configureren op basis van CPU metrics. Voeg de volgende code toe aan de spec sectie van de deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mijn-app
spec:
  autoscaling:
    enabled: true
    minReplicas: 1
    maxReplicas: 5
    targetCPUUtilizationPercentage: 80
  selector:
    matchLabels:
      app: mijn-app
  template:
    metadata:
      labels:
        app: mijn-app
    spec:
      containers:
        - name: mijn-app
          image: jouw-container-image
          ports:
            - containerPort: 80
          resources:
            limits:
            cpu: "1"
            memory: "512Mi"
          requests:
            cpu: "0.5"
            memory: "256Mi"

Met deze configuratie hebben we autoscaling ingeschakeld voor onze deployment. Hierdoor kan Kubernetes automatisch het aantal replicas schalen op basis van de CPU-belasting. In dit voorbeeld stellen we het minimum aantal replicas in op 1, het maximum aantal replicas op 5 en de streefwaarde voor CPU-gebruik op 80%.

Wat willen we je meegeven?
Om apps flexibel en efficient te kunnen deployen in een Kubernetes cluster is het belangrijk om de juiste configuraties toe te passen. Door autscaling en resource limits toe te passen, kan je app pieken in het gebruik aan en wordt het verbruik van resources beperkt bij weinig gebruik.

Het correct toepassen van schalen en autoscaling in Kubernetes deployments is van groot belang voor het bouwen van schaalbare en veerkrachtige applicaties. De stappen in deze blog laten zien hoe je deployments optimaliseert en efficiënt gebruik maakt van de beschikbare resources. Dit stelt je in staat om je applicaties moeiteloos te schalen en te beheren in een Kubernetes omgeving.

Wil je hier een keer over sparren? Neem dan contact op met Gerard!