Kubernetes Services Explained: A Practical Hands-on Guide

Kubernetes Services in a way that I wish someone had explained to me when I first started. We’ll do this completely free on your local machine—no cloud provider needed!

What is a Kubernetes Service?

Think of a Kubernetes Service as your application’s front desk. Just as a hotel’s front desk directs guests to the fitting rooms, a Service directs traffic to your application’s pods. “A service is how you make your application available to the world.”

Types of Kubernetes Services

Let me break down the three main types of Services we use in production (yes, ExternalName exists, but in my years of Kubernetes work, I’ve rarely seen it used):

1. ClusterIP: Think of this as your internal office phone extension – only accessible within the building (cluster)
2. NodePort: Like giving out your office’s direct phone number – accessible from outside but through a specific port
3. LoadBalancer: Similar to having a professional reception service – handles external traffic distribution elegantly

Before we begin, make sure you have the following set up on your computer:

• Docker
• Kind (Kubernetes in Docker)

If you haven’t installed these tools yet, don’t worry! Check out the links in the video description for my tutorials on installing them on Windows, Mac, and Ubuntu.

Ubuntu – Kind / Docker

Mac – Kind / Docker

Windows – Kind / Docker

Hands-on Demo

Let’s get our hands dirty! I’ve created a Makefile that makes this super easy to follow along. Here’s how we’ll do it step by step:

1. Setting Up Our Playground

First, let’s create our local Kubernetes cluster:

make create-cluster

This command creates a Kind cluster named “services” using our custom configuration:

kind create cluster --name services --config kind/kind-config.yaml

2. Deploying Our Test Application

Let’s deploy a simple nginx application:

make create-deployment
make apply-deployment

Behind the scenes, this creates a deployment YAML with:

kubectl create deployment service --image nginx:latest --port 80 --replicas 1

3. Creating Different Service Types

Now, let’s create all three service types to see how they work:

ClusterIP Service

make create-svc-ClusterIP

This creates an internal service only accessible within the cluster:

kubectl expose deployment service --name service-cluster-ip --port 80 --target-port 80 --type ClusterIP

NodePort Service

make create-svc-NodePort

This exposes the service on each node’s IP at a static port:

kubectl expose deployment service --name service-node-port --port 80 --target-port 80 --type NodePort

LoadBalancer Service

make create-svc-LoadBalancer

This creates a load balancer service:

kubectl expose deployment service --name service-load-balancer --port 80 --target-port 80 --type LoadBalancer

4. Applying and Checking Our Services

Let’s apply all our services and check their status:

make apply-svc
make check-svc

5. Testing Access

Here’s a neat trick – we can use port forwarding to access our ClusterIP service:

make port-forward

This forwards localhost:8888 to our service’s port 80:

kubectl port-forward svc/service-cluster-ip 8888:80

When to Use Each Service Type

Here’s my rule of thumb after years of working with Kubernetes:

• Use ClusterIP for internal services (service-to-service communication)
• Use NodePort for development and testing
• Use LoadBalancer for production applications that need external access
• Consider using Ingress with ClusterIP when you need path-based routing and domain management

Clean Up

When you’re done experimenting, clean everything up:

make delete-all

Pro Tips From the Field

1. Always start with ClusterIP if you’re not sure – you can change the service type later
2. NodePort services are excellent for development but rarely used in production
3. Remember that each LoadBalancer service gets its own IP – this can get expensive in cloud environments
4. Use labels consistently – they’re crucial for service selection

Conclusion

Understanding Kubernetes Services is crucial for any containerized application. Start with these basics, and you’ll be well on your way to mastering Kubernetes networking.

Remember: the best way to learn is by doing. Run this code on your machine and experiment with different configurations. Break things – that’s how we all knew!