Skip to content

Here we will cover:

✔️ the history of Kubernetes, its architecture and components; ✔️ services and pods; ✔️ jobs and how to run them; ✔️ configuration management methods (ConfigMap and Secrets); ✔️ networking, what Ingress is and how to configure it; ✔️ storage system management; ✔️ the concept of operators and extending Kubernetes capabilities; ✔️ the Helm tool, which allows you to create manifests more efficiently and group them into so-called Helm Charts; ✔️ the role-based access control system — RBAC.

Getting Started with Kubernetes

Welcome to the first step on the path to learning Kubernetes — a key technology in the world of cloud computing and microservices. This lesson is dedicated to the fundamentals and history of Kubernetes. Let's dive in!

What is Kubernetes?

Kubernetes is a system for automatic deployment, scaling, and management of containerized applications. In the word Kubernetes there are 8 characters between "k" and "s", so Kubernetes is also called k8s (kates).

Translated from Greek, "Kubernetes" means "helmsman" or "captain." Its logo resembles a ship's helm, and the ecosystem contains many names related to the ocean.

Kubernetes was developed by engineers at Google, which actively builds its own infrastructure on containers. For example, to service Gmail, Drive, Maps, Docs, and other services, Google uses Borg (Cluster Management). There are thousands of containers for these services. Imagine how exciting it is to manage thousands of containers!

Kubernetes, released in 2014, is the result of the evolution of Borg and Omega. In 2015, Google transferred Kubernetes ownership to the Cloud Native Computing Foundation, one of the largest sub-foundations of The Linux Foundation.

Kubernetes Updates

Like many other infrastructure projects, Kubernetes is written in Go and is hosted on GitHub at kubernetes/kubernetes. New versions are released every 4 months. This means that clusters need to be updated quite frequently, because support for old versions can be discontinued. On average, an old version is supported for about a year.

Kubernetes Functions

A newcomer to the DevOps world should understand Kubernetes because it is a key tool in the modern development world. This powerful system for automating deployment, scaling, and management of containerized applications allows you to:

  • manage containers across different servers;
  • optimize resource usage;
  • ensure application stability and scalability.

💡 Kubernetes can be compared to an orchestra conductor who knows exactly when and how each musician should play to ensure harmony in the performance of a symphony.

From a technical standpoint, Kubernetes is a set of servers on which special software is installed. This software is Kubernetes, which can manage the servers on which it is installed. Kubernetes can also:

  • run containers;
  • allocate the necessary resources to containers;
  • isolate containers from each other;
  • scale containers by creating additional containers;
  • configure load balancing for these containers.

💡 Kubernetes can also be compared to a courier service. We package all the parcels we send according to certain packaging instructions. In our case, the packaging consists of special manifest files and container images. After packaging, we hand the parcels to the courier — Kubernetes. The courier then independently organizes the shipping and delivery process, makes decisions about routes, transport, etc.

In the case of Kubernetes, we package applications as containers, describe them in a declarative manifest file. All other work is handled by Kubernetes, namely:

  • ensures that the application containers are started;
  • checks that they have the required resources and network;
  • automatically responds to increases or decreases in load by scaling the application;
  • performs many other functions.

Advantages of Kubernetes

Management Efficiency

Kubernetes allows you to efficiently manage microservices. Imagine that your application is a large puzzle where each piece is a separate microservice that performs its unique function. Kubernetes is needed to easily assemble these pieces together, ensure their interaction and stable operation. You can add, update, or remove these pieces without destroying the entire puzzle. This makes application development and management more efficient.

Flexibility and Scalability

Kubernetes promotes better flexibility and scalability of a project. It is like a very smart assistant that automatically adapts to changes in business. For example, if your application suddenly becomes very popular, Kubernetes automatically increases resources to cope with the load. When demand for the application decreases, Kubernetes reduces resources. This means you can easily change the size of the application depending on needs, without wasting extra resources.

Active Community

Kubernetes has one of the largest and most active communities in the IT world. By using this technology, you gain access to a huge number of resources, educational materials, and support from other developers. If you encounter a problem, there is a high probability that someone has already found a solution.

Comparison of Monolithic and Microservice Architecture

Monolithic and microservice architectures have their advantages and disadvantages. Choosing the right architecture positively impacts the software development process.

Monolith

A monolith is a colloquial term for a massive application with all functions and capabilities assembled into one gigantic program. Monolithic architecture has obvious disadvantages. Imagine you need to fix a small part of the program. You will have to modify the entire program, which consists of one, usually large, codebase.

Similar problems arise with scaling. You cannot scale individual parts of the program. For example, if at the end of the year the reporting system is overloaded, you cannot scale just the reporting — you will have to scale the entire application. This means you need to buy resources for the existing server or start a new server and set up the entire application on it. As you can see, a simple change to the reporting system caused many complications.

Microservices

Microservices is a shortened name for microservice architecture. The essence of this approach is creating applications composed of small and independent services. Each such service is responsible for a separate business function.

You can develop, scale, and update these services independently of each other. This provides better flexibility and development speed. Kubernetes plays a key role here and is used for managing microservices and orchestration (automatic container management).

Example of Transitioning from Monolith to Microservices

A large number of old monolithic applications are being replaced by solutions using microservice architecture. Imagine a large old monolith that has reporting, payment, and shopping cart storage systems. If you replace the monolith with microservices with a similar set of functions, this set of functions/services will be divided into separate mini-applications. From a technical standpoint, this means that management of each microservice is done independently, so you can change one service without modifying or shutting down other services. Containers and their orchestration facilitate this.

Scaling Microservices

Running each microservice as a separate container is quite common today. That is, we have separate containers for reporting, the payment system, the web interface, and all other services. For example, if there is a need to scale reporting during peak loads at the end of the year, more containers for reporting are simply added. When the load on reporting decreases, reverse scaling occurs, which does not affect other services in any way.

For the user, the application looks the same regardless of whether it is implemented as a monolith or microservices, but it is with microservices that managing scaling becomes much simpler.