Path-based routing in Kubernetes - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to specify the path for routing in the Ingress rule.

Kubernetes

paths:
  - path: [1]
    pathType: Prefix
    backend:
      service:
        name: my-service
        port:
          number: 80

Drag options to blanks, or click blank then click option'

A/api

Bapi

Chttp://api

D/*

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the leading slash in the path

Using wildcard characters like '*' incorrectly

The path must start with a slash '/' to define the route correctly in Kubernetes Ingress.

2fill in blank

medium

Complete the code to set the pathType for prefix-based routing.

Kubernetes

paths:
  - path: /app
    pathType: [1]
    backend:
      service:
        name: app-service
        port:
          number: 8080

Drag options to blanks, or click blank then click option'

AWildcard

BExact

CImplementationSpecific

DPrefix

Attempts:

3 left

💡 Hint

Common Mistakes

Using Exact when prefix matching is needed

Using invalid pathType values

For path-based routing that matches all paths starting with the given prefix, use Prefix as the pathType.

3fill in blank

hard

Fix the error in the Ingress rule by completing the backend service port number.

Kubernetes

rules:
- http:
    paths:
    - path: /web
      pathType: Prefix
      backend:
        service:
          name: web-service
          port:
            number: [1]

Drag options to blanks, or click blank then click option'

A80

Beighty

Chttp

D8080

Attempts:

3 left

💡 Hint

Common Mistakes

Using protocol names instead of port numbers

Using strings instead of integers for port

The port number must be an integer, such as 80, not a string or protocol name.

4fill in blank

hard

Fill both blanks to complete the Ingress rule for routing /blog and /shop paths to their services.

Kubernetes

rules:
- http:
    paths:
    - path: [1]
      pathType: Prefix
      backend:
        service:
          name: blog-service
          port:
            number: 80
    - path: [2]
      pathType: Prefix
      backend:
        service:
          name: shop-service
          port:
            number: 8080

Drag options to blanks, or click blank then click option'

A/blog

B/store

C/shop

Dblog

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the leading slash

Using incorrect path names

Paths must start with a slash and match the intended route names exactly.

5fill in blank

hard

Fill all three blanks to create a dictionary of paths with their backend service names and ports.

Kubernetes

paths_dict = {
  [1]: {
    "service": [2],
    "port": [3]
  }
}

Drag options to blanks, or click blank then click option'

A"/api"

B"api-service"

C80

D"/app"

Attempts:

3 left

💡 Hint

Common Mistakes

Missing quotes around strings

Using strings for port numbers

The dictionary key is the path string, the service is the service name string, and the port is the integer port number.

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