How to run Pods and Services locally on Kubernetes

In order to run something on k8s we need to create a runnable unit. This can be a pod or a service.

What is a Kubernetes Pod?

A Kubernetes Pod is the smallest deployable unit on Kubernetes. It is represented by one or more Docker containers, generally tightly coupled, which are meant to be part of the same deployable unit. As such, containers within a Pod, share the Pod IP address, they can communicate with each other via localhost and they share other privileges, e.g. network and volumes.

What is a Kubernetes Service

A Kubernetes Service is an abstraction that exposes a logical set of Pods. It is generally used as the entry point for clients of exposed containers within a Pod.

How to define a Pod?

We describe Pods via YML files. In this post I’ve created a pod-helloworld.yml file.

apiVersion: v1
kind: Pod
metadata:
  name: nodehelloworld.example.com
  labels:
    app: helloworld
spec:
  containers:
  - name: k8s-course
    image: alzamabar/k8s-course:v1
    ports:
    - containerPort: 3000

The above script creates a Pod named nodehelloworld.example.com that runs the Docker image: alzamabar/k8s-course:v1 on port 3000

Having a k8s running engine

There are various ways one can run k8s locally. As of the time of writing (July 2018) I’m using the Docker Edge native client for Mac (which will eventually make its way to the stable version). However other options are available, e.g. Minikube (https://github.com/kubernetes/minikube).

Once you’ve chosen the k8s engine you want to use, make sure it’s started.

Creating the Pod from its definition

In order to create the runnable unit on k8s, the following command can be used (assuming there is a pod-helloworld.yml file in the current directory):

kubectl create -f ./helloworld.yml

pod-create-terminal-output

Accessing the pod through port-forwarding

There are various ways of exposing the Pod. One is through Pod port’s forwarding. The command is the following:

kubectl port-forward <pod-name> 8081:3000

Doing that on my laptop, the following appears on the command line:

pod-expose-port-forwarding

K8s is now listening on localhost:8081 and will forward all traffic to port 3000 (which is the k8s pod native port, as defined in the above pod definition file).

Opening the address: http://localhost:8081on my browser yielded to the following output:

hello-world-8081.png

Exposing a service on Kubernetes running locally

If you’re running k8s locally (e.g. via the Docker native client), you can create a service by expose the pod port with type NodePort as follows:

kubectl expose pod nodehelloworld.example.com --type=NodePort --name=nodehello-service

This command creates a k8s service by exposing the Pod we have already described as a NodePort type and assigning the service the name nodehello-service

Upon running this command I get the following output:

service-exposed

I can now inspect the service by running the following command:

kubectl get service

kctl-get-service.png

I can see that the k8s service is not up and running. If I want to access it, I need to access localhost on the service port, indicated under the PORT(S) column. I can see that the port is 30189 therefore to access this service from a browser I can visit the following address from a browser: http://localhost:30189

hello-world-service-port

You can achieve the same by viewing the service description through the following command:

kubectl describe service nodehello-service

On my laptop I get the following output:

kctl-describe-service

As you can see the ingress LoadBalancer is localhost and the NodePort is 30189.

Deleting the Kubernetes Pod and Service

To delete the Pod, it’s enough to run the following command (assuming there is a pod-helloworld.yml file in the current directory):

kubectl delete -f ./pod-helloworld.yml

pod-deleted

At this point the Pod is deleted but the service is still there. If you want to delete the service as well, you can run the command:

kubectl delete service nodehello-service