Kubernetes: Introduction, architecture and how it works

Kubernetes, or k8s is an open source platform that automates the management, scaling, and application deployment in the form of a container or container orchestration engine. It eliminates many manual processes involved in deploying and expanding containerized applications.

Recently, many applications have implemented containerization by using docker and using it as a growing production environment. On a production environment, it is very difficult to structure a container-based system using only dockers. So using a Container orchestration engine platform like k8s is quite common today.

Kubernetes orchestration allows you to build application services that extend multiple containers. It schedules those containers on a cluster, expands the containers and manages the status of the containers over time.

Real production applications extend many containers. These containers must be deployed on multiple server hosts. Kubernetes provides the coordination and management capabilities needed to deploy containers at scale for those workloads.

Kubernetes was originally developed and designed by engineers at Google. This is also the technology behind Google's cloud services. Google has been creating more than 2 billion container deployments every week and all of them are supported by an internal platform: Borg.

When to use Kubernetes?
Large businesses that really need to scaling systems quickly, and have used containers (Docker).
Projects need to run> = 5 containers of the same type for 1 service. (For example using> = 5 machines to run thegioimaychu.vn website code).
Innovative startups, investing in technology to easily auto scale later.

What problem does Kubernetes solve?
By using docker, on one host you can create multiple containers. However, if you intend to use in production environment, it is imperative to think about the following issues:

Batch management of docker hosts
Container Scheduling
Rolling update
Scaling / Auto Scaling
Monitor life cycle and status of container life.
Self-hearing in case of an error. (Ability to detect and correct errors by itself)
Service discovery
Load balancing
Data management, work node, log
Infrastructure as Code
Interconnection and expansion with other systems
By using a Container orchestration engine like K8s it is possible to solve the above problems. In the absence of the k8s, it would be necessary to create an automated mechanism for the aforementioned, which is extremely time consuming and not feasible.

The K8s manages the execution of containers using YAML to write Manifest.

Kubernetes manages the docker hosts and cluster container structure. In addition, when executing containers on K8s, by replicas (creating multiple identical containers) makes the system highly fault tolerant and automatically performs load balancing. Through the load balancing mechanism, we can increase or decrease the number of replica containers (auto scaling).

When dividing containers into nodes (docker hosts), based on the type of docker hosts like "Disk SSD" or "high CPU clock count" ... Or based on type of Workload like "Disk I / O too much" "," The bandwidth to a specified container is too much "... K8s will be aware of affinity or anti-affinity and perform Scheduling appropriately for us.

In case no specific host is specified, K8s will perform scheduling depending on CPU status, docker host's memmory is available or not. Therefore, we do not need to care about how to manage the container layout into the host docker.

In addition, if the resource is not enough, the auto scheduling of the K8s cluster will also be done automatically.

Built from the standpoint of high fault tolerance, the K8s monitors standard containers. In some unexpected case, when a container process is stopped, K8s will perform Self-hearing by scheduling another container.

Self-hearing is an extremely important concept in k8s, if there is a problem with a node in the cluster, for example it could be a die, or that node is moved. The self-hearing mechanism will automatically recover without affecting the service.

In addition, in addition to the system monitor, k8s is also capable of setting health checks using HTTP / TCP scripts.

The case after auto scaling, there is a problem of endpoint to the container. In the case of virtual machine use, by setting load balancing endpoint will be used as a VIP.

K8s also has a similar function that is Service. The k8s service provides load balancing for a range of designated containers. It is obvious to automatically add and delete containers at the time of scale, when a container goes into trouble, it is automatically quarantined.

When rolling the container update, the first thing k8s will do is isolate the container for us, so k8s can take care of managing the endpoints at high SLA level. In the case of a docker-structured system, the functions in the Microservice architecture should be broken down.

In Microservice architecture, to use the image containers created corresponding to each function and deploy them, the Service discovery function is really necessary.

K8s is a Platform but able to connect well with external ecosystems, there are many middleware running on k8s services, in the future there will certainly be more.

Ansible: Deploy container to Kubernetes
Apache Ignite: Using Kubernetes Service Discovery, automatically create and scaling k8s clkuster
Fluentd: sends the log of the container in Kubernetes
Jenkins: Deploy container to Kubernetes
OpenStack ： Structure of links with Cloud
Prometheus: Monitor Kubernetes
Spark: Implementing a native job on Kubernetes (replacing YARN)
Spinnaker ： Deploy container to Kubernetes
In addition, K8s prepares a few instances to be able to extend, perform independent functions, it can use the platform as a framework. By using scalability, we can release a ReplicaSet that k8s provides.