Skip to main content

An introduction to Kubernetes Overview.

What is a Container? 

A container is simply like a software unit/wrapper that will package everything- your application code, app-related dependencies, etc. together. You can assume that you get a portable environment to easily run your application. You can easily manage the container on your own (operations like starting, stopping, monitoring, etc.). 

Why Kubernetes? 

Suppose, you have a requirement for running 10 different applications (microservices) ~ 10 containers. 
In case you need to scale each application for high availability, you create 2 replicas for each app ~ 2 * 10 = 20 containers. Now you have to manage 20 containers. 
Would you be able to manage 20 containers on your own? (20 is just an example, there could be more based on the requirement). It would be difficult, for sure. Orchestration A Container Orchestration tool or framework can help you in such situations. It can help you automate all the deployment/management overhead. One such Container Orchestration tool is Kubernetes. 

What is Kubernetes? 

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It provides a set of abstractions and APIs for managing containers, so you can focus on building your application and not worry about the underlying infrastructure. With Kubernetes, you can manage multiple containers across multiple machines, making it easier to streamline and automate the deployment and management of your application infrastructure. 

Kubernetes is fast becoming the de facto standard for container orchestration in the cloud-native ecosystem. 

Kubernetes Architecture:

Control Plane: 

This is the brain of the Kubernetes cluster and manages the overall state of the system. It includes - 

API Server: 

Provides a REST API for the Kubernetes control plane and handles requests from various Kubernetes components and external clients.

ETCD:

ETCD is a distributed key-value store that stores the configuration data of the Kubernetes cluster. It is used by the API server to store the current state of the cluster.

Controller Manager: 
This component ensures that the desired state of the cluster is maintained by monitoring the state of various Kubernetes objects (e.g., ReplicaSets, Deployments, Services) and reconciling any differences. 

Scheduler: 

This component assigns Pods to worker nodes based on resource availability and other scheduling policies. 

Worker Nodes: 

These are the machines that run the application containers. Each worker node includes the following components: 

Kubelet: 

This component communicates with the API server to receive instructions and ensures that the containers are running correctly. Container Runtime: This is the software that runs the containerized applications (e.g., Docker, contained). 

Kube-proxy: 

The Kube proxy is responsible for network proxying on the worker node. It maintains the network rules and routes traffic to the appropriate container.

Pod: 

A pod is the smallest deployable unit in Kubernetes and represents a single instance of a running process in the cluster. A pod can contain one or more containers. 

Container: 

A container is a lightweight, standalone executable package that contains everything needed to run an application, including code, runtime, system tools, and libraries. 

Service:

A service is an abstraction that defines a set of pods and a policy for how to access them. Services provide a stable IP address and DNS name for a set of pods, allowing other parts of the application to access them. 

Other Key Components - 

ReplicaSet: It ensures that a specified number of replicas of a pod are running at all times. It takes care of auto-scaling of the replicas based on demand. 

Deployment: 

A higher-level object that manages ReplicaSets and provides declarative updates to the pods and Replica Sets in the cluster. 

ConfigMap: 

A configuration store that holds configuration data in key-value pairs. 

Secret: 

A secure way to store and manage sensitive information such as passwords, API keys, and certificates. 

Volume: 

A directory accessible to the containers running in a pod. Volumes can be used to store data or share files between containers. 

Summary - 

You can imagine Kubernetes as a classical ' Master-Worker' cluster setup. The master node has responsibilities to perform absolutely necessary processes to run/manage the cluster and the Worker nodes would actually run your applications. So you basically instruct Kubernetes about the application's desired state and then it is the responsibility of Kubernetes to achieve and maintain the state. You need to use YAML or JSON manifest/config files to give the instructions. (For example, I want to run 3 different spring-boot applications each having 2 replicas on some specified ports. I would prepare the manifest files and give them to Kubernetes and the rest would be taken care).

Comments

Post a Comment

Popular posts from this blog

Java Loops II print each element of our series as a single line of space-separated values.

We use the integers  ,  , and   to create the following series: You are given   queries in the form of  ,  , and  . For each query, print the series corresponding to the given  ,  , and   values as a single line of   space-separated integers. Input Format The first line contains an integer,  , denoting the number of queries.  Each line   of the   subsequent lines contains three space-separated integers describing the respective  ,  , and   values for that query. Constraints Output Format For each query, print the corresponding series on a new line. Each series must be printed in order as a single line of   space-separated integers. Sample Input 2 0 2 10 5 3 5 Sample Output 2 6 14 30 62 126 254 510 1022 2046 8 14 26 50 98 Explanation We have two queries: We use  ,  , and   to produce some series  : ... and so on. Once we hit  , we print the first ten terms as a single line of space-separate
15 comments
Read more

Java Currency Formatter Solution

Given a  double-precision  number,  , denoting an amount of money, use the  NumberFormat  class'  getCurrencyInstance  method to convert   into the US, Indian, Chinese, and French currency formats. Then print the formatted values as follows: US: formattedPayment India: formattedPayment China: formattedPayment France: formattedPayment where   is   formatted according to the appropriate  Locale 's currency. Note:  India does not have a built-in Locale, so you must  construct one  where the language is  en  (i.e., English). Input Format A single double-precision number denoting  . Constraints Output Format On the first line, print  US: u  where   is   formatted for US currency.  On the second line, print  India: i  where   is   formatted for Indian currency.  On the third line, print  China: c  where   is   formatted for Chinese currency.  On the fourth line, print  France: f , where   is   formatted for French currency. Sample
7 comments
Read more

Java Static Initializer Block

Static initialization blocks are executed when the class is loaded, and you can initialize static variables in those blocks. It's time to test your knowledge of  Static initialization blocks . You can read about it  here. You are given a class  Solution  with a  main  method. Complete the given code so that it outputs the area of a parallelogram with breadth   and height  . You should read the variables from the standard input. If   or    , the output should be  "java.lang.Exception: Breadth and height must be positive"  without quotes. Input Format There are two lines of input. The first line contains  : the breadth of the parallelogram. The next line contains  : the height of the parallelogram. Constraints Output Format If both values are greater than zero, then the  main  method must output the area of the  parallelogram . Otherwise, print  "java.lang.Exception: Breadth and height must be positive"  without quo
10 comments
Read more