Stories by Aditya Girigoudar on Medium

<h4>Hands-on with Kubernetes using minikube</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*slnPhDmkoH1_myc4"><figcaption>Photo by <a href="https://unsplash.com/@chriscantlose?utm_source=medium&amp;utm_medium=referral">Christopher Luther</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Introduction</h3>
Hey guys, welcome to my series of blogs on Kubernetes, where I will be covering most of the concepts related to Kubernetes. This is the fifth and last blog of the series. Let’s begin!
Now that you have learnt about the basics of Kubernetes and its architecture in my previous blog; let’s get some hands-on experience with Kubernetes with Minikube.
What is Minikube? Minikube is a tool which allows the user to run a Kubernetes cluster on their local machine with all the necessary components such as the API server, etcd, kubelet, and kubectl. It is mainly created to help users to developers to learn, test, deploy and experiment with Kubernetes so that you don’t have to launch a Kubernetes on production-level. Minikube can run on various platforms including Linux, MacOS and Windows.
You can learn about Minikube <a href="https://minikube.sigs.k8s.io/docs/">here</a>.
Alright! Enough theory. Let’s setup Minikube locally on our machine and play with it.
<h4>Installing Minikube</h4>
<ol>
<li>For Linux: <a href="https://www.fosstechnix.com/how-to-install-minikube-on-ubuntu-22-04-lts/">How to Install Minikube on Ubuntu 22.04 LTS (fosstechnix.com)</a>
</li>
<li>For Windows: <a href="https://www.shellhacks.com/install-minikube-on-windows/">Install Minikube on Windows — ShellHacks</a>
</li>
<li>For MacOS: <a href="https://medium.com/@javatechie/kubernetes-tutorial-install-run-minikube-in-mac-os-k8s-cluster-369b25b0c3f0">Kubernetes Tutorial | Install &amp; Run Minikube in mac OS | K8s Cluster | by Java Techie | Medium</a>
</li>
</ol>
Nice. Now that you have installed minikube on your local machine, let’s get some hands-on experience with it.
When you use the below command,
<pre>minikube start</pre>
you might have noticed the last line in the terminal and noticed the word “namespace”. What does “namespace” mean?
<pre>🏄 Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default</pre>
Namespace in Kubernetes is a way to divide/organise cluster resources into virtual sub-clusters. By default, Kubernetes clusters have a “default” namespace, but you can create additional namespaces to organise and isolate resources according to your needs and requirements. Namespaces help in:
<ol>
<li>Resource isolation</li>
<li>Access control</li>
<li>Resource quotas and</li>
<li>Name management</li>
</ol>
Let’s see some of the commonly used commands in Kubernetes. The syntax for the kubectl is
<pre>kubectl [command] [TYPE] [NAME] [flags]</pre>
command: The command portion describes what sort of operation you want to perform — namely create, describe, get, apply, and delete. TYPE: The TYPE attribute describes the kind of resource kubectl is targeting. NAME: The NAME field is case sensitive and specifies the name of the resource in question. Flags: Finally, flags help denote special options or requests made to a certain resource. They work as modifiers that override any default values or environmental variables.
<h3>Pods</h3>
To list all pods
<pre>kubectl get pods -A</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*Joqy5TkJnY2MrtsiCI7XFA.png"></figure>Pro tip: To create, update, delete or read resources for a particular namespace, use the flag -n namespace
<pre>kubectl get pods -n &lt;namespace&gt;</pre>
To list all running pods
<pre>kubectl get pods --field-selector=status.phase=Running</pre>
To get logs for a pod
<pre>kubectl logs &lt;pod_name&gt; -n &lt;namespace&gt;</pre>
To create a pod
<pre>kubectl create pod &lt;pod_name&gt;</pre>
To delete a pod
<pre>kubectl delete pod &lt;pod_name&gt;</pre>
To execute a command against a container in a pod
<pre>kubectl exec &lt;pod_name&gt; -c &lt;container_name&gt; &lt;command&gt;</pre>
To get into the interactive shell on a a single-container pod
<pre>kubectl exec -it &lt;pod_name&gt; /bin/bash</pre>
To get pods running on a node
<pre>kubectl get pods -o wide | grep &lt;node_name&gt;</pre>
<h3>Services</h3>
To list all namespace services
<pre>kubectl get services</pre>
To get service logs
<pre>kubectl logs -f &lt;service_name&gt;</pre>
To edit and update the definition of one or more services
<pre>kubectl edit services</pre>
<h3>Namespace</h3>
To list all namespaces
<pre>kubectl get ns OR kubectl get namespaces OR kubectl get namespace</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/232/1*5CqdUuAMa3T6PDLuasbKGg.png"></figure>To create a namespace
<pre>kubectl create namespace &lt;namespace&gt;</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/243/1*7rYu77pTOtgMuZlAOnb7iQ.png"></figure>To delete a namespace
<pre>kubectl delete ns &lt;namespace&gt;</pre>
<h3>Nodes</h3>
To list the nodes
<pre>kubectl get nodes</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/365/1*BAsEy8__P1q3rZ46VJmkZQ.png"></figure><h3>Secrets</h3>
<blockquote>Secrets are the passwords, credentials, keys, and more that help your services (and Kubernetes) run effectively at any given time. Without this data, proper authentication and authorization are impossible. Managing these secrets is essential — which is tough if you don’t know them.</blockquote>
To get secrets
<pre>kubectl get secrets</pre>
<h3>Events</h3>
To get the events
<blockquote>In Kubernetes, an event is a record of a change that has occurred in the system. Events are created when an object in the Kubernetes system changes state, such as when a pod is created, deleted, or restarted. Events can be used for monitoring, troubleshooting, and auditing purposes.</blockquote>
<pre>kubectl get events</pre>
There are many commands in Kubernetes other than the aforementioned commonly used commands. You can use this cheatsheet in official Kubernetes docs: <a href="https://kubernetes.io/docs/reference/kubectl/cheatsheet/">kubectl Cheat Sheet | Kubernetes</a>
That’s it for this blog. This is the last blog for the Kubernetes Basics series. Now you have some good hold on Containers, Docker and Kubernetes. I will be writing some more blogs on Kubernetes and mainly on DevOps tools and technologies.
Till then, happy learning :)
Here are the beautiful and clearly explained playlist and Udemy course from <a href="https://www.udemy.com/user/mumshad-mannambeth/">Mumshad Mannambeth</a> which will help you a lot in your DevOps or Kubernetes journey.
<ol>
<li><a href="https://www.youtube.com/watch?v=QJ4fODH6DXI&amp;list=PL2We04F3Y_43dAehLMT5GxJhtk3mJtkl5&amp;index=1">(413) What Is Kubernetes — The Engine Behind Google’s massive Container Systems | KodeKloud — YouTube</a></li>
<li><a href="https://www.udemy.com/course/certified-kubernetes-application-developer/">Kubernetes Certified Application Developer (CKAD) Training | Udemy</a></li>
</ol>
If you find any typos or mistakes in this blog, feel free to comment. And if you have any doubts, contact me and I will help you out.
Thank you. Have a great day!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=91f37c0cc7c5" width="1" height="1" alt="">

Kubernetes Basics: Hands-on with Kubernetes

<h4>Kubernetes Architecture</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sesEN50HNje4UsLV"><figcaption>Photo by <a href="https://unsplash.com/@alexkixa?utm_source=medium&amp;utm_medium=referral">Alexandre Debiève</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Introduction</h4>
Hey guys, welcome to my series of blogs on Kubernetes, where I will be covering most of the concepts related to Kubernetes. This is the fourth blog of the series. Let’s begin!
In this blog we will learn the basic terminologies and concepts of Kubernetes. If you have come this far, congratulations and thank you :)
Aight! Now that we know the ground basics of Kubernetes let’s get to know the architecture of Kubernetes.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pKXSPhA_peumDTkH6vH_nw.png"><figcaption>Kubernetes Architecture</figcaption></figure>Alright. Don’t worry about the architecture diagram being so clumsy with a lot of words that bounces off your head :) Let’s just consider a scenario on analogy of ships to understand Kubernetes architecture in a better way.
Consider two kind of ships; cargo ships and control ships. The cargo ships that carry containers across the sea and control ships monitor and manage the cargo ships. Kubernetes as we all know consists a set of worker nodes which may be physical or virtual on premise or on cloud that hosts the applications in the for of containers. Let’s relate worker nodes as cargo ships.
Okay. So now we know that the cargo ships carry the containers. But who loads those containers on the cargo ships? Cargo ships cannot load them on their own, there has to be some bigger ship or control ship who loads the number of containers and also what containers to load. It should also store the information of the cargo ships like the location, the maximum capacity of the cargo ships, etc.
These control ships are actually the Master node in Kubernetes cluster. The master node is responsible for managing, planning, monitoring, scheduling the nodes/worker nodes and also the container on the worker nodes.
Okay. Now the master node cannot do this on one single component right? Imaging you have one room filled with developers, architects, marketing manager, etc. That would be hella crowded and no work gets done at all :)
Instead of having all these in a single component, the master node consists of multiple components that work together hand-in-hand to get all the necessary work done.
<blockquote>Master node is also known as Control plane</blockquote>
Let us now look at the components of Master nodes one-by-one:
ETCD Cluster: ETCD is a kind of database you can say. It is a key-value store and is used to store configuration data and other key-value pairs that is used by the Kubernetes to manage the cluster. ETCD provides a simple and reliable way to store and access data across a large number of nodes in a cluster. ETCD is hight available and fault tolerant.
kube-scheduler: kube-scheduler is commonly called Scheduler. It is responsible for assigning pods to nodes in a Kubernetes cluster. The scheduler examines the resource requirements and constraints of the pod and finds a suitable node to run on it. The few factors that the scheduler takes into account when making scheduling decisions are:
<ul>
<li>Resource requirements.</li>
<li>Node availability.</li>
<li>Affinity and anti-affinity rules.</li>
</ul>
kube-controller-manager: kube-controller-manager runs various control loops to manage the state of the cluster. It is responsible for monitoring the state of the Kubernetes cluster and make necessary changes to make sure that the system remains in a healthy state. There are four types of controllers inside the kube-controller-manager:
<ul>
<li>
Node controller: Node controller as the name itself says; it takes care of nodes. It is responsible for onboarding new nodes to the Kubernetes cluster, handling the unhealthy/unavailable nodes. It monitors the node status and makes changes as necessary to ensure that nodes are in the healthy state.</li>
<li>
Replication controller: Replication controller ensures that the desired number of containers are running at all times in the replication group. It is also responsible for managing the state of replica sets.</li>
<li>
Service controller: Service controller is responsible for managing the state of services in the cluster. It monitors the service endpoints and updates the DNS entries as necessary to ensure that services remain available.</li>
<li>
Endpoint controller: Endpoint controller is responsible for managing the state of endpoints in the cluster. It monitors the pods that provide a particular service and updates the endpoints as necessary to ensure that traffic is properly routed in a Kubernetes cluster.</li>
</ul>
kube-apiserver: kube-apiserver is responsible for exposing the Kubernetes APIs. It acts as the front-end for the Kubernetes control plane and provides a RESTful API for interacting with the cluster. The kube-apiserver is responsible for validating and processing API requests, maintaining the state of the Kubernetes API objects (such as pods, services, and deployments), and enforcing authorization and access controls. It is the only component of the control plane that interacts with the etcd datastore directly.
Let us now look at the components of worker nodes one-by-one:
kubelet: Kubelet is the component which is responsible for running containers on individual nodes in the Kubernetes cluster. Kubelet also communicates with the master node or control plane to make sure that the containers are running as expected. The kubelet is responsible for:
<ul>
<li>
Pod management: Kubelet ensures that all the containers running in a pod are healthy. The starting and deleting containers when the pod is created and deleted respectively is handled by thr Kubelet.</li>
<li>
Container management: Kubelet ensures the healthy state of containers. containers if they fail, and reports container status to the Kubernetes API server.</li>
<li>
Node management: The kubelet monitors the state of the node and reports node status to the Kubernetes API server. It also performs node-level tasks, such as cleaning up unused resources and managing local storage.</li>
<li>
Image management: The kubelet pulls container images from a container registry as necessary and manages the local cache of container images on the node.</li>
</ul>
container-runtime: Every worker node in a Kubernetes cluster require a container-runtime to manage the container’s lifecycle. The most popular one is the Docker.
kube-proxy: Kube-proxy or a network proxy is responsible for network proxy and load-balancing tasks. It is also responsible for routing traffic to the appropriate pods based on the IP address and port number of the incoming request. Basically it helps in routing work requests to the appropriate containers.
<h4>Extras:</h4>
<ol>
<li>
Persistent storage: Persistent storage is like a non-volatile memory. It is used for providing persistent data storage to stateful applications running in containers. Unlike the ephemeral storage where the data is deleted when the container is terminated, persistent storage allwos the data to be stored and retrieved even when the container has been terminated or moved to a different node in a Kubernetes cluster.</li>
<li>
Container registry: We know that the container images are stored in a container registry, so this can be the user ‘s own registry that the user configured or a third-party registry like Docker Hub.</li>
<li>
Underlying infrastructure: You can run Kubernetes anywhere; whether it’s a physical machine, virtual machine, public, hybrid or a private cloud based on your needs and requirements.</li>
</ol>
<h4>Foot notes:</h4>
<blockquote>Why does Kubernetes use “pods” instead of just using the containers?</blockquote>
There are many advantages of using pods instead of just deploying containers. They are:
1. Pods can group the containers as a single unit of deployment and scaling. This is useful for applications that require multiple processes to be run together, such as a web server and a database.
2. Communication is a lot easier as pods provide a shared network namespace allowing containers within the pod to communicate with each other using localhost, as if they were running on the same host. This can simplify application development and reduce network latency.
3. Resource sharing: Pods allow containers to share resources such as storage volumes, network namespaces, and IPC namespaces. This can simplify the deployment and configuration of complex applications.
4. Co-location: Pods can be co-located on the same node, allowing for efficient use of resources and reducing network traffic between nodes.
Aye! A long blog it is. I am dropping in some reference and also YouTube playlist to learn more about Kubernetes in a better way. Become a master of Kubernetes :)
<h4>References and tutorials:</h4>
<ol>
<li>Kubernetes Playlist by Mumshad Manambeth: <a href="https://www.youtube.com/watch?v=QJ4fODH6DXI&amp;list=PL2We04F3Y_43dAehLMT5GxJhtk3mJtkl5">(332) What Is Kubernetes — The Engine Behind Google’s massive Container Systems | KodeKloud — YouTube</a>
</li>
<li>Blog by Spacelift.io: <a href="https://spacelift.io/blog/kubernetes-architecture">What Is Kubernetes Architecture? — Components Overview (spacelift.io)</a>
</li>
<li>Blog by TechGeekNext: <a href="https://www.techgeeknext.com/how-kubernetes-works">Kubernetes Architecture (2023) | TechGeekNxt &gt;&gt; (techgeeknext.com)</a>
</li>
<li>Blog by ClickItTech: <a href="https://www.clickittech.com/devops/kubernetes-architecture-diagram/">Kubernetes Architecture Diagram: The Complete Explanation (clickittech.com)</a>
</li>
<li>Blog by TechDozo: <a href="https://techdozo.dev/kubernetes-architecture/">Components of Kubernetes Architecture — Techdozo</a>
</li>
</ol>
As always, I am a human after all :) I make mistakes. If you find anything wrong, please let me know. And please post your questions and get in touch with me if you have any doubts. I would love to resolve your doubts.
Thank you. Have a great day!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=5ca38ab32d4b" width="1" height="1" alt="">

Kubernetes Basics: Basics of Kubernetes Part 2

<h4>Ground basics</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wKMLStdt4jl5vJXG"><figcaption>Photo by <a href="https://unsplash.com/it/@daunation?utm_source=medium&amp;utm_medium=referral">Drew Dau</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Introduction</h4>
Hey guys, welcome to my series of blogs on Kubernetes, where I will be covering most of the concepts related to Kubernetes. This is the third blog of the series. Let’s begin!
In this blog we will learn the basic terminologies and concepts of Kubernetes. If you have come this far, congratulations and thank you :)
Buckle up folks. Here we are for the most interesting and fun part of the Kubernetes Basics series. I will break down this blog into multiple parts so that the blog looks short and detailed.
<blockquote>Oh and BTW Kubernetes is also called “K8s” or “kube” in short.</blockquote>
Let’s take some real world example to understand Kubernetes at a high level. Imagine you are an app developer and have built a new app. Your app is so good that you can’t contain the excitement to show it to the world.
Since you have read the Kubernetes Basics blog series from the legend Aditya Girigoudar :P you now package the application code, it’s runtime and dependencies using Docker image and create a Docker container for your app that can run consistently across different machines and platforms and throw away the worries of environment issues of your app.
You also test the app in an environment which closely resembles the production environment to catch bugs and errors before deploying it to production.
Now you deploy your app to production using 2 servers with the help of Docker. Initially your app and servers were doing fine until you app became famous and you start to see a lot of traffic for your app. At first you deploy more container to handle the issue but it all goes in vain as the requests/traffic is huge. This becomes a big problem for you. You search the internet to handle this situation and search for tools to manage multiple containers, automate scaling, and ensure high availability and reliability.
That’s where <a href="https://kubernetes.io/">Kubernetes</a> comes to the rescue.
<h4>What is Kubernetes?</h4>
In simple words, Kubernetes (also called k8s or “kube”) is an open source container orchestration tool/platform that automates tasks such as deploying, scaling and managing multiple containerised applications. Kubernetes was originally designed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF).
<blockquote>Container orchestration is the automated management of containerised applications for their deployment, scaling, availability, reliability and scheduling.</blockquote>
Kubernetes can be deployed on a variety of platforms, including on-premises data centers, public cloud providers, or hybrid environments. Kubernetes has now become an essential component of many modern cloud-native architectures.
<blockquote>It literally says “Oh! So you have deployed an app using Docker? Let me take care of everything from scaling, managing and orchestrating the containers.</blockquote>
So now that you have an idea about Kubernetes and why is it used in modern day applications, let’s hop into the basic terminologies of Kubernetes.
Although there are many concepts and terminologies in a Kubernetes world, let’s learn the root terminologies first.
<blockquote>Let me tell you a real story of my learnings on Kubernetes. I was convinced that learning all Kubernetes concepts will make me a pro in it. I was so wrong.</blockquote>
<blockquote>It doesn’t work like that. I saw many tutorials not going from ground basics and instead jumping into the core concepts. Trust me, even though this blog series will be large, it will cover all the concepts needed to be a hero in Kubernetes. Let’s learn slowly and grasp knowledge with full potential.</blockquote>
<h4>Ground basics:</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*AUx890fQwtGnOzbtNKL_2w.png"><figcaption>Basic architecture of Kubernetes</figcaption></figure><ol>
<li>
Cluster: A cluster is a group of interconnected nodes that work together to run containerised applications. A cluster is typically composed of one or more master nodes and one or more worker nodes.</li>
<li>
Node: A node in K8s is a worker machine that runs containerised applications. A node can be either physical or virtual machine and it is managed by the Kubernetes master.</li>
<li>
Pod: A pod is the smallest deployable unit in Kubernetes. A pod represents a single instance of a running process in a cluster. A pod can container single or multiple containers. Since all the containers are present in a pod, the containers in a pod can communicate with each other using localhost, and they can share the same storage volumes.</li>
<li>
Container: A container is a lightweight, standalone, and executable software package that contains everything needed to run an application, including code, runtime, system tools, libraries, and settings.</li>
</ol>
That’s it for this blog. Now you have an idea of what is Kubernetes and why is it so widely used in modern-day applications. You now know the basics terminologies also. In the next blog let’s dig deeper on the Kubernetes architecture and how it works.
Till then, happy learning :)
If you find any typos or mistakes in this blog, feel free to comment. And if you have any doubts, contact me and I will help you out.
Thank you. Have a gread day!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=e7063bfc25e7" width="1" height="1" alt="">

Kubernetes Basics: Basics of Kubernetes Part 1

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0gCCPhyBFjwvNLuh"><figcaption>Photo by <a href="https://unsplash.com/@quinoal?utm_source=medium&amp;utm_medium=referral">Quino Al</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>Hands-on experience with Docker</h4>
<h4>Introduction</h4>
Hey guys, welcome to my series of blogs on Kubernetes, where I will be covering most of the concepts related to Kubernetes. This is the second blog of the series. Let’s begin!
Now that you have learnt about the basics of containers and Docker in my previous blog; let’s get some hands-on experience with containers using Docker.
<blockquote>You can’t be a master at anything if you don’t try it yourself. You have to make mistakes and learn how to fix them. That’s how you learn and grow :)</blockquote>
With that being said, let’s begin the blog.
First of all we need to install Docker. You can follow <a href="https://docs.docker.com/get-docker/">this link</a> to install Docker on your machine. After the installation, check whether the docker is running by using commands docker or docker — version on your terminal.
You can also use the Docker Desktop which is the GUI version for Docker.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*lEoOwrASi3QkeU5q.jpg"><figcaption>Docker Desktop</figcaption></figure>After this, <a href="https://hub.docker.com/">create an account on Docker Hub</a>. Docker Hub is like a store for container images from software vendors, open-source projects and by YOU :). Yes, we will deploy a sample docker image on Docker Hub.
Alright! Let’s learn some docker commands: 1. docker — version: To get the version of docker installed. 2. docker ps: To get the list of the containers on your machine. 3. docker images: To get the list of all the images on your machine. 4. docker start: To start one or more stopped containers. 5. docker stop: To stop one or more running containers. 6. docker build: To build the image from the Dockerfile. 7. docker pull: To pull an image or repository from the registry. 8. docker push: To push an image or repository to the registry. 9. docker exec: To run a new command in a running container. 10. docker search: To search the Docker Hub for images. 11. docker commit: To create a new image for any container changes.
You can also find more commands <a href="https://docs.docker.com/engine/reference/commandline/docker/">here</a>
I will be including two major contents here; one will be on using Docker with existing images and one will be creating a custom image and then deploying it on Docker Hub.
<h4>Tinkering with existing images with Docker</h4>
We will be using the Ubuntu 20.04 image from Docker Hub. Follow the steps below to use Ubuntu 20.04.
Step 1: Pull the Ubuntu 20.04 image from Docker Hub. Use the command docker pull
<pre>docker pull ubuntu:20.04</pre>
Pro tip: To use the latest version of the image, use
<pre>docker pull &lt;image_name&gt;:latest</pre>
This will download the or pull the Ubuntu image from Docker Hub.
<blockquote>Status: Downloaded newer image for ubuntu:latest docker.io/library/ubuntu:latest</blockquote>
You can see the image with the command docker images
<pre>docker images</pre>
<blockquote>ubuntu latest 730eeb702b69 10 days ago 69.2MB</blockquote>
Now let’s run the Ubuntu image.
<pre>docker run -it --entrypoint "/bin/bash" ubuntu:latest</pre>
This will build and run a container for Ubuntu 20.04 image. We have also specified an entrypoint to launch a bash shell (/bin/bash).
<figure><img alt="" src="https://cdn-images-1.medium.com/max/301/1*lgClztcyuhxojCE-l_JrNA.png"></figure>Congratulations! You have now used an existing image of Ubuntu created a Docker container of Ubuntu and used it.
Now let’s create an custom image and push it to Docker Hub. This will be interesting. Let’s go!
<h4>Tinkering with custom images with Docker</h4>
Follow the steps below to create a custom image and push it to Docker Hub. Create a directory called my-web-page so that it would be very easy to manage the files.
<ol><li>Create a Dockerfile and add the content below:</li></ol>
<pre>FROM nginx:latest COPY index.html /usr/share/nginx/html</pre>
We are creating an official image of Nginx as a base image and copying the file called index.html to the default web root directory of Nginx.
Warning! Extra knowledge ahead.
Learn Nginx with a live example.
Imagine you have started your own venture of online bookstore. The website was doing well. One day your online bookstore got so much popular that there were thousands of visitors and the server couldn’t handle the load ans it crashed. You figured out that the main problem with the server was that it had more connections to handle but with poor performance.
Luckily your friend suggested to use Nginx. Nginx is a webserver with different features to handle this problem. Nginx can effectively handle a large number of concurrent connections and requests, making it ideal for serving high-traffic websites and applications. Now when you have installed Nginx, your website can handle many requests without any performance issues. Learn more about Nginx <a href="https://www.nginx.com/resources/glossary/nginx/">here</a>.
2. Now create an HTML file and paste the content below in the file.
<pre>&lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;Hello, World!&lt;/title&gt; &lt;/head&gt; &lt;body&gt; &lt;h1&gt;Hello, World! This is my web page.&lt;/h1&gt; &lt;/body&gt; &lt;/html&gt;</pre>
3. Now we need to build the image, to do that use the below command. Make sure that the present working directory has the Dockerfile.
<pre>docker build -t my-web-page .</pre>
The above command will build the Docker image using the Dockerfile and the HTML file in the current directory.
4. Run the Docker container using the below command.
<pre>docker run -d -p 8080:80 my-web-page</pre>
The above command runs the Docker container in detached mode (-d), maps it to port 8080 on the host machine to port 80 in the container (-p 8080:80), and uses the my-web-page image that you had just created.
5. Open a web browser and go to http://localhost:8080. You should see the "Hello, World! This is my web page." message displayed on your browser window.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*M5bSXT-fB0ZlagZZb6ZlHw.png"></figure>Bingo! Now you have built and used your Docker image. Let’s push this image…. I mean you Docker image :) to Docker Hub. To do that follow the steps below:
<ol><li>Login to Docker Hub using the below command</li></ol>
<pre>docker login</pre>
This command will prompt you to enter your Docker Hub username and password. Enter the credentials.
2. Give a tag to the Docker image that we are pushing to Docker Hub. To do that use the below command
<pre>docker tag my-web-page &lt;username&gt;/my-web-page:1.0.0</pre>
3. Push the docker image to Docker Hub using docker push command
<pre>docker push &lt;username&gt;/my-web-page:1.0.0</pre>
Once the push is complete, you can verify that the image was uploaded to Docker Hub by logging in to the <a href="https://hub.docker.com/">Docker Hub website</a> and checking your repository.
NOTE: When you push your repository will be private by default. That means only you can see and pull the Docker image. To make it available to everyone around the globe, go to Repositories &gt; my-web-app &gt; Settings ? Visibility settings and make it public.
Congratulations pal! Now anyone can use your Docker image. Cheers for your work on creating a custom Docker image and pushing it to Docker Hub for the world to see.
As always, I am a human afterall :) I make mistakes. If you find anything wrong, please let me know. And please post your questions and get in touch with me if you have any doubts. I would love to resolve your doubts.
Thank you. Have a great day!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=cf50d0e61d2" width="1" height="1" alt="">

Kubernetes Basics: Hands-on with Docker

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IeAgJcS9YPBq7pf0"><figcaption>Photo by <a href="https://unsplash.com/@justusmenke?utm_source=medium&amp;utm_medium=referral">Justus Menke</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Kubernetes Basics: Containers and Docker</h3>
<h4>Basic concepts on containers and Docker</h4>
<h4>Introduction</h4>
Hey guys, welcome to my series of blogs on Kubernetes, where I will be covering most of the concepts related to Kubernetes. This is the first blog of the series. Let’s begin!
Whether you’re a developer or a tech enthusiast, you may have heard the names Docker somewhere at some point in you lives. I mean I have had heard about it in my college days and even used Docker. But little did I know that it would be kick start to learn Kubernetes. Let’s find out why is Kubernetes so popular and what are it’s uses and advantages.
Shall we?
Before diving into the world of Kubernetes, you need to grasp the basics.
Let’s get started with that!
<h3>Containers and Virtual Machines</h3>
Containers and Virtual Machines (VMs) are methods used to virtualise computing resources.
<h4>Containers</h4>
Containers come under the form of OS virtualisation. What does OS virtualisation in containers mean?
OS or Operating System virtualisation is a kind of virtualisation where the host system’s kernel is shared with other containers. This will cause the containers to run in their own isolated space on a single host and in-turn the parts that are created from scratch are bins and libraries.
As containers share host OS kernel, they also used a layered file system and shared resources such as host’s network and storage interfaces which will lose the burden to allocate resources for each container. This will make containers fast, efficient, lightweight and lesser resource crunch and faster deployment.
Although there are many other tools for containerisation such as Solaris, LXC, etc. Docker is very popular.
Why is Docker so popular? Docker is popular because: 1. Docker is easy to use. 2. Docker containers are lightweight and fast. 3. Docker also has Docker Hub which you can think of it as “a store for Docker images”. 4. Docker is modular and scalable. 5. And of course, the cute docker whale :)
Before diving deep into the architecture of containers using Docker, let’s just understand the surface concepts of Docker by using a real-time example.
What is Docker? Imagine you’re a developer and you have developed a web application. You have used ReactJS (v1.0) for frontend and NestJS (v1.1) for backend. It works perfectly on you local machine without any warnings and/or errors. Now you’re very happy :) that your web app is working as you had expected. Now you want to deploy it to production for the world to see.
Suddenly your web app won’t work or function properly on other people’s machines. You are now confused on why the web app worked perfectly on local machine but not in production :(
Here the famous developer quote comes dancing. “IT WORKS ON MY MACHINE” :P
Okay! Fun aside. Now you figure out and debug what’s going wrong with you web app. You realise that the culprit is the version of ReactJS. You have used ReactJS (v1.0) and the latest version is v2.0. That’s the reason why your web app is not functioning properly on other’s machine (they might be using ReactJS version higher than v1.0).
<blockquote>BONUS: There may be several other reasons on why your web app isn’t functioning properly. The main reasons include: 1. Libraries 2. Frameworks 3. Microservices 4. OS capabilities 5. Dependencies, etc.</blockquote>
Now you need to figure out a way to fix this issue. That;’s where the cute whale — Docker comes to the rescue.
Docker is a popular tool that runs containerised applications so that you can deploy without any hassle. You can wrap your code, services, libraries, packages, tools and the dependencies into a virtual container that can run on any platform like Linux, Windows, MacOS, etc. At last, you take a sigh of relief and get back to work on other applications. Come on now, you’re a developer and you FIX things. You don’t waste time blaming your local machine :P
Now, let’s understand the architecture of a container using Docker.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B8DAL72SESzKFcuyD946aw.png"><figcaption>Container Diagram</figcaption></figure>As you can see in the above image that the containers are just using the same Host OS. Each container runs in it’s own isolated user-space. Containers do not require a separate Host OS to run which makes them faster and less resource craving.
Basics terminologies of Docker: 1. Docker Desktop: Docker Desktop is a desktop GUI application which can be used for managing Docker containers and images. It includes Docker Engine, Docker CLI and other tools and services required to develop, test and launch containerised applications on local machines.
2. Docker Engine: Docker Engine also known as Docker daemon or Docker runtime constitute the core component for a Docker platform. Docker Engine is responsible for managing the Docker containers and images as well as providing rich set of tools and services required to run and deploy containerised apps.
3. Image: Image is a read-only template which is used to create containers. Image can also be considered as a snapshot of a container which then can be used to create identical container on different machines.
4. Docker-file: Docker-file is a text file that contain the instructions for building a Docker image which includes base image, software packages, config files and also other files required to run the application.
5. Registry: Registry is a repository for storing and distributing Docker images such as Docker Hub or even a private repository.
6. Volume: Volumes can be used to persist data outside a container. Volumes can be used to share data between containers or to store data that need to be preserved after container deletion.
7. Docker Compose: Docker Compose is a tool for defining and launching multiple Docker containers at once. Docker Compose is written in YAML (Yet Another Markup Language) and the config for those multi-containers.
8. Docker Service: Docker service are a group of containers that perform the functions such as web-server or a database.
9. Docker Swarm: Docker Swarm is container orchestration platform that allows for the management and scaling of Docker containers across multiple hosts.
Warning!!!! Extra Knowledge ahead.
Whenever you hear the word “Containers” you should also come across its similar yet different architecture of Virtual Machines (VMs). Who knows! Sometime extra knowledge is very helpful :P
<h4>Virtual Machines or (VMs)</h4>
As the name suggests, we are making a machine virtual. Virtual machines come under the form of hardware virtualisation that emulates a complete physical machine, including a full OS and virtualised hardware.
Both container and VMs are very similar. The only difference is that; containers provide OS virtualisation and share the host system’s kernel with the other containers whereas VMs provide hardware virtualisation including OS and virtualised hardware.
Each VM runs on the top of a hypervisor, which provides a layer of abstraction or a bridge between the hardware and the VM. VMs are isolated from each other and from the host OS which means that VMs are highly secure and flexible. And as you know, where there are advantages, there are also disadvantages. VMs are heavier and they start-up slowly than containers.
What is a hypervisor? A hypervisor is a piece of software or a firmware or a hardware, that VMs runs on top of it. A hypervisor is also known as VMM (Virtual Machine Monitor).
There are two types of hypervisors: 1. Type 1 hypervisor (or bare-metal hypervisor): This type of hypervisor runs directly on the host machine’s hardware, without the need for an underlying operating system. Type 1 hypervisors provide a higher level of performance and security than Type 2 hypervisors, as they have direct access to the host machine’s hardware resources.
2. Type 2 hypervisor (or hosted hypervisor): This type of hypervisor runs on top of an existing operating system, such as Windows or Linux. Type 2 hypervisors are easier to install and manage, but they provide lower performance and security than Type 1 hypervisors.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YgJ5bM41V0sAJ8-RRwLwdQ.png"><figcaption>Virtual Machine Architecture (Hypervisor Type 1)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ZBZ7w4kw21csIPRcWt-Mg.png"><figcaption>Virtual Machine Architecture (Hypervisor Type 2)</figcaption></figure><h3>Foot Notes</h3>
Differences between Containers and VMs:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nn2uahhLIfHUR2Qg3UFdVg.png"><figcaption>Differences between Containers and VMs</figcaption></figure><h3>Conclusion</h3>
I hope you are now comfortable with Docker, Containers and VMs. This is the first blog of Kubernetes series.
As always, let me know if I have made any typo errors or mistakes in any information.
Thanks! Have a good day.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=1598d754344a" width="1" height="1" alt="">

Kubernetes Basics: Docker

<h3>Proxychains — What and How.</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wbUnDv4qmGjcq6SS"><figcaption>Photo by <a href="https://unsplash.com/@pensandpillows?utm_source=medium&amp;utm_medium=referral">Aida L</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure>What are Proxy chains?
Before getting into What and How of Proxy chains, let’s understand VPN (Virtual Private Network). Most of you have heard about this term but lets go through it deeply. A VPN or Virtual Private Network is a tool which is used to get online privacy and anonymity. VPN creates a private network for your internet connection. It also provides secure and encrypted connection which gives you maximum privacy possible.
How does a VPN work?
<figure><img alt="" src="https://cdn-images-1.medium.com/max/682/0*Z5zO-DBr2AMIPBD1.png"><figcaption>Image Credit: <a href="https://www.google.com/url?sa=i&amp;url=https%3A%2F%2Fwww.cactusvpn.com%2Fbeginners-guide-to-vpn%2Fwhat-is-a-vpn-server-how-does-a-vpn-server-work%2F&amp;psig=AOvVaw2aSbgqrhJR3sdrjfcnpzXg&amp;ust=1606201098069000&amp;source=images&amp;cd=vfe&amp;ved=0CAIQjRxqFwoTCJCyrMGLmO0CFQAAAAAdAAAAABAO">682 × 298 (google.com)</a></figcaption></figure>The VPN point encrypts your data and sends it through the internet. Another point in your VPN network decrypts your data and sends it to the appropriate internet resource, such as a web server, an email server, or your company’s intranet. Then the internet resource sends data back to a point in your VPN network, where it gets encrypted. That encrypted data is sent through the internet to another point in your VPN network, which decrypts the data and sends it back to your client machine.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*Iko5pZw3GE6w8Dxe.png"><figcaption>Image Credits: <a href="https://en.wikipedia.org/wiki/Proxy_server">Proxy server — Wikipedia</a></figcaption></figure>Proxy chains work similar to VPN, the only difference is that VPN uses just one proxy between user and server(destination) while proxy chains can chain multiple proxies and your connection will go through different proxies before reaching the destination. Proxy chains gives you more anonymity than a VPN. You can also configure different proxy protocols such as SOCKS 4, SOCKS 5, HTTP and also the secured version of HTTP i.e. HTTPS. You can even configure Tor proxy with it.
How to use Proxy chains?
Proxy chains is a tool which is written only for GNU/Linux based systems. If you’re using Kali Linux, then it is pre-installed. You can also download it form the repository using a terminal. So, let’s get started.
$sudo apt install proxychains
You need to install tor if you intend to use the tor proxy with proxychains.
For that type $sudo apt install tor
Once this is done, now type $sudo nano /etc/proxychains.conf
<figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*fkiW7rZnMyA9x8ZFX4DQUQ.jpeg"></figure>Once that is opened, you can see many commented lines and there are different ways to configure the chain of proxies such as dynamic, random, and strict. You can comment or uncomment the name(dynamic_chain, strict_chain and random_chain) to enable or disable the specific option. I am using the dynamic_chain option to route packets through the proxies.
What is a Dynamic Chaining?
<figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*15zs5SHYvFkFqR7YBa9ALw.png"></figure>Dynamic Chaining uses every proxy in the proxy list and if one of the proxies is down or not responding, the dead proxies are skipped, it will automatically go to the next proxy in the list without throwing an error or exception.
What is a Strict Chaining?
<figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*-wx2My-XfGs4QkSSPyFFsg.png"></figure>In strict chaining, the proxies which are present in the proxy list will be used and they will be executed in order.
What is a Random Chaining?
<figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*v2wAQ8B8hSOywKCidEoV3g.png"></figure>As the name itself says, the proxies in the proxy list are chosen at random.
If you scroll down a bit, there will be a line “Proxy DNS requests — no leaks for DNS” commented. You should remove the hashtag to prevent DNS leak while using the proxychains. Scroll down further to see the list where you can add your proxies. The file also gives you some examples of how to add the proxies. By default, the Proxychains use tor. If you don’t want to use tor, you can comment out the first line out and add your own proxies. You can get some https or socks 5 proxy servers from this <a href="https://www.socks-proxy.net/">link</a>. Save and close the file(Press Esc and :wq to write and exit OR Press Ctrl+O, Enter and Ctrl+X).
<figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*PmT2KW9B3DI97RVYUSdFVg.jpeg"></figure>After this you need to check whether the tor service is active or not. To do this type $service tor status
<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*DN6UnDXSFp_y72Ug5x4Jlg.png"></figure>If it shows inactive (dead) as in the above image then type $service tor start
<figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*M4EVvBLgUMVguDWQkaGe8g.png"></figure>If it shows active (exited) then tor service is active.
Bingo! Now you can use proxy chains.
Type for eg. $proxychains firefox <a href="http://www.bing.com/">www.bing.com</a>
You can see that after executing the proxychains, bing will be loaded with some other language. Now let’s check DNS leak test by typing $proxychains firefox <a href="http://www.dnsleaktest.com/">www.dnsleaktest.com</a> or going to www.dnsleaktest.com
You can see that your location is now changed from (Your Location) to (Any other location of the proxy server). So this how dynamic proxychains work. It provides good anonymity.
References: <a href="https://cybersecurity.att.com/blogs/security-essentials/explain-how-vpn-works#:~:text=The%20VPN%20point%20encrypts%20your%20data%20and%20sends%20it%20through%20the%20internet.&amp;text=Then%20the%20internet%20resource%20sends,back%20to%20your%20client%20machine">https://cybersecurity.att.com/blogs/security-essentials/explain-how-vpn-works#:~:text=The%20VPN%20point%20encrypts%20your%20data%20and%20sends%20it%20through%20the%20internet.&amp;text=Then%20the%20internet%20resource%20sends,back%20to%20your%20client%20machine</a>. <a href="https://www.geeksforgeeks.org/how-to-setup-proxychains-in-linux-without-any-errors/">https://www.geeksforgeeks.org/how-to-setup-proxychains-in-linux-without-any-errors/</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=e7f11799890f" width="1" height="1" alt="">

girigoudar_

Hi there 👋🏻 I am

Aditya Girigoudar

Developer.

Blogger.

Tinkerer.

Blogs.

Kubernetes Basics: Hands-on with Kubernetes

Kubernetes Basics: Basics of Kubernetes Part 2

Kubernetes Basics: Basics of Kubernetes Part 1

Kubernetes Basics: Hands-on with Docker

Kubernetes Basics: Docker

Proxychains — What and How.