Kubernetes, or k8s (k, 8 characters, s...get it?), or
kube if you're into brevity,
is an open source platform that automates Linux container operations. It eliminates many of the
manual processes involved in deploying and scaling containerized applications. In other words, you
can cluster together groups of hosts running Linux containers, and Kubernetes helps you easily and
efficiently manage those clusters. Kubernetes clusters can span hosts across public, private, or
hybrid clouds. For this reason, Kubernetes is an ideal platform for hosting cloud‐native
applications that require rapid scaling, like real‐time data streaming through Apache Kafka.
Kubernetes was originally developed and designed by engineers at Google. Google was one of the
early contributors to Linux container technology and has talked publicly about how everything at
Google runs in containers. (This is the technology behind Google's cloud services). Google
generates more than 2 billion container deployments a week, all powered by an internal platform:
Borg. Borg was the predecessor to Kubernetes and the lessons learned from developing Borg over the
years became the primary influence behind much of Kubernetes technology.
Red Hat was one of the first companies to work with Google on Kubernetes, even prior to launch, and
has become the 2nd leading contributor to the Kubernetes upstream project. Google donated the
Kubernetes project to the newly formed Cloud Native Computing Foundation in 2015.
What can you do with Kubernetes?
The primary advantage of using Kubernetes in your environment, especially if you are optimizing app
dev for the cloud, is that it gives you the platform to schedule and run containers on clusters of
physical or virtual machines (VMs). More broadly, it helps you fully implement and rely on a
container‐based infrastructure in production environments. And because Kubernetes is all
about automation of operational tasks, you can do many of the same things that other application
platforms or management systems let you do, but for your containers.
With Kubernetes you can:
- Orchestrate containers across multiple hosts.
- Make better use of hardware to maximize resources needed to run your enterprise apps.
- Control and automate application deployments and updates.
- Mount and add storage to run stateful apps.
- Scale containerized applications and their resources on the fly.
- Declaratively manage services, which guarantees the deployed applications are always running the
way you deployed them to run.
- Health-check and self-heal your apps with autoplacement, autorestart, autoreplication, and auto
However, Kubernetes relies on other projects to fully provide these orchestrated services. With
the addition of other open source projects, you can fully realize the power of Kubernetes. These
necessary pieces include (among others):
- Registry, through projects like Atomic Registry or Docker Registry.
- Networking, through projects like OpenvSwitch and intelligent edge routing.
- Telemetry, through projects such as Kibana, Hawkular, and Elastic.
- Security, through projects like LDAP, SELinux, RBAC, and OAUTH with multitenancy layers.
- Automation, with the addition of Ansible playbooks for installation and cluster life cycle
- Services, through a rich catalog of popular app patterns
Learn to speak Kubernetes
Like any technology, there are a lot of words specific to the technology that can be a barrier to
entry. Let's break down some of the more common terms to help you understand Kubernetes.
Master: The machine that controls Kubernetes nodes. This is where all task
Node: These machines perform the requested, assigned tasks. The Kubernetes master
Pod: A group of one or more containers deployed to a single node. All containers
in a pod share an IP address, IPC, hostname, and other resources. Pods abstract network and storage
away from the underlying container. This lets you move containers around the cluster more easily.
Replication controller: This controls how many identical copies of a pod should be
running somewhere on the cluster.
Service: This decouples work definitions from the pods. Kubernetes service proxies
automatically get service requests to the right pod‐no matter where it moves to in the
cluster or even if it’s been replaced.
Kubelet:This service runs on nodes, reads the container manifests, and ensures the
defined containers are started and running.
kubectl:This is the command line configuration tool for Kubernetes.
Using Kubernetes in production
Kubernetes is open source and as such, there's not a formalized support structure around that
technology‐at least not one you'd trust your business on. If you had an issue with your
implementation of Kubernetes, while running in production, you're not going to be very happy.
And your customers probably won't, either.
That's where Red Hat OpenShift Container Platform comes in. OpenShift Container Platform is
Kubernetes for the enterprise‐and a lot more. It includes all of the extra pieces of
technology that makes Kubernetes powerful and viable for the enterprise, including: registry,
networking, telemetry, security, automation, and services. With OpenShift Container Platform, your
developers can make new containerized apps, host them, and deploy them in the cloud with the
scalability, control, and orchestration that can turn a good idea into new business quickly and
Best of all, OpenShift Container Platform is supported and developed by the #1 leader in open
source, Red Hat.
Why do you need Kubernetes?
Real production apps span multiple containers. Those containers must be deployed across multiple
server hosts. Security for containers is multilayered and can be complicated. That's where
Kubernetes can help. Kubernetes gives you the orchestration and management capabilities required to
deploy containers, at scale, for these workloads. Kubernetes orchestration allows you to build
application services that span multiple containers, schedule those containers across a cluster,
scale those containers, and manage the health of those containers over time. With Kubernetes you can
take real steps towards better IT security.
Kubernetes also needs to integrate with networking, storage, security, telemetry, and other
services to provide a comprehensive container infrastructure.
Of course, this depends on how you're using containers in your environment. A rudimentary
application of Linux containers treats them as fast, efficient virtual machines. Once you scale this
to a production environment and multiple applications, it's clear that you need multiple,
colocated containers working together to deliver the individual services. This significantly
multiplies the number of containers in your environment and as those containers accumulate, the
complexity also grows.
Kubernetes fixes a lot of common problems with container proliferation by sorting containers
pods.Pods add a layer of abstraction to grouped containers, which helps you
schedule workloads and provide necessary services‐like networking and storage‐to those
containers. Other parts of Kubernetes help you load balance across these pods and ensure you have
the right number of containers running to support your workloads.
With the right implementation of Kubernetes‐and with the help of other open source projects
like Atomic Registry, Open vSwitch, heapster, OAuth, and SELinux‐you can orchestrate all
parts of your container infrastructure.