Deploying Your First Docker Image Using Kubernetes: A Step-by-Step Guide

Deploying a Docker image via Kubernetes can seem daunting at first, but with this comprehensive guide, you'll be able to deploy your first Docker image with ease. Follow these steps to get your application up and running using Kubernetes and Minikube.

Prerequisites

Before starting, make sure you have kubectl and Minikube installed on your local machine. Verify the installations by executing the following commands:

command: kubectl version --client
command: minikube status

If you have not already installed Minikube and kubectl, or if you encounter errors, refer to our installation guide: Introduction to Kubernetes and Minikube Installation.

Step-by-Step Guide to Deploying via Kubernetes

1. Create a Deployment

First, you need to create a deployment. Use the following command, replacing deploymentName with your desired deployment name and imageName with your Docker image name:

command: kubectl create deployment deploymentName --image=imageName

2. Verify the Deployment

To ensure that your deployment and pods are running, execute:

command: kubectl get deployments
command: kubectl get pods

3. Bind the Port

Next, bind the port. Assuming your Docker image exposes port 3000 internally, you can expose this port externally using the following command

command:kubectl expose deployment deploymentName --type=LoadBalancer --port=3000

4. Notify Minikube

Finally, inform Minikube about the service. This will provide you with a URL to access your application. Run:
command: minikube service deploymentName

Copy the provided URL and paste it into your browser to see your application in action.

Rolling Out Updates

Once your application is deployed, you might need to update it. Rolling out updates in Kubernetes is straightforward. Use the following command to update your deployment with a new image version:

command: kubectl set image deployment deploymentName containerName=newImageName:newTag

Verify the rollout status with the command: kubectl rollout status deployment deploymentName

now you can see on the same service/url my updated image is running

Rolling Back Updates

If something goes wrong with your update, you can easily roll back to the previous version. Use the following command to roll back the deployment:

command:kubectl rollout undo deployment/deploymentName

after running the rollout undo command hit your Project URL again you will see your project is rolled back to the previous version

Conclusion

By following these steps, you can easily deploy your first Docker image using Kubernetes and Minikube. This guide helps streamline the process, ensuring a successful deployment. With these foundational skills, you can explore more advanced features of Kubernetes and enhance your containerized applications further.

For more detailed information on Kubernetes and Docker, check out our other blog posts and tutorials. Happy deploying!

Introduction to Kubernetes

Kubernetes, often abbreviated as K8s, is a powerful open-source platform designed to automate deploying, scaling, and operating application containers. Here's a quick overview of its key concepts:

Nodes: Individual servers in the Kubernetes architecture.
Cluster: A group of nodes working together.
Pods: The smallest deployable units in Kubernetes, which run containers on nodes.

Master Components of Kubernetes

The Kubernetes master components manage the cluster and its workload:

API Server: Provides the CLI and RESTful API interface for interaction.
Scheduler: Assigns nodes to newly created pods.
ETCD: A key-value store that holds the entire cluster's state, including nodes and pods.
Control Manager: Ensures the desired state of the cluster is maintained.

Worker Node Components

Worker nodes run the applications and perform the following functions:

Kubelet: Ensures that containers are running in pods.
Kube Proxy: Manages network rules to enable communication with pods.
Container Runtime: Runs the containers.

Kubernetes Installation on Red Hat Linux

Step 1: Install Kubectl

1. Update the Repository:

command: "cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo

[kubernetes]

name=Kubernetes

baseurl=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/

enabled=1

gpgcheck=1

gpgkey=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/repodata/repomd.xml.key

EOF

2. Install Kubectl:

command: sudo yum install -y kubectl

3. Verify Installation:

command: kubectl version --client

Step 2: Install Minikube

Minikube is a tool that makes it easy to run Kubernetes locally, ideal for learning and development purposes.

1. Download Minikube:

command: curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-latest.aarch64.rpm

2. Install Minikube:

command: sudo rpm -Uvh minikube-latest.aarch64.rpm

3. Start Minikube:

command: minikube start

Handling Sudo User Permission Errors

If you encounter permission errors as a sudo user, follow these steps

- Switch User:

if you are logged in as a sudo user switch to any other use or create a new user I have user Danish already

command: su - username

- Add User to Docker Group:

command: sudo usermod -aG docker $USER && newgrp docker

after adding this user to the group now start the minikube again

- Edit the Sudoers File (if still getting error):

Use visudo to add your user, ensuring proper permissions
After resolving permissions, run: minikube start

Check Minikube Status:

To check the status of the running status of the minikube run the following command
command: minikube status

By following these steps, you can effectively set up and manage a Kubernetes environment on Red Hat Linux. This guide should help you get started with Kubernetes, providing a strong foundation for further exploration and learning.