Kubernetes is an open source system for automating deployment, scaling and management of containerized applications. A more technical term for it is, container orchestrator which is used to manage large fleets of containers.
Minikube is an all-in-one single node installation for trying out kubernetes on local machines. And the following post covers deploying a nginx application container using kubernetes in minikube.
If you don’t have, then this link has it all to install minikube and kubectl (command line tool to access minikube) : Download and install minikube and kubectl
Step 1 : Making minikube up and running
Ensure that minikube is running.
Step 2 : Open the minikube dashboard
Minikube comes with a GUI tool that opens in the web browser. Open the minikube dashboard with following command :
It should open the dashboard in a browser window and it’ll look something like this:
Looks cool! No?
Step 3 : Deploy a webserver using the nginx:alpine image
Alpine linux is preferred for containers because of its small size. We’ll be using the nginx:alpine docker image to deploy a nginx powered webserver.
Now, go the deployments section and click the create button, which will open an interface like below.
Fill in the details as shown in the image.
We can either provide the application details here, or we can upload a YAML file with our Deployment details.
As shown, we are asking kubernetes to create a deployment with nginx:alpine image as container and that we want 3 pods (or simply instances) of that.
A pod in kubernetes is a scheduling unit, a logical collection of one or more containers that are always scheduled together.
Go on and click that awesome deploy button!
Step 4 : Analyzing the deployment
Once we click the deploy button. Kubernetes will trigger the deployment. Deployment will create a ReplicaSet. A ReplicaSet is a replication controller that ensures that specified number of replicas for a pod are running at any given point of time.
Flow is something like this:
Deployment create ReplicaSets, ReplicaSets create Pods. Pods is where the real application resides.
As expected, we have our deployment, replica set and pods in place.
We can also, check our deployment via command line using kubectl.
Step 5 : Create a Service and expose it to the external world with NodePort
So far, we have our pods up and running. But how do we access them?
This is where a service comes into play. K8S provides a higher level abstraction called as a service that logically groups pods and policy to access them. This grouping is done via labels and selectors.
Then we expose the service to the world by defining its service type and service redirects our request to one of the pod and load balances them.
Create a my-nginx-webserver.yaml file with the following content:
apiVersion: v1 kind: Service metadata: name: my-nginx-web-service labels: run: my-nginx-web-service spec: type: NodePort ports: - port: 80 protocol: TCP selector: app: my-nginx-webserver
Enter the following commands to create a service name my-nginx-web-service
We can now verify that our service is running :
Step 6 : Accessing the application
Our application is running inside the minikube VM. To access the application from our workstation, let’s first get the IP address of the minikube VM:
Now head to the address and port number of the service we got in above step.
And our app is running! Amazing, give yourself a pat now!
Taste of self-healing feature of the kubernetes system :
One of the most powerful feature of kubernetes is self-healing capabilities (just like Piccolo. DBZ, anyone?). While defining our app we created a replica set with 3 pods. Let’s go ahead and kill one pod and kubernetes wil create another one to maintain the running pod count 3.
As we can see in the image. We deleted the bottom-most pod and K8S created a new one instantly.
Such kubernetes! Much HA (High Availability)!
Taste of scaling with Kubernetes:
Now, our app is receiving a crazy amount of traffic and three nginx pods are not enough to handle the load. Kubernetes allows us to scale our deployments with almost zero effort.
Let’s go ahead and spin up a new pod.
Click OK. Now let’s go and check our pods.
As we can see in the image, we have now 4 pods running to handle the increased traffic.
Isn’t it amazing? We just horizontally scaled our application with the power of kubernetes.
This was just the tip of the iceberg what Kubernetes can do. I am also exploring the kubernetes and containerized architecture just like you, hopefully we’ll be back with another post soon with more kubernetes stuff!
Leave a Reply