01 Aruba Managed Kubernetes service

A Kubernetes cluster is a set of nodes that work together to run and manage containerised applications.
It consists of:

• one or more control plane components, which manage the state and operation of the cluster;
• one or more worker nodes, where workloads and their containers run.

The control plane coordinates cluster activities, while worker nodes provide the resources required to run applications.

A container is an executable instance used to host an application or service. Kubernetes manages and orchestrates containers within the cluster, allowing multiple applications to run in isolated environments on the same infrastructure.
Each container has its own file system and processes. Containers generally run within logical units called pods.

A control plane node hosts the components responsible for managing and controlling the cluster. It coordinates worker node activities and manages operations such as pod scheduling, resource allocation and maintaining the desired state of the cluster.
The main control plane components include:

• API Server;
• controller manager;
• scheduler;
• etcd.

These components work together to maintain the cluster in the desired state and enable its management.

A worker node is a node in a Kubernetes cluster where application workloads and containers run.
The worker node receives instructions from the control plane and provides its resources, such as CPU, memory, storage and network resources, to run applications. It communicates with the control plane through the API Server and provides information about the status of resources and running workloads.

A Node Pool is a group of worker nodes within a Kubernetes cluster with the same hardware characteristics and configurations, such as CPU, memory, storage and network capacity.

Node Pools allow you to organise and size cluster resources according to application requirements. If autoscaling is configured and active, the number of nodes in a Node Pool can be automatically increased or decreased according to the resources required by workloads.

The kubelet is an agent that runs on each worker node and is one of the main node components.
It communicates with the control plane through the API Server and ensures that the containers required for the pods assigned to the node are running correctly. The kubelet also helps manage node resources and provides the cluster with information about the status of running workloads.

kubectl is the CLI (Command Line Interface) used to interact with a Kubernetes cluster.
It lets you perform operations such as:

• creating, editing and deleting resources;
• managing pods and services;
• scaling applications;
• checking resource status;
• viewing events and logs.

kubectl communicates with the cluster through the API Server.

A pod is the smallest deployable unit that can be managed by Kubernetes and consists of one or more containers running together on the same node.
Containers within the same pod share the same network namespace and IP address and can communicate with each other using localhost. They can also share volumes and other resources defined for the pod.
Kubernetes manages the lifecycle of pods and, when necessary, can replace an unavailable pod to maintain the desired state of the application.

The API Server is the control plane component that exposes the Kubernetes API and is the main access point for managing the cluster.
It receives and validates requests, manages authentication and authorisation mechanisms and allows cluster components and external tools, such as kubectl, to interact with Kubernetes resources.

etcd is a distributed key-value store used by Kubernetes to store data about the state and configuration of the cluster.
Data is replicated to ensure availability and reliability and is used by the control plane to maintain the state of the cluster.

The scheduler is the control plane component responsible for assigning pods to worker nodes.
For each pod to be run, it evaluates the available resources, configured requirements and constraints, and selects the most suitable node on which to run it.

A controller is a software component that monitors the state of cluster resources and takes action to bring the current state closer to the desired state.
The main functions of Kubernetes controllers include:

• state monitoring - they monitor the state of the cluster and its resources through the API Server;
• reconciliation - they compare the current state of resources with the desired state and take action when necessary;
• event management - they respond to events such as the creation, modification or removal of resources;
• dependency management - where applicable, they coordinate relationships between resources.

Controllers are fundamental components of the Kubernetes declarative management model.