SPEAKER 1: Kubernetes-- I hear everyone
has been talking about it, and you've probably
heard of it, too.
It's become pretty popular, and I think it's time
to learn what it is.
[MUSIC PLAYING]
With a whole universe of things to learn,
it's important to start with the essentials.
Let's go over the concepts that make
Kubernetes usable, scalable, and just downright awesome.
Are you ready?
Hey, [INAUDIBLE].
Good to see you.
I was just going over what Kubernetes is.
SPEAKER 2: That sounds like fun!
Kubernetes is a portable, extensible, open-source
platform for managing containerized workloads
and services that facilitates both declarative configuration
and automation, letting you run distributed
systems resiliently, with scaling and failover
for your application.
SPEAKER 1: OK, well, that's a lot.
Do you have a way to simplify that?
SPEAKER 2: Good call.
Basically, it's a container orchestrator
that helps make sure that each container is where
it's supposed to be and that the containers can work together.
SPEAKER 1: Oh, that makes me think
of a conductor that manages everything in an orchestra.
Are the horns going?
Oh, the drums-- they should be going now.
SPEAKER 2: Exactly.
There's a lot of moving points in a scalable application.
Just like a conductor makes sure the song sounds
like a composer wants, Kubernetes
makes sure services are running smoothly
the way an app developer wants.
SPEAKER 1: Mmm.
OK, before we get into more details about the what,
let's go over why it was created.
See, there are a lot of applications
that we call monoliths, which means
they put all the functionality, like transaction
and third-party integration, into a single deployable
artifact.
SPEAKER 2: And monoliths are a common way
to build applications, even today.
But they still have their downfalls.
For example, deployments can take a long time,
since everything has to roll out all together.
And if different parts of the monolith
are managed by different teams, there
could be a lot of additional complexity
when prepping for a rollout.
SPEAKER 1: And scaling has the same problem.
Teams have to throw resources at the whole application,
even if the bottleneck is only on a single area.
SPEAKER 2: Right.
So people came up with microservices.
Each piece of functionality is split apart
into smaller individual artifacts.
If there's an update, only that exact service
has to be replaced.
SPEAKER 1: And the microservice model
has scaling benefits, too.
Now individual services can be scaled to match their traffic,
so it's easier to avoid bottlenecks
without over-provisioning.
SPEAKER 2: This is all great, but having
one machine for each service would
require a lot of resources and a whole bunch of machines.
SPEAKER 1: That's why containers are the perfect choice.
With containers, teams can package up their services
neatly.
All the applications, their dependencies,
and any necessary configuration get delivered together.
This also means that they can be sure their services will
run the same way, no matter where they're run.
SPEAKER 2: But there are still more problems
that remain unsolved.
Upgrading a container is easy, since you
can create a new version of the container
and deploy it in place of the old one.
But how can upgrades be done without downtime?
How do these containers know how to talk to the other ones?
And how can the app developer debug issues
and observe what's happening?
SPEAKER 1: And now we've come back
to the conductor of our container orchestra.
Kubernetes is all about managing these containers
on virtual machines or nodes.
The nodes in the containers they run
are grouped together as a cluster,
and each container has endpoints, DNS, storage,
and scalability.
SPEAKER 2: Everything that modern applications
need, without the manual effort of doing it yourself.
Kubernetes automates most of the repetition and inefficiencies
of doing everything by hand.
The app developer tells Kubernetes
what it wants the cluster to look like,
and Kubernetes makes it happen.
SPEAKER 1: See, this all sounds amazing.
So everyone should just switch to Kubernetes, yeah?
SPEAKER 2: Well, not so fast.
Microservices still have their own unique challenges,
and sometimes a monolith can be the right solution,
based on what's right for the application itself.
And monoliths can still run on Kubernetes,
even though they won't be able to use all the same benefits.
SPEAKER 1: Either way, how do you
know when you're ready to get started with Kubernetes?
SPEAKER 2: Well, the first step is to start using containers.
That's easier said than done, but let's
save that for the next episode.
SPEAKER 1: OK, so now we have an idea
of what kinds of problems Kubernetes helps with,
and we've also got an orbital view of what it actually does.
SPEAKER 2: Yep.
Next time, let's dig into containers.
SPEAKER 1: Containers, huh?
OK, stay tuned, everybody.
If you want to get hands on, check out
the link in the description.
And if you enjoyed the episode, subscribe for more.
[MUSIC PLAYING]