Ingress vs LoadBalancer Service decision in Kubernetes - Visual Side-by-Side Comparison

Process Flow - Ingress vs LoadBalancer Service decision

Start: Need external access to app

↓

Decide: Single or Multiple apps?

↓

Single app

↓

Use LoadBalancer

↓

Direct external IP

↓

Access app

This flow shows how to decide between LoadBalancer and Ingress based on app count and routing needs.

Execution Sample

Kubernetes

kubectl expose deployment myapp --type=LoadBalancer --port=80
kubectl apply -f ingress.yaml

Expose a single app with LoadBalancer or multiple apps with Ingress routing.

Process Table

Step	Decision Point	Condition	Chosen Service Type	Result
1	Need external access?	Yes	Proceed	Evaluate app count
2	Number of apps?	Single app	LoadBalancer	Creates external IP per app
3	Number of apps?	Multiple apps	Ingress	Single external IP with routing rules
4	Routing needed?	Yes, path or host based	Ingress	Routes traffic to correct app
5	Routing needed?	No	LoadBalancer	Direct external IP to app
6	Cost and IP limits?	Many apps with LoadBalancer	Ingress preferred	Saves IP addresses
7	Exit	Decision complete	-	Service type chosen based on needs

💡 Decision ends when service type matches app count and routing needs

Status Tracker

Variable	Start	After Step 2	After Step 3	Final
app_count	unknown	single	multiple	multiple
routing_needed	unknown	no	yes	yes
service_type	none	LoadBalancer	Ingress	Ingress

Key Moments - 3 Insights

Why choose Ingress when multiple apps need external access?

Ingress allows using a single external IP with routing rules to direct traffic to different apps, as shown in execution_table rows 3 and 4.

Can LoadBalancer be used for multiple apps?

Yes, but it creates one external IP per app which can be costly and limited, explained in execution_table row 6.

What if no routing is needed for a single app?

LoadBalancer is simpler and provides direct external IP access, as shown in execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution table, what service type is chosen at step 3 when there are multiple apps?

A Ingress

B NodePort

C LoadBalancer

D ClusterIP

💡 Hint

Check the 'Chosen Service Type' column at step 3 in the execution_table.

At which step does the decision consider routing needs?

A Step 2

B Step 4

C Step 6

D Step 1

💡 Hint

Look for 'Routing needed?' in the 'Decision Point' column in the execution_table.

If you have a single app with no routing, which service type will be chosen?

A NodePort

B Ingress

C LoadBalancer

D ExternalName

💡 Hint

Refer to step 5 in the execution_table where routing is 'No'.

Concept Snapshot

Ingress vs LoadBalancer decision:
- Use LoadBalancer for single app needing direct external IP.
- Use Ingress for multiple apps or routing needs.
- Ingress shares one external IP with path/host routing.
- LoadBalancer creates one external IP per service.
- Consider cost and IP limits when choosing.

Full Transcript

This visual execution shows how to decide between Kubernetes Ingress and LoadBalancer services. First, check if you need external access. Then, decide if you have a single app or multiple apps. For a single app without routing, use LoadBalancer to get a direct external IP. For multiple apps or when routing by path or host is needed, use Ingress to share one external IP and route traffic accordingly. LoadBalancer creates one external IP per app, which can be costly and limited. The execution table traces these decisions step-by-step, and the variable tracker shows how app count, routing needs, and service type change during the decision process. Key moments clarify common confusions about when to use each service type. The quiz tests understanding by referencing the execution steps. The snapshot summarizes the decision rules for quick reference.

Practice

1. Which Kubernetes service type should you choose if you want to expose a single application with its own external IP address?

easy

A. LoadBalancer Service

B. Ingress Controller

C. ClusterIP Service

D. NodePort Service

Solution

1. Step 1: Understand service types

   LoadBalancer Service exposes an app with its own external IP, making it directly accessible.

2. Step 2: Compare with Ingress

   Ingress routes multiple apps through one IP, so it's not for single app direct exposure.

3. Final Answer:

   LoadBalancer Service -> Option A

4. Quick Check:

   Single app direct IP = LoadBalancer Service [OK]

Hint: Single app direct IP? Use LoadBalancer Service [OK]

Common Mistakes:

• Confusing Ingress with LoadBalancer for single app
• Choosing ClusterIP which is internal only
• Selecting NodePort which exposes on node ports, not external IP

2. Which of the following is the correct way to define a LoadBalancer service in a Kubernetes YAML manifest?

easy

A. apiVersion: networking.k8s.io/v1\nkind: LoadBalancer\nmetadata:\n name: my-service\nspec:\n selector:\n app: my-app\n ports:\n - protocol: TCP\n port: 80\n targetPort: 8080

B. apiVersion: v1\nkind: Service\nmetadata:\n name: my-service\nspec:\n type: Ingress\n selector:\n app: my-app\n ports:\n - protocol: TCP\n port: 80\n targetPort: 8080

C. apiVersion: v1\nkind: Service\nmetadata:\n name: my-service\nspec:\n type: NodePort\n selector:\n app: my-app\n ports:\n - protocol: TCP\n port: 80\n targetPort: 8080

D. apiVersion: v1\nkind: Service\nmetadata:\n name: my-service\nspec:\n type: LoadBalancer\n selector:\n app: my-app\n ports:\n - protocol: TCP\n port: 80\n targetPort: 8080

Solution

1. Step 1: Check apiVersion and kind

   Service resources use apiVersion: v1 and kind: Service.

2. Step 2: Confirm service type

   LoadBalancer type is set under spec.type to expose external IP.

3. Final Answer:

   YAML with kind Service and type LoadBalancer -> Option D

4. Quick Check:

   LoadBalancer service YAML uses kind Service and type LoadBalancer [OK]

Hint: LoadBalancer service uses kind Service and type LoadBalancer [OK]

Common Mistakes:

• Using kind LoadBalancer instead of Service
• Setting type to Ingress which is invalid for Service
• Confusing NodePort with LoadBalancer

3. Given this scenario: You have two apps, app1 and app2, and want to expose both externally using one IP with different paths. Which Kubernetes resource will handle this correctly?

medium

A. Two LoadBalancer Services, one for each app

B. One Ingress resource with path rules for app1 and app2

C. Two NodePort Services with different ports

D. One ClusterIP Service with multiple selectors

Solution

1. Step 1: Understand routing multiple apps on one IP

   Ingress allows routing multiple apps through one IP using path or hostname rules.

2. Step 2: Compare with LoadBalancer and others

   LoadBalancer exposes one app per IP; NodePort uses node ports, not one IP; ClusterIP is internal only.

3. Final Answer:

   One Ingress resource with path rules -> Option B

4. Quick Check:

   Multiple apps, one IP = Ingress with path rules [OK]

Hint: Multiple apps, one IP? Use Ingress with paths [OK]

Common Mistakes:

• Using multiple LoadBalancers wasting IPs
• Choosing NodePort which needs manual port management
• Thinking ClusterIP exposes externally

4. You created a LoadBalancer service but it never gets an external IP assigned. What is the most likely cause?

medium

A. You forgot to set spec.type to ClusterIP

B. Ingress controller is missing

C. Your Kubernetes cluster is running on a platform without LoadBalancer support

D. You used NodePort instead of LoadBalancer

Solution

1. Step 1: Check platform support for LoadBalancer

   Some clusters (like bare metal) do not support automatic external IP assignment for LoadBalancer services.

2. Step 2: Verify service type and controller

   Spec.type must be LoadBalancer, not ClusterIP; Ingress controller is unrelated; NodePort is different service type.

3. Final Answer:

   Platform lacks LoadBalancer support -> Option C

4. Quick Check:

   No external IP = platform lacks LoadBalancer support [OK]

Hint: No external IP? Check platform LoadBalancer support [OK]

Common Mistakes:

• Confusing ClusterIP with LoadBalancer type
• Assuming Ingress controller assigns LoadBalancer IP
• Mixing NodePort with LoadBalancer service

5. You want to minimize cloud costs while exposing 5 different apps externally. Which approach is best?

hard

A. Use one Ingress resource to route all 5 apps through a single LoadBalancer IP

B. Use ClusterIP services and expose each with a separate external IP

C. Use 5 NodePort services and expose nodes directly

D. Create 5 LoadBalancer services, one per app

Solution

1. Step 1: Understand cost implications of LoadBalancer IPs

   Each LoadBalancer service usually gets a separate external IP, increasing cloud costs.

2. Step 2: Use Ingress for cost efficiency

   Ingress lets multiple apps share one external IP with routing rules, saving costs.

3. Final Answer:

   One Ingress resource with single LoadBalancer IP -> Option A

4. Quick Check:

   Multiple apps, minimize cost = Ingress with one LoadBalancer IP [OK]

Hint: Multiple apps, one IP saves cost: use Ingress [OK]

Common Mistakes:

• Creating multiple LoadBalancers wasting IPs and money
• Using NodePort exposes nodes, less secure and complex
• ClusterIP cannot expose apps externally