ClusterIP service type in Kubernetes - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a ClusterIP service in Kubernetes?

A ClusterIP service exposes the service on an internal IP in the cluster. It is reachable only within the cluster and not from outside.

intermediate

How does a ClusterIP service route traffic to pods?

It uses kube-proxy to route requests sent to the ClusterIP to one of the backend pods selected by labels.

beginner

Which use case fits best for a ClusterIP service?

When you want to expose a service only inside the cluster, for example, for internal communication between microservices.

beginner

What is the default service type in Kubernetes if none is specified?

ClusterIP is the default service type if you do not specify any other type.

beginner

Can a ClusterIP service be accessed from outside the Kubernetes cluster?

No, ClusterIP services are only accessible inside the cluster. To access from outside, use NodePort or LoadBalancer types.

What does a ClusterIP service expose?

A An internal IP accessible only inside the cluster

B An external IP accessible from the internet

C A port on each node

D A load balancer IP

ClusterIP exposes an internal IP reachable only within the Kubernetes cluster.

Which Kubernetes service type allows external access by default?

A None

B ClusterIP

C Headless

D NodePort

NodePort exposes the service on a port on each node, allowing external access.

What is the default service type if none is specified in Kubernetes?

A LoadBalancer

B ClusterIP

C NodePort

D ExternalName

ClusterIP is the default service type in Kubernetes.

How does a ClusterIP service select which pods to send traffic to?

A By matching labels on pods

B Randomly without any selection

C By pod IP addresses only

D By node IP addresses

ClusterIP services use label selectors to route traffic to matching pods.

Can you access a ClusterIP service from outside the Kubernetes cluster?

A Yes, always

B No, never

C Only if you use port forwarding

D Only with LoadBalancer

ClusterIP services are internal, but you can access them externally using port forwarding or proxies.

Explain what a ClusterIP service is and when you would use it.

Think about services that do not need to be exposed outside the cluster.

Describe how Kubernetes routes traffic to pods using a ClusterIP service.

Focus on how the service finds the right pods to send requests to.

Practice

1. What is the primary purpose of a ClusterIP service in Kubernetes?

easy

A. To create a load balancer outside the cluster

B. To expose the service to the internet with a public IP

C. To assign a static external IP to the service

D. To provide an internal IP for pods to communicate within the cluster

Solution

1. Step 1: Understand ClusterIP service role

   ClusterIP is designed to create an internal IP address accessible only inside the Kubernetes cluster.

2. Step 2: Compare with other service types

   Other types like NodePort or LoadBalancer expose services externally, but ClusterIP does not.

3. Final Answer:

   To provide an internal IP for pods to communicate within the cluster -> Option D

4. Quick Check:

   ClusterIP = internal communication [OK]

Hint: ClusterIP is for internal pod communication only [OK]

Common Mistakes:

• Confusing ClusterIP with LoadBalancer or NodePort
• Thinking ClusterIP exposes service externally
• Assuming ClusterIP assigns static external IP

2. Which of the following YAML snippets correctly defines a ClusterIP service?

easy

A. apiVersion: v1
kind: Pod
metadata:
name: my-service
spec:
containers:
- name: myapp
image: nginx

B. apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
type: NodePort
selector:
app: myapp
ports:
- protocol: TCP
port: 80
targetPort: 8080

C. apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
type: ClusterIP
selector:
app: myapp
ports:
- protocol: TCP
port: 80
targetPort: 8080

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

Solution

1. Step 1: Check service type and selector

   apiVersion: v1 kind: Service metadata: name: my-service spec: type: ClusterIP selector: app: myapp ports: - protocol: TCP port: 80 targetPort: 8080 uses type: ClusterIP and has a proper selector and ports defined.

2. Step 2: Validate other options

   apiVersion: v1 kind: Service metadata: name: my-service spec: type: NodePort selector: app: myapp ports: - protocol: TCP port: 80 targetPort: 8080 uses NodePort, not ClusterIP. apiVersion: v1 kind: Pod metadata: name: my-service spec: containers: - name: myapp image: nginx is a Pod, not a Service. apiVersion: v1 kind: Service metadata: name: my-service spec: type: LoadBalancer selector: app: myapp ports: - protocol: UDP port: 80 targetPort: 8080 uses type: LoadBalancer, not ClusterIP.

3. Final Answer:

   YAML with type ClusterIP, selector, and TCP port -> Option C

4. Quick Check:

   Correct YAML = apiVersion: v1 kind: Service metadata: name: my-service spec: type: ClusterIP selector: app: myapp ports: - protocol: TCP port: 80 targetPort: 8080 [OK]

Hint: ClusterIP service YAML must specify type: ClusterIP [OK]

Common Mistakes:

• Using wrong service type like NodePort
• Confusing Pod definition with Service
• Omitting service type field

3. Given this service YAML with type ClusterIP, what will be the output of kubectl get svc my-service?

medium

A. NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-service ClusterIP 10.96.0.1 <none> 80/TCP 5m

B. NAME TYPE EXTERNAL-IP PORT(S) AGE
my-service LoadBalancer 192.168.1.1 80/TCP 5m

C. Error: service not found

D. NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-service NodePort 10.96.0.1 <none> 80:30080/TCP 5m

Solution

1. Step 1: Understand ClusterIP service output

   ClusterIP services show a cluster internal IP and no external IP.

2. Step 2: Match output format

   NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE my-service ClusterIP 10.96.0.1 <none> 80/TCP 5m shows ClusterIP type with a cluster IP and <none> external IP, matching expected output.

3. Final Answer:

   Service listed with ClusterIP and no external IP -> Option A

4. Quick Check:

   ClusterIP service output = NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE my-service ClusterIP 10.96.0.1 <none> 80/TCP 5m [OK]

Hint: ClusterIP services have no external IP in kubectl output [OK]

Common Mistakes:

• Expecting external IP for ClusterIP service
• Confusing LoadBalancer or NodePort output
• Assuming service not found error

4. You created a ClusterIP service but pods cannot reach it. Which YAML mistake could cause this?

medium

A. Using type: LoadBalancer instead of ClusterIP

B. Missing or incorrect selector labels in the service spec

C. Specifying targetPort as a string instead of a number

D. Omitting the metadata section

Solution

1. Step 1: Identify service selector role

   The selector connects the service to the correct pods. If missing or wrong, no pods match.

2. Step 2: Evaluate other options

   Type LoadBalancer changes exposure but doesn't block pod access. targetPort as string is accepted. metadata omission causes other errors but not pod reachability.

3. Final Answer:

   Missing or incorrect selector labels -> Option B

4. Quick Check:

   Selector connects pods = Missing or incorrect selector labels in the service spec [OK]

Hint: Check selector labels to link service and pods [OK]

Common Mistakes:

• Ignoring selector labels importance
• Blaming service type for pod connectivity
• Confusing metadata omission with connectivity issues

5. You want to expose a web app only inside your Kubernetes cluster using a ClusterIP service. Which combination of YAML fields ensures this?

hard

A. spec:
type: ClusterIP
selector:
app: webapp
ports:
- port: 80
targetPort: 8080

B. spec:
type: NodePort
selector:
app: webapp
ports:
- port: 80
targetPort: 8080

C. spec:
type: LoadBalancer
selector:
app: webapp
ports:
- port: 80
targetPort: 8080

D. spec:
ports:
- port: 80
targetPort: 8080

Solution

1. Step 1: Confirm service type for internal exposure

   ClusterIP is the default and only exposes service inside the cluster.

2. Step 2: Verify selector and ports

   Selector must match pods, and ports must map correctly for traffic routing.

3. Final Answer:

   YAML with type ClusterIP, correct selector, and ports -> Option A

4. Quick Check:

   ClusterIP + selector + ports = spec: type: ClusterIP selector: app: webapp ports: - port: 80 targetPort: 8080 [OK]

Hint: Use type ClusterIP with correct selector for internal-only service [OK]

Common Mistakes:

• Using NodePort or LoadBalancer for internal-only access
• Omitting service type defaults to ClusterIP but unclear
• Incorrect or missing selector causing no pod matching