We already learned
quite a bit about Kubernetes
and in the end we do use Kubernetes,
to deploy our containers to some host machines,
one or multiple host machines.
At the moment, with minikube, it's one host machine,
it's this virtual machine on our local host machine.
But the idea behind Kubernetes,
as explained throughout the last module,
of course is that eventually we can deploy our application
to a multi-machine, a multi-node cluster.
Now therefore, of course, when we deploy our containers,
we in the end face the same kinds of problems
we faced when working with Docker
locally on our local host machine
without any clusters or anything like that.
And for example,
one problem we'll also run into at some point
is how we store and manage data.
And how we can ensure that any data
created by our containers
survives if these containers shut down
or if, in the context of Kubernetes,
if the pods hosting these containers
also are removed or extended or moved between nodes.
And therefore in this course section
we are going to revisit a concept which we already saw
but which we up to this point only saw
in the context of our local machine
and of using Docker or Docker Compose.
And that would be volumes.
We're going to have another look
at volumes in this course section
and we're going to see how we can make volumes work
and survive with Kubernetes.
We're going to have a look at regular volumes
and we're then also going to dive into something called
persistent volumes and persistent volume claims.
And I will of course explain
what that is and why we need it.
Well, and then, kind of loosely related to that,
we're also going to have a look at working
with environment variables later in this course section.
So again, lot of content to go through,
let's not waste anytime and jump right in.