Containers package applications and dependencies to run consistently across environments. Kubernetes uses containers grouped in pods, which are scheduled across nodes that provide computing resources. Nodes pool resources and run pods to distribute workloads, ensuring applications have necessary resources. Pods contain related containers and act as logical hosts, while nodes are physical or virtual machines that run pods.

2. What are containers?
Containers enable developers to package up an application with all of its required
parts and ship it out as one standard, lightweight, secure package. This gives
DevOps teams peace of mind knowing that the application they’re building and
supporting will run properly in any environment—whether a virtual machine, bare
metal, or the cloud. Containers essentially eradicate the “works on my machine”
problem inherent with monolithic applications.

3. What Are Kubernetes Nodes?
Nodes in Kubernetes can be described as the smallest units of computing power.
They are a collection of CPU and memory resources used by the tool to run
processes. Nodes are usually available in clusters — intelligent groups of nodes that
can distribute workload among their component nodes to increase efficiency. While
you can manage nodes independently, it is suggested to manage them via clusters to
enhance performance.
Individual nodes can be virtual machines or physical hardware, depending upon the
system’s requirements. They house the pods which run containerized applications
inside them. An entity called Master manages the nodes by assessing the available
resources and changing allocations as needed. Nodes communicate with the Master
via kubelet, an interface meant for this purpose.
Each Kubernetes Node runs at least one container runtime inside it. This runtime
takes care of managing the individual containers and pulling them from repositories
or registries as needed.

4. What Are Kubernetes Pods?
Pods replicate a logical host for containers that are tightly coupled with each other.
Although they can host multiple containers together, limiting the number of containers
in one pod to a minimum is advised. This is because pods are meant to be scaled up
and down quickly, and each container in the pod is scaled with it irrespective of its
requirements.
Pods are the smallest independent deployable units in Kubernetes. The Kubernetes
engine replicates or shuts down entire pods at once based on available resources
and incoming workload. Even when there is no high demand, multiple nodes are run
with the same pods for redundancy as far as resources are available.

6. What is a cluster?
A cluster is central to the basic architecture of Kubernetes: If you’re running
Kubernetes, you’re running at least one cluster. (Literally, there’s no such thing as a
Kubernetes deployment without a cluster.) This cluster is sort of like a central nervous
system for your application(s). Or, as Vempati explains it, it’s kind of like a
motherboard or circuit board powering your applications: “A cluster is a board that
provides the circuitry to run all the pods (which have the container instances in them)
in an orchestrated manner as defined by the users,” Vempati says.
So there’s a symbiotic relationship between these terms:
Container → Pod → Cluster
•“A container runs logically in a pod (though it also uses a container runtime);
•A group of pods, related or unrelated, run on a cluster. A pod is a unit of replication
on a cluster;
•A cluster can contain many pods, related or unrelated [and] grouped under the tight
logical borders called namespaces.”

7. What is the difference between Kubernetes Nodes vs. Clusters?
•A node is the smallest element of a cluster. A cluster is comprised nodes. The cluster
is a collective that shares overall execution of pods. Nodes pool their individual
resources together to form a powerful machine or cluster.
•When an application is deployed onto a cluster, Kubernetes automatically distributes
workloads across individual nodes.
•If nodes are added or removed, the cluster will then redistribute work.

8. What is a Kubernates?
Kubernetes is open-source software that helps in the deployment and scaling of
containerized applications. This is possible by grouping containers into logical units,
which are easier to discover and manage. Primary Kubernetes features include
storage orchestration, batch execution, load balancing, and automated rollouts and
rollbacks.
Kubernetes performs all these roles using Kubernetes containers, Kubernetes
Nodes, and Kubernetes Pods.
Once pods are created, Kubernetes assigns them to one or more nodes in the
cluster, and ensures the correct number of replica pods are running. Kubernetes
scans the cluster to ensure each set of pods is running as specified.

9. Diff between Containers vs Pods vs Nodes?
A Kubernetes container is software that contains all the dependencies, tools,
settings, and system libraries required to run a particular application.
Kubernetes Pods, on the other hand, are groups of application containers with
unique ports, image versions, and cluster IP addresses. A Pod can act as a logical
host for a specific application.
Kubernetes Nodes are responsible for running Pods. A Kubernetes Node can be a
virtual or physical machine that’s managed by a control plane. The Kubernetes
control plane acts as a container orchestration layer and exposes interfaces and
APIs.

10. How Kubernetes Nodes work?
Kubernetes Nodes are responsible for running Pods. These Pods can contain one or
more containers. Depending on the Kubernetes cluster, a Node can be either a
physical or a virtual machine. A Kubernetes cluster is composed of a group of worker
Nodes for running containerized applications.
Kubernetes Nodes have the following components:
•The kubelet for managing containers and Pods running on a host machine
•A container runtime for downloading containers from the registry
•The kube-proxy for maintaining network rules

11. How Kubernetes Pods work?
Pods can contain init containers, which are initialized during startup.
An init container is unique because it must be completed successfully
before other containers are executed. If the init container fails, the
kubelet will restart it repeatedly until it runs to completion.
Although Pods can accommodate multiple containers, one container per
Pod is most often the case. Nevertheless, tight-coupled containers on
the same Pod can still communicate quickly because they use a similar
network port, IP address, and network namespace. This functionality
supports an application’s lifecycle by ensuring access to the required
resources.

12. What is the difference between Kubernetes pods vs. nodes?
Pods are an abstraction of executable code, nodes are abstractions of
computer hardware, so the comparison is a bit apples-and-oranges.
Pods are simply the smallest unit of execution in Kubernetes, consisting
of one or more containers, each with one or more application and its
binaries.
Nodes are the physical servers or VMs that comprise a Kubernetes
Cluster. Nodes are interchangeable and typically not addressed
individually by users or IT, other than when maintenance is required.

13. How Do Nodes, Pods, and Containers Work With Each Other?
While the three terms might sound a little confusing, they have quite
distinct roles in Kubernetes. Here’s a quick list to understand this:
1.Containers are packages of applications and execution environments.
2.Pods are collections of closely-related or tightly coupled containers.
3.Nodes are computing resources that house pods to execute
workloads.

14. Container
A container bundles code and dependencies into one standard uniit of
software, called a “container image”. This container image isolates code
from the environment allowing the application to run consistently
regardless of infrastructure or computing environment.
Pod
The first layer of Kubernetes-native abstractions, a pod is a way to
bundle up and package containers into one logical grouping that
represents a process in your cluster. A pod can have one or more
containers that will all share the same environment.

15. Node
A node is the actual machine your pods are running on. They can be
bare metal or virtual machines.
Cluster
A cluster is a grouping and management abstraction for nods. All of the
orchestration and networking magic happens at the cluster level.

16. Summary
To summarize, nodes represent physical or virtual machines that provide
CPU and RAM resources for container-based applications. Nodes are
grouped together into clusters. And finally, instead of managing
containers individually, Kubernetes containers are housed into pods for
scheduling and execution. Pods are the unit of replication.

17. THANK YOU
Like the Video and Subscribe the Channel