So this was an important module.
We got our hands dirty with Kubernetes
and we first of all learned, what we need to set up,
the cluster and the infrastructure for the cluster,
the software on the cluster
and what Kubernetes does will do.
We also learned that there are tools
that can help us with setting up the cluster.
Locally that would be Minikube
to give us this development environment
and on a cloud provider,
that's something we're going to explore later,
we'll also have tools that help us.
Now since we work locally,
we started with creating
such a local development environment
with the help of Minikube to get a local cluster
in a virtual machine, running on our local machine
and we installed the Kube control tool,
which we will always need,
not just if we work locally,
because that's our communication device
for sending instructions to the Kubernetes cluster.
Now we learned that Kubernetes works
with so-called objects.
So the different resources we have running
in a Kubernetes clusters are in the end, all such objects.
And we can create them in two different ways,
imperatively or declaratively.
Now with the imperative approach,
we executed commands like, create deployment,
giving it a name and specifying the image
which should be used.
Something like this.
And this worked just fine.
It just was quite a bunch of typing.
Of course we did not just do this for deployments,
but then for example, also to expose a deployment
by creating a service where we then specify
a port and also the type of service.
These were the imperative commands we saw.
And we did not just see the commands for creating things,
but also for deleting or for setting a new image
and therefore for updating currently running deployments.
But then we also learned about the more modern
and a bit more convenient declarative approach.
There you write down your configuration
in these YAML files and you then simply apply them
with the Kube control tool and the apply command.
And you can apply just one file, as you learned
or also multiple files at once.
And whenever you make a change to one of these files
and you reapply it, the cool thing is,
that only these parts will be changed automatically
by Kubernetes on the running application in your cluster.
Now you can also delete resources
that were created based on files
by using delete with the dash F option like this.
And of course, you also learned
that you can merge multiple definitions into one file,
in case you don't want to manage multiple files
and also to make it easy to see which services
and deployments and maybe other resources belong together.
Now, when it comes to these files,
we had a look at how they are structured
and what the different options do in here,
how labels and selectors work together
to connect different resources,
how we define paths and containers,
how we can control the health checks which are performed,
how we can control when images are pulled and so on.
And I also pointed you at the official API reference,
which can be useful for finding out
which options can be set
and what these different options do.
Though, I also of course mentioned
that many of these options will rarely be needed.
So don't be overwhelmed by the long list
of options that can be set on certain objects.
And with that,
we get all the important Kubernetes basics down.
We know the big picture
and the general architecture or philosophy
behind Kubernetes, but then even more important than that,
we also now know how to work with this architecture
and how to bring this big picture to life.
So now we'll dig deeper into Kubernetes
and have a look at a couple of key problems
which you'll face in almost any application,
so that you're also prepared to build such applications.