Author: Ujwal Pachghare
In this tutorial, we will walk through the process of deploying a Mario game on Kubernetes (k8s) nodes. This includes creating the necessary manifests, applying them, and testing the deployment.
In the previous tutorial we have deployed Super-Mario game in docker with the help of multi container manager docker compose and inspection technique. if your interested you follow this tutorial “Deploy Super-Mario on Docker with Docker Compose by using Inspecting Technique” here.
In this tutorial the only prerequisite is to have fully setup a Kubernetes cluster with Kops. if you wanna learn how to setup highly available local Kubernetes cluster with Kops, you can follow this tutorial “Setting Up Local Kubernetes Cluster with Kops” here.
Step 1: Confirm Kubernetes Setup
In the previous tutorial we learn that ap-south-1c availability zone doesn`t support k8s deployment. so make the cluster in North Verginia region, because this region provide us 6 availability zones which helps to create highly available Kubernetes environment.
let’s ensure that all Kubernetes objects and services are up and running. Use the following command:
kubectl get all -A
Ensure your master node is connected to slave nodes:
kubectl get nodes -o wide
Step 2: Create Kubernetes Manifests
Next, we’ll create a new directory and namespace for storing our Kubernetes manifests:
mkdir mario && cd mario
kubectl create ns mario
Now, we’ll create several YAML files for our deployment:
Deployment Manifest
cat << EOF > mario-deploy.yml
apiVersion: apps/v1
kind: Deployment
metadata:
name: mario-deploy
labels:
app: mario-app
spec:
replicas: 2
selector:
matchLabels:
app: mario-app
template:
metadata:
labels:
app: mario-app
spec:
containers:
- name: mario-con
image: uj5ghare/mario:80
ports:
- containerPort: 80
volumeMounts:
- name: mario-vol
mountPath: /volume
volumes:
- name: mario-vol
persistentVolumeClaim:
claimName: mario-pvc
EOF
we will create Deployment Manifest for providing Auto Healing feature to our pods and application. Deployment will ensure that our pods are running and in healthy condition it will reduce the downtime of our application by 80–90 percent, in some cases it provide zero downtime.
Service Manifest
cat << EOF > mario-svc.yml
apiVersion: v1
kind: Service
metadata:
name: mario-svc
spec:
selector:
app: mario-app
ports:
- protocol: TCP
port: 80
targetPort: 80
type: LoadBalancer
EOF
we will apply Service on deployment to expose our application outside the world. Service gave power to decide from where our application should be accessed. it could be inside the cluster only with ClusterIP, outside the nodes only by IP with NodePort, and expose to public with LoadBalancer DNS.
StorageClass Manifest
cat << EOF > mario-sc.yml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: mario-sc
provisioner: kubernetes.io/aws-ebs
parameters:
type: gp2
fsType: ext4
EOF
StorageClass is work as shelfs for persistence volume claim. we can create different shelfs with deferent types of configurations. Ex: 8GB SSD and 8GB HDD
we just have to connect PVC to the StorageClass other things will be handled by Kubernetes. so, Kubernetes will create PVC for us according to our StorageClass configuration automatically.
Persistent Volume Manifest
cat << EOF > mario-pvc.yml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mario-pvc
spec:
accessModes:
- ReadWriteOnce
storageClassName: my-storage-class
resources:
requests:
storage: 4Gi
EOF
PV means persistent storage which helps prevent data loss. we can create PV also but according to our situation we don't need to create PV because we already have defined storage class so it will take care of the volume.
PVC gave power to apply persistent volume according to our needs. we can define how much persistent volume can be claimed by our application pods.
Horizontal Pod AutoScaller Manifest
cat << EOF > mario-hpa.yml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: mario-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: mario-deployment
minReplicas: 1
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50
EOF
The Horizontal Pod Autoscaler (HPA) plays a significant role in Kubernetes. It is responsible for the autoscaling of application pods.
Kubernetes does not offer a built-in HPA tool. To enable HPA in our cluster, we need to install a third-party tool called Metric Server, which will automatically scale our pods.
This tool helps reduce downtime and increase the durability and high availability of our application pods.
Install Metric-Server
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.4.1/components.yaml
Step 3: Apply the Manifest
With our YAML files ready, we can apply the manifests. To apply all the manifests in Mario namespace run this command:
kubectl apply -f . -n mario
Step 4: Confirm all Objects are Up and Running
Let’s confirm that all objects and services are up and running:
kubectl get all -n mario
Step 5: Test the Deployment of Mario
To test our deployment, we’ll get the service for our Mario game:
kubectl get svc mario-svc -n mario
Copy the Load Balancer DNS (which is the External IP) and paste it into a browser to play the game!
If you wanna expose service with NodePort, so just change the Service type LoadBalancer to NodePort and then apply changes again.
make sure you have to copy public IP of slave nodes to test the deployment and then paste in on web browser. you can see this type of UI.
Step 6: Clean Up
Once you’re done, you can delete all manifests:
kubectl delete -f . -n mario
And finally, delete the cluster:
kops delete cluster --name=$KOPS_CLUSTER_NAME --state=$KOPS_STATE_STORE --yes
And that’s All! You’ve successfully deployed a Mario game on Kubernetes nodes.