So let's get started on macOS.
And first of all, we should check
if we fulfill the requirements
even though I'm very confident that you do,
but you can simply copy this command
from the before you begin section into your terminal,
and you'll see this output.
And somewhere in this output,
you should see a colored VMX key or word.
And if you see that, you're fulfilling the requirements,
you can now move on to the next step.
If you're not seeing this,
you probably shouldn't be at this point in the course
because then Docker shouldn't work either.
So therefore, let's next install the kubectl tool,
which we always need.
Now we can visit the official installation guide
to learn how that works.
And it is really straightforward.
You can either follow this first approach
using curl or actually use Homebrew,
which is an extra package manager,
which you might need to install
as instructed on the Homebrew page.
It's just one command and really easy to do.
So you can execute this command
in your terminal to install Homebrew.
And once you've got Homebrew installed,
you can run brew install kubectl,
so this command here
to install the kubectl tool on your Mac.
So that's what I'm doing here.
I'm now installing this tool
and this can take a couple of minutes,
but once it is finished,
you will have to kubectl tool installed locally
on your Mac system.
And we will need that to communicate with the Cluster later.
So let's wait for that to finish.
And once it's finished,
you can check whether it worked
by running this command here, kubectl version --client.
And you should see some output here
which proves that it was installed successfully.
So now that is kubectl installed,
now we can install minikube
to have that local development Cluster.
And for this, you need a hypervisor first,
which is basically the software,
you could say, which will create that virtual machine.
You can pick any of the three,
but I will go with VirtualBox
since this also works on Windows
and therefore I have one and the same setup
on Windows and macOS.
You can of course choose any of the three.
So on the VirtualBox page,
you can now install VirtualBox on your Mac
simply by clicking on OS X hosts here
and then downloading this installer here in the end.
And with that downloaded,
we can start this installer, this VirtualBox installer.
Follow the steps we see here,
so double click on this icon
and then walk through the installer you should get here.
Which, of course, again can take a couple of minutes.
If you get a system extension block warning,
go to your settings, make sure you can change them,
and click allow here and close this and run this again.
This time it should now succeed.
That looks better.
And now with that installed,
we've got VirtualBox installed
and therefore we can now install minikube.
Again, we can do this with Homebrew,
which we already installed earlier for the kubectl command.
We don't need to install Homebrew again,
but now we can run brew install minikube
to install this minikube playground environment tool,
you could say,
which again can take a couple of minutes.
And once you got it installed,
you can confirm the installation
by calling minikube start --driver=
and then your virtual hypervisor you chose before.
So I just installed VirtualBox.
So this is my driver.
You can see a list of all drivers here.
But, of course, you should choose the one you installed.
And if that was all the VirtualBox,
you just use VirtualBox here and set this as a driver,
which simply instructs minikube
to use VirtualBox to create this demo Cluster in.
So if I now hit enter,
this gets created
and this again can take a couple of minutes,
but now this in the end sets up this virtual machine
on your local machine and it creates the Cluster,
the Kubernetes Cluster inside of that virtual machine.
It creates the master node
and installs all the software the master node needs on it.
And it also installs all the worker nodes software.
So once this is completed,
once this instruction here is done,
we have our local development Cluster
which we can then control with the kubectl command
and where we can then apply our Kubernetes configuration
to run our containers inside of this demo local Cluster.
And the cool thing is that the configuration we come up with
will then later all the work in a remote Cluster,
for example, in a Cluster set up on AWS.
But we'll see that in action later
once we dive into deploying our Kubernetes setup
to remote machines.
So for the moment, let's wait for this to finish
and let's then see whether everything works.
So now it finished for me
and we can now verify whether it works
by calling or by running minikube status, minikube status.
This looks good.
Everything is up and running
and we can now all the run minikube dashboard, woops!
minikube dashboard, that's the correct command
to bring up a web dashboard of our Cluster.
This is a process which keeps on running.
You can quit it with Ctrl+C,
but it should also open up a new tab in your browser,
this tab, and there you can actually see
your running Cluster.
And this is simply some utility tool,
which you can use to see
for example, any running pods
of which we have none at the moment,
because we haven't created any Kubernetes deployment,
but we will be able to basically see what's going on
in our Cluster here.
So for the moment, I'll quit this
and quit this process with Ctrl+C,
but we can definitely say that everything is working now.
So now in the next lecture,
we'll set this up on Windows.
Of course, you can skip this if you have no Windows system
and thereafter we'll get started
with working with Kubernetes on this demo Cluster.