LoadBalancer service type in Kubernetes - Mini Project: Build & Apply

Create a Kubernetes LoadBalancer Service

📖 Scenario: You have deployed a simple web application in Kubernetes using a Deployment. Now, you want to expose this application to the internet so users can access it from outside the cluster.

🎯 Goal: Learn how to create a Kubernetes Service of type LoadBalancer to expose your application externally.

📋 What You'll Learn

Create a Deployment named webapp running the nginx image with 2 replicas

Create a Service named webapp-service of type LoadBalancer

The Service should select pods with label app: webapp

The Service should expose port 80 and forward it to container port 80

Print the Service YAML manifest at the end

💡 Why This Matters

🌍 Real World

In real cloud environments, LoadBalancer Services provide a simple way to expose applications to the internet with a cloud provider's load balancer.

💼 Career

Understanding how to expose Kubernetes applications externally is essential for DevOps roles managing cloud-native applications.

1

Create the Deployment

Create a Deployment named webapp with 2 replicas using the nginx image. The pods should have the label app: webapp. Write the YAML manifest for this Deployment.

Kubernetes

# Write the Deployment YAML manifest here
# Your code here

Hint

Use kind: Deployment and set replicas: 2. Add label app: webapp under template.metadata.labels.

2

Add the LoadBalancer Service configuration

Create a Service named webapp-service of type LoadBalancer. It should select pods with label app: webapp. Expose port 80 and forward it to container port 80. Write the YAML manifest for this Service below the Deployment manifest.

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80

# Write the Service YAML manifest here
# Your code here

Hint

Use kind: Service and set type: LoadBalancer. Use selector: app: webapp and expose port 80.

3

Apply the manifests to the cluster

Use the kubectl apply -f command to apply the YAML manifest file named webapp.yaml that contains both the Deployment and Service manifests.

Kubernetes

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

# Write the kubectl command to apply the manifest file named webapp.yaml
# Your code here

Hint

Use kubectl apply -f webapp.yaml to apply the manifest file.

4

Display the Service details

Use the kubectl get service webapp-service command to display the details of the LoadBalancer Service and show its external IP address.

Kubernetes

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

kubectl apply -f webapp.yaml

# Write the command to get the service details for webapp-service
# Your code here

Hint

Use kubectl get service webapp-service to see the external IP and ports.

Practice

1. What does the LoadBalancer service type do in Kubernetes?

easy

A. It creates multiple internal IPs for the service.

B. It only exposes the service inside the cluster without external access.

C. It exposes the service externally with a cloud provider's load balancer and a single external IP.

D. It automatically scales the number of pods based on load.

Solution

1. Step 1: Understand LoadBalancer service purpose

   The LoadBalancer service type is designed to expose a Kubernetes service externally using a cloud provider's load balancer.

2. Step 2: Identify the external IP behavior

   It provides a single external IP address that routes traffic to the service pods.

3. Final Answer:

   It exposes the service externally with a cloud provider's load balancer and a single external IP. -> Option C

4. Quick Check:

   LoadBalancer = external IP + cloud load balancer [OK]

Hint: LoadBalancer = external IP + cloud load balancer [OK]

Common Mistakes:

• Confusing LoadBalancer with ClusterIP (internal only)
• Thinking it creates multiple external IPs
• Assuming it auto-scales pods

2. Which of the following is the correct YAML snippet to create a LoadBalancer service in Kubernetes?

easy

A. apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
type: NodePort
ports:
- port: 80
selector:
app: my-app

B. apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
type: ExternalName
ports:
- port: 80
selector:
app: my-app

C. apiVersion: v1
kind: Pod
metadata:
name: my-service
spec:
type: LoadBalancer
ports:
- port: 80
selector:
app: my-app

D. apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
type: LoadBalancer
ports:
- port: 80
selector:
app: my-app

Solution

1. Step 1: Identify correct kind and type

   The resource must be kind: Service and spec.type: LoadBalancer to create a LoadBalancer service.

2. Step 2: Check YAML correctness

   apiVersion: v1 kind: Service metadata: name: my-service spec: type: LoadBalancer ports: - port: 80 selector: app: my-app correctly uses kind: Service and type: LoadBalancer with proper ports and selector.

3. Final Answer:

   YAML with kind: Service and type: LoadBalancer -> Option D

4. Quick Check:

   LoadBalancer service YAML uses kind: Service + type: LoadBalancer [OK]

Hint: LoadBalancer service YAML: kind Service + type LoadBalancer [OK]

Common Mistakes:

• Using kind: Pod instead of Service
• Using wrong service type like NodePort or ExternalName
• Missing selector or ports section

3. Given this service YAML with type LoadBalancer, what will kubectl get svc my-service show for the EXTERNAL-IP field after creation?

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: my-app

medium

A. An external IP address like 34.68.123.45

B. <none>

C. Pending

D. ClusterIP address like 10.0.0.1

Solution

1. Step 1: Understand LoadBalancer external IP assignment

   When a LoadBalancer service is created, the cloud provider assigns an external IP address to the service, visible in EXTERNAL-IP field.

2. Step 2: Recognize typical EXTERNAL-IP values

   Initially, EXTERNAL-IP may show Pending, but after provisioning, it shows an actual external IP like 34.68.123.45.

3. Final Answer:

   An external IP address like 34.68.123.45 -> Option A

4. Quick Check:

   LoadBalancer EXTERNAL-IP = cloud IP address [OK]

Hint: LoadBalancer EXTERNAL-IP shows cloud IP, not ClusterIP [OK]

Common Mistakes:

• Expecting <none> or ClusterIP in EXTERNAL-IP field
• Confusing Pending state as final
• Thinking LoadBalancer does not assign external IP

4. You created a LoadBalancer service but kubectl get svc shows EXTERNAL-IP as "Pending" indefinitely. What is the most likely cause?

medium

A. The Kubernetes cluster is not running on a cloud provider that supports LoadBalancer.

B. The service selector does not match any pods.

C. The service type is incorrectly set to ClusterIP.

D. The pod containers do not expose the correct port.

Solution

1. Step 1: Understand LoadBalancer external IP provisioning

   LoadBalancer service requires cloud provider support to provision an external IP and load balancer.

2. Step 2: Identify cause of Pending EXTERNAL-IP

   If the cluster runs on bare metal or unsupported environment, the external IP stays Pending indefinitely.

3. Final Answer:

   The Kubernetes cluster is not running on a cloud provider that supports LoadBalancer. -> Option A

4. Quick Check:

   Pending EXTERNAL-IP means no cloud LB support [OK]

Hint: Pending EXTERNAL-IP means no cloud load balancer support [OK]

Common Mistakes:

• Blaming pod selector or ports for EXTERNAL-IP Pending
• Confusing service type ClusterIP with LoadBalancer
• Ignoring cluster environment limitations

5. You want to expose a Kubernetes app externally with a LoadBalancer service, but your cluster runs on bare metal without cloud support. Which approach will work best?

hard

A. Use ClusterIP service type and access pods internally only.

B. Change service type to NodePort and use external node IP with the node port.

C. Use LoadBalancer service type and wait for external IP assignment.

D. Delete the service and expose pods directly with hostPort.

Solution

1. Step 1: Recognize LoadBalancer limitation on bare metal

   LoadBalancer service requires cloud provider support, which bare metal lacks, so it won't get an external IP.

2. Step 2: Choose alternative external exposure method

   NodePort exposes the service on each node's IP at a static port, allowing external access without cloud load balancer.

3. Final Answer:

   Change service type to NodePort and use external node IP with the node port. -> Option B

4. Quick Check:

   Bare metal + external access = NodePort service [OK]

Hint: Bare metal clusters use NodePort for external access, not LoadBalancer [OK]

Common Mistakes:

• Expecting LoadBalancer to work without cloud support
• Using ClusterIP which is internal only
• Exposing pods directly with hostPort is less flexible