Path-based routing in Kubernetes - Step-by-Step Execution

Process Flow - Path-based routing

Incoming HTTP Request

↓

Check URL Path

↓

Route to Service1

↓

Response

Incoming requests are checked for their URL path and routed to different services based on the path prefix.

Execution Sample

Kubernetes

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - http:
      paths:
      - path: /app1
        pathType: Prefix
        backend:
          service:
            name: service1
            port:
              number: 80
      - path: /app2
        pathType: Prefix
        backend:
          service:
            name: service2
            port:
              number: 80

Ingress resource routes requests with path /app1 to service1 and /app2 to service2.

Process Table

Step	Incoming Request Path	Path Match Check	Service Routed To	Action
1	/app1/home	Matches /app1 prefix	service1	Request routed to service1
2	/app2/dashboard	Matches /app2 prefix	service2	Request routed to service2
3	/app3/info	No matching path prefix	default backend or 404	Request routed to default or rejected

💡 Routing stops after matching the first path prefix or falls back to default backend.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
request_path	none	/app1/home	/app2/dashboard	/app3/info
matched_path	none	/app1	/app2	none
routed_service	none	service1	service2	default backend or 404

Key Moments - 2 Insights

Why does a request to /app3/info not get routed to service1 or service2?

Because /app3 does not match any defined path prefixes (/app1 or /app2) in the ingress rules, so it goes to the default backend or returns 404 as shown in execution_table row 3.

What happens if two paths overlap, like /app and /app1?

The ingress controller matches the first path prefix that fits the request path. Order matters, so the more specific path should be listed first to avoid unexpected routing.

Visual Quiz - 3 Questions

Look at the execution table, which service handles the request path '/app2/dashboard'?

A service1

B service2

C default backend

D No service

💡 Hint

Check execution_table row 2 under 'Service Routed To'

At which step does the routing fall back to the default backend or 404?

A Step 1

B Step 2

C Step 3

D Never

💡 Hint

Look at execution_table row 3 'Path Match Check' and 'Service Routed To'

If a new path /app is added before /app1, which service will handle '/app1/home' requests?

A service for /app

B default backend

C service1

D No service

💡 Hint

Path matching uses first match order; adding /app before /app1 changes routing as per key_moments explanation

Concept Snapshot

Path-based routing in Kubernetes Ingress:
- Define multiple paths under rules.http.paths
- Use pathType: Prefix for prefix matching
- Requests routed to backend service matching first path prefix
- Order of paths matters for overlapping prefixes
- Unmatched paths go to default backend or 404

Full Transcript

Path-based routing in Kubernetes Ingress works by checking the incoming HTTP request's URL path. The ingress controller compares the path against defined prefixes in the ingress rules. When a match is found, the request is routed to the corresponding backend service. If no path matches, the request goes to the default backend or returns a 404 error. The order of path definitions is important because the first matching prefix is used for routing. This allows different services to handle different parts of a website or application based on URL paths.

Practice

1. What does path-based routing in Kubernetes Ingress do?

easy

A. It sends traffic to different services based on URL paths.

B. It balances traffic evenly between all nodes.

C. It encrypts traffic between pods.

D. It schedules pods on specific nodes.

Solution

1. Step 1: Understand Ingress role

   Kubernetes Ingress manages external access to services, often HTTP.

2. Step 2: Identify path-based routing function

   Path-based routing directs requests to services depending on the URL path.

3. Final Answer:

   It sends traffic to different services based on URL paths. -> Option A

4. Quick Check:

   Path-based routing = directing traffic by URL path [OK]

Hint: Remember: path-based routing matches URL paths to services [OK]

Common Mistakes:

• Confusing path-based routing with load balancing
• Thinking it schedules pods
• Assuming it encrypts traffic

2. Which is the correct way to specify a path in a Kubernetes Ingress rule for path-based routing?

easy

A. url: /app
urlType: Prefix

B. route: /app
routeType: Exact

C. servicePath: /app
serviceType: Exact

D. path: /app
pathType: Prefix

Solution

1. Step 1: Recall Ingress rule syntax

   Ingress rules use path and pathType keys to define routing.

2. Step 2: Match correct keys and values

   Correct keys are path and pathType, with values like '/app' and 'Prefix'.

3. Final Answer:

   path: /app pathType: Prefix -> Option D

4. Quick Check:

   Use path and pathType keys for routing [OK]

Hint: Look for 'path' and 'pathType' keys in Ingress rules [OK]

Common Mistakes:

• Using wrong keys like 'route' or 'url'
• Mixing up pathType values
• Missing pathType field

3. Given this Ingress snippet, which service will receive traffic for URL path '/shop/cart'?

rules:
- http:
    paths:
    - path: /shop
      pathType: Prefix
      backend:
        service:
          name: shop-service
          port:
            number: 80
    - path: /blog
      pathType: Prefix
      backend:
        service:
          name: blog-service
          port:
            number: 80

medium

A. blog-service

B. shop-service

C. default backend

D. No service matches

Solution

1. Step 1: Check path matching rules

   Path '/shop/cart' starts with '/shop', matching the first path rule with pathType Prefix.

2. Step 2: Identify backend service

   The matching path routes to 'shop-service' on port 80.

3. Final Answer:

   shop-service -> Option B

4. Quick Check:

   Prefix match '/shop' routes to shop-service [OK]

Hint: Prefix path matches any URL starting with it [OK]

Common Mistakes:

• Choosing blog-service for /shop/cart
• Assuming no match for subpaths
• Confusing default backend with path rules

4. You wrote this Ingress rule but traffic to '/api' is not routed correctly:

paths:
- path: api
  pathType: Prefix
  backend:
    service:
      name: api-service
      port:
        number: 80

What is the likely error?

medium

A. Incorrect pathType value

B. Service name is invalid

C. Missing leading slash in path value

D. Port number must be a string

Solution

1. Step 1: Check path syntax

   Paths must start with a leading slash '/' to match URLs correctly.

2. Step 2: Identify missing slash

   The path is 'api' instead of '/api', so it won't match requests starting with '/api'.

3. Final Answer:

   Missing leading slash in path value -> Option C

4. Quick Check:

   Paths need leading '/' for correct matching [OK]

Hint: Always start path with '/' in Ingress rules [OK]

Common Mistakes:

• Omitting leading slash in path
• Using wrong pathType values
• Assuming port number must be string

5. You want to route traffic so that: - '/app' goes to 'app-service' - '/app/admin' goes to 'admin-service' Which Ingress path rules correctly implement this path-based routing?

hard

A. - path: /app/admin
pathType: Prefix
backend:
service:
name: admin-service
port:
number: 80
- path: /app
pathType: Prefix
backend:
service:
name: app-service
port:
number: 80

B. - path: /app
pathType: Prefix
backend:
service:
name: app-service
port:
number: 80
- path: /app/admin
pathType: Prefix
backend:
service:
name: admin-service
port:
number: 80

C. - path: /app
pathType: Exact
backend:
service:
name: app-service
port:
number: 80
- path: /app/admin
pathType: Exact
backend:
service:
name: admin-service
port:
number: 80

D. - path: /app/admin
pathType: Exact
backend:
service:
name: admin-service
port:
number: 80
- path: /app
pathType: Exact
backend:
service:
name: app-service
port:
number: 80

Solution

1. Step 1: Understand path matching order

   Ingress matches paths in order; more specific paths must come first to avoid being shadowed.

2. Step 2: Check rule order and pathType

   Placing '/app/admin' before '/app' with pathType Prefix ensures '/app/admin' routes to admin-service, others to app-service.

3. Final Answer:

   Place '/app/admin' rule before '/app' rule with Prefix pathType -> Option A

4. Quick Check:

   Order specific paths first for correct routing [OK]

Hint: List longer paths before shorter ones in Ingress rules [OK]

Common Mistakes:

• Placing general path before specific path
• Using Exact pathType causing no subpath matches
• Ignoring rule order importance