All About Kubernetes | Clusters, Nodes, Pods & More!

Kubernetes (K8s) is a container orchestration platform that makes sure each software container is where it's supposed to be and that containers can work together. Containers are fashioned so that developers can migrate code and its components from one environment to the next in a portable, lightweight way with minimum overhead. Kubernetes, Greek for "helmsman" or "pilot", is one of the most popular platforms for automating, deploying, scaling, controlling, monitoring and maintaining these containers.

Problems with Containers

If you're a developer, you probably often find yourself asking questions like:

• What happens if a container goes down? How do we keep the system running?
• How do we get containers to communicate?
• How do we observe what's going in containers?
• What's the protocol for finding containers?
• How do we organize containers?
• How do we scale containers up or down?

Deploying containers is one thing. Managing them is slow, inefficient and full of holes. That's where Kubernetes comes in.

How Kubernetes Works

Kubernetes resolves these issues through a system of clusters, nodes, pods, and kubelets that intercommunicate to monitor and automate containers. It scales or descales these containers, aggregates or segregates them, and heals faulty containers, among other functions. It also restarts orphaned containers, shuts down containers when they're not being used, and distributes containers in a logical and efficient way. At its core, Kubernetes gives you power over what gets done by managing, scaling and monitoring your containers.

The following are the main components of the Kubernetes system:

• The control plane is the brain of the cluster, feeding it incoming and outgoing signals (for example, scheduling), as well as detecting and responding to cluster events (for example, starting up a new pod when a deployment's replicas field is unsatisfied).
• Nodes run the containers. They are the worker machines, with each node running an "agent" called a kubelet.
• Kubelets are tiny applications that run on the machine and communicate with the control plane (or Master Node), relaying its signals.
• Pods are the smallest units of Kubernetes. Each node has multiple pods. 
• Etcd is the registry that stores data about the cluster.
• Objects define the desired state of the cluster. By creating an object, you're telling the Kubernetes system what you want your cluster's workload to look like.

Working with Kubernetes

Containers are stored as clusters of nodes. Each node has endpoints, DNS, pods, and kubelets, and is overseen by the master node, or control plane.  You specify the desired state of your clusters with "objects", achieved through a YAML configuration file listing the processes you want up and running. The control plane of Kubernetes then prompts the nodes and their minions (pods and kubelets) to automate your bidding.

Nodes help containers spread by adding scalability to the cluster. They also provide for fault-tolerance and a replica set for availability in case of downtime. Risk is distributed so that no running process can be taken down by a single point of failure. Kubernetes is self-healing, always returning the system to the ideal state specified by your objects in the deployment, by either curing or slaying flawed containers.  

Kubernetes uses new container images pulled from the Etcd registry as rolling updates for a smooth, stable transition.

The following are some of the benefits of working with Kubernetes:

• Load balancing, namely distributing traffic among the various containers.
• Tracking containers through their DNS names or IP addresses.
• Storage through local services, public cloud providers, and more.
• Automated rollouts and rollbacks. You can automate Kubernetes to create new or remove existing containers.
• Self-healing capability. Kubernetes restarts stalled containers, replaces others and kills those that are hopelessly flawed.
• Deep security. Kubernetes secures sensitive information, such as passwords, OAuth tokens, and SSH keys.

In Short:

As this handy Google Cloud cartoon strip illustrates, if you're trying to manage hundreds or even thousands of containers, Google Cloud's Kubernetes Engine monitors, controls, and automates them.

Extra Credit: