A Tale of Phippy: Understanding Kubernetes Through Storytelling

Dedicated to all parents trying to explain software engineering to their children.

Once upon a time, there was an application called Phippy. It was a simple, single-page PHP app. It lived on a host that it had to share with other frightening applications, none of which it knew or wanted to interact with. Phippy longed for a dedicated environment—a web server that could be called its own home.

Every application runs in an environment; for a PHP app, this typically includes a web server, a readable filesystem, and the PHP engine itself.

One day, a kind whale appeared and suggested that little Phippy live inside a container, which might make it happier. So Phippy migrated into a container. The container was wonderful, yet it felt like a luxurious living room floating in the middle of the ocean.

Containers provide isolated environments for applications to run, but these isolated containers often need to be managed and connected to the outside world. Challenges include sharing filesystems, network communication, scheduling, load balancing, and distribution.

The whale shrugged, said “Sorry, child,” and vanished beneath the waves. As Phippy began to despair, a captain steering a massive ship appeared on the horizon. The ship was made of dozens of tied‑together rafts, but from afar it looked like a single giant vessel.

“Hello, PHP application friend. I am Captain Kube,” the wise old captain said.

‘Kubernetes’ means ‘captain’ in Greek. From the word we can derive the terms ‘Cybernetic’ and ‘Gubernatorial.’ The Kubernetes project focuses on building a robust platform for running thousands of containers in production.

Kubernetes uses labels as ‘name tags’ to identify objects. They can be queried, and are open‑ended: you can use them to denote role, stability, or other important attributes.

The captain suggested that the application move its container into a cabin on the ship. Phippy happily moved its container into a cabin on Captain Kube’s giant vessel, feeling that it was like home.

In Kubernetes, a Pod represents a runnable unit of work. Typically a single container runs in a Pod, but for tightly coupled containers you can run multiple containers in the same Pod. Kubernetes connects your Pod to the network and the rest of the Kubernetes environment.

Phippy, who has an unusual interest in genetics and sheep, asks the captain, “If I want to clone myself, can I clone myself any number of times on demand?”

“That’s easy,” the captain replied, introducing Phippy to a Replication Controller.

A Replication Controller provides a way to manage any number of Pods. It contains a Pod template that can be replicated arbitrarily. Through a Replication Controller, Kubernetes manages the Pod lifecycle, including scaling, rolling updates, and monitoring.

For countless days and nights, the little application enjoyed being with its copies in the cabin, but being with oneself isn’t as wonderful as it sounds… even if you have N clones of yourself.

Captain Kube smiled kindly, “I happen to have something.”

He opened a tunnel between Phippy’s Replication Controller and the rest of the ship. Captain Kube said, “Even as your copies come and go, this tunnel remains; you can use it to discover other Pods, and other Pods can discover you!”

A Service informs the rest of the Kubernetes environment (including other Pods and Replication Controllers) about the services your application provides. While Pods come and go, the Service’s IP address and port remain constant, allowing other applications to discover your service via Kubernetes service discovery.

Phippy met Goldie, who gave her a gift, but Phippy had nowhere to store it. Goldie suggested putting it into a volume.

A volume represents a location where a container can access and store data. For an application, a volume appears as part of the local filesystem, but it can be backed by local storage, Ceph, Gluster, persistent block storage, or other storage backends.

“That sounds like what you need,” Captain Kube said, “it’s a namespace.”

Namespaces are an internal grouping mechanism in Kubernetes. Services, Pods, Replication Controllers, and volumes can collaborate easily within a namespace, while namespaces provide a degree of isolation from the rest of the cluster.

Phippy sailed across the sea aboard Captain Kube’s giant ship with her new friends, experiencing many great adventures, but most importantly, she found a home. And so Phippy lived happily ever after.