High availability cluster setup in Kubernetes - Commands & Configuration

Introduction

High availability cluster setup ensures your application keeps running even if some parts fail. It spreads the workload across multiple nodes to avoid downtime and data loss.

When you want your web app to stay online even if one server crashes

When you run a database that must never lose data or stop responding

When you deploy a critical service that users rely on 24/7

When you want to balance traffic evenly across several servers

When you need automatic recovery from hardware or software failures

Config File - deployment-ha.yaml

deployment-ha.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: nginx:1.23.3
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

This file creates a Deployment with 3 replicas of the nginx container to ensure multiple copies run simultaneously.

The Service exposes these replicas on port 80 and balances traffic between them.

This setup helps keep the app available even if one pod or node fails.

Commands

This command creates the Deployment and Service defined in the YAML file. It starts 3 pods running the app and exposes them via a load balancer.

Terminal

kubectl apply -f deployment-ha.yaml

Expected Output

deployment.apps/my-app created

service/my-app-service created

This command lists all pods with the label app=my-app to verify that 3 pods are running as expected.

Terminal

kubectl get pods -l app=my-app

Expected Output

NAME                        READY   STATUS    RESTARTS   AGE

my-app-6d4cfb7f7f-abcde    1/1     Running   0          15s

my-app-6d4cfb7f7f-fghij    1/1     Running   0          15s

my-app-6d4cfb7f7f-klmno    1/1     Running   0          15s

→

-l - Filter pods by label

This command shows the Service details including the external IP and port to access the app.

Terminal

kubectl get svc my-app-service

Expected Output

NAME             TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE

my-app-service   LoadBalancer   10.96.123.45    34.68.123.45    80:31234/TCP   1m

This command provides detailed information about the Deployment, including the number of replicas, pod status, and events.

Terminal

kubectl describe deployment my-app

Expected Output

Name:                   my-app

Namespace:              default

CreationTimestamp:      Thu, 01 Jun 2024 12:00:00 +0000

Labels:                 app=my-app

Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable

StrategyType:           RollingUpdate

Pods Status:            3 Running / 0 Waiting / 0 Succeeded / 0 Failed

Events:

  Type    Reason             Age   From                   Message

  ----    ------             ----  ----                   -------

  Normal  ScalingReplicaSet  1m    deployment-controller  Scaled up replica set my-app-6d4cfb7f7f to 3

Key Concept

If you remember nothing else from this pattern, remember: running multiple replicas of your app across nodes keeps it available even if some parts fail.

Common Mistakes

Setting replicas to 1 in the Deployment

Only one pod means no backup if it crashes, so the app becomes unavailable.

Set replicas to at least 2 or 3 to ensure high availability.

Not exposing the Deployment with a Service

Without a Service, you cannot access the pods easily or balance traffic between them.

Create a Service of type LoadBalancer or ClusterIP to expose the pods.

Using the same node for all pods without spreading

If that node fails, all pods go down together, losing availability.

Kubernetes schedules pods across nodes automatically; avoid node selectors that force all pods on one node.

Summary

Create a Deployment with multiple replicas to run several copies of your app.

Expose the Deployment with a Service to balance traffic and provide a stable access point.

Verify pods and service status with kubectl commands to ensure high availability.

Practice

1. What is the main purpose of setting up a high availability (HA) cluster in Kubernetes?

easy

A. To prevent downtime by having multiple master nodes

B. To reduce the number of worker nodes

C. To speed up pod creation on a single node

D. To disable load balancing between nodes

Solution

1. Step 1: Understand HA cluster purpose

   High availability clusters are designed to avoid downtime by having multiple master nodes so if one fails, others take over.

2. Step 2: Compare options

   Options B, C, and D do not relate to preventing downtime or multiple masters.

3. Final Answer:

   To prevent downtime by having multiple master nodes -> Option A

4. Quick Check:

   HA cluster = multiple masters for uptime [OK]

Hint: HA means multiple masters to avoid downtime [OK]

Common Mistakes:

• Thinking HA reduces worker nodes
• Confusing HA with pod scaling
• Ignoring the role of multiple masters

2. Which of the following is the correct syntax to initialize a Kubernetes HA cluster using kubeadm with a config file named ha-config.yaml?

easy

A. kubeadm create cluster ha-config.yaml

B. kubeadm start --config=ha-config.yaml

C. kubeadm init --config ha-config.yaml

D. kubeadm init ha-config.yaml

Solution

1. Step 1: Recall kubeadm init syntax

   The correct command to initialize a cluster with a config file is kubeadm init --config filename.

2. Step 2: Check options

   kubeadm init --config ha-config.yaml matches the correct syntax. Options A, B, and D use incorrect commands or missing flags.

3. Final Answer:

   kubeadm init --config ha-config.yaml -> Option C

4. Quick Check:

   kubeadm init + --config = correct syntax [OK]

Hint: Use 'kubeadm init --config filename' to start HA cluster [OK]

Common Mistakes:

• Using 'start' instead of 'init'
• Omitting '--config' flag
• Passing config file without flag

3. Given the following HA cluster setup snippet in ha-config.yaml:

apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
controlPlaneEndpoint: "lb.example.com:6443"
---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs

What does the controlPlaneEndpoint specify in this configuration?

medium

A. The IP address of the worker node

B. The port for kubelet communication

C. The DNS name of the pod network

D. The load balancer address for master nodes

Solution

1. Step 1: Understand controlPlaneEndpoint role

   This field defines the address (usually a load balancer) that routes traffic to the master nodes in an HA setup.

2. Step 2: Analyze options

   The load balancer address for master nodes correctly identifies it as the load balancer address. Other options do not relate to controlPlaneEndpoint.

3. Final Answer:

   The load balancer address for master nodes -> Option D

4. Quick Check:

   controlPlaneEndpoint = load balancer address [OK]

Hint: controlPlaneEndpoint points to the HA load balancer [OK]

Common Mistakes:

• Confusing it with worker node IP
• Thinking it is pod network DNS
• Mixing it with kubelet port

4. You tried to join a new master node to your HA cluster using this command:

kubeadm join lb.example.com:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:12345

But it failed with an error about missing --control-plane flag. What is the correct fix?

medium

A. Remove the token from the command

B. Add the --control-plane flag to the join command

C. Use kubeadm init instead of join

D. Change the port number to 8080

Solution

1. Step 1: Identify the error cause

   Joining a master node requires the --control-plane flag to indicate it is a control plane node.

2. Step 2: Apply the fix

   Add --control-plane to the join command to fix the error.

3. Final Answer:

   Add the --control-plane flag to the join command -> Option B

4. Quick Check:

   Joining master needs --control-plane flag [OK]

Hint: Joining master nodes requires --control-plane flag [OK]

Common Mistakes:

• Removing token breaks authentication
• Using init instead of join for adding nodes
• Changing port to wrong value

5. You want to set up a Kubernetes HA cluster with 3 master nodes behind a load balancer. Which of the following steps is the correct order to achieve this?

hard

A. Set up load balancer -> Initialize first master with kubeadm and config -> Join other masters with --control-plane -> Join worker nodes

B. Initialize all masters separately -> Set up load balancer -> Join worker nodes

C. Join worker nodes -> Initialize first master -> Set up load balancer -> Join other masters

D. Set up load balancer -> Join worker nodes -> Initialize all masters

Solution

1. Step 1: Set up load balancer first

   The load balancer must be ready to route traffic to masters before initializing the cluster.

2. Step 2: Initialize first master with kubeadm and config

   This creates the cluster control plane and configures the controlPlaneEndpoint.

3. Step 3: Join other masters with --control-plane flag

   Other masters join as control plane nodes to form HA.

4. Step 4: Join worker nodes

   Finally, worker nodes join the cluster to run workloads.

5. Final Answer:

   Set up load balancer -> Initialize first master with kubeadm and config -> Join other masters with --control-plane -> Join worker nodes -> Option A

6. Quick Check:

   Load balancer first, then masters, then workers [OK]

Hint: Load balancer first, then init masters, then join workers [OK]

Common Mistakes:

• Initializing all masters before load balancer
• Joining workers before masters
• Skipping --control-plane flag on masters