That's it for this key module.
We learned a lot in this course module.
We learned a lot about the core fundamentals
you have to know when working with Docker.
One of the most important takeaways
and kind of the heart of Docker is that Docker
is all about images and containers.
But in this module you learned what this means.
It means that images are the templates,
the blueprints for containers and you can run
multiple containers which are based
on one and the same image and you can have multiple images
for different containers as well.
And you learned that these containers would then be run
in an efficient way as a tiny layer on top of your image
using the code and the environment
which is stored in the image, not in the container,
but then actually running the application
which is set up and configured with help of the image.
That's how work is split between image and container
and how multiple containers running the same application
can be executed in isolation
with a very low footprint on your system.
Now images are either downloaded with docker pull
or created with help of a Dockerfile
if you build your own image.
A Dockerfile and docker build builds a new image.
And in this module we built a couple of Dockerfiles
and the structure's always very similar.
Often we use a base image, like in this case Node
which then in turn might use
even another base image internally.
And then we have our instructions that configure this image,
that control what is copied into the image
and how the environment should be set up.
And last but not least we have that command
which should be executed whenever we run
a container based on that image.
And all these instructions
which you put into your Dockerfile create layers.
Images as you learned are made up of multiple layers
and this layer concept exists to optimize build speed
since Docker is able to cache layers and doesn't need
to rerun them if nothing changed about that step
and it also helps with reusability.
For example, if you share an image
which is based on Node,
then Docker is able to find out
that this Node image already exists,
maybe didn't change and therefore it's able to efficiently
link this to your image.
For example, if you share your Docker image on Docker Hub.
So that's images.
Containers of course are why we're all here though.
We run containers based on images
with the docker run command
and throughout this module you saw
that there are a lot of options and flags
which can be set on the docker run command.
You can make the container interactive if it needs it
to allow the user or yourself
to enter something into the running application.
You can assign a name.
You can ensure that the container
is automatically removed if it stops.
And there are many other options,
some which you need often
and a lot of options which you rarely need.
We're going to see more options
throughout this course of course.
Now running containers is one thing,
but you got various commands to manage containers as well.
You can list and remove containers
with the respective commands
and you can stop and start them if you want to.
And the same is true for images.
They can also be listed or removed if you need to
and you can share them with docker push and pull.
For example with Docker Hub
as you saw in the last lectures of this module.
Now at this point, all the core concepts
discussed in this module should be clear.
If they're not, definitely revisit the lectures
where I talk about them, where I explain them
so that we all are on the same page after this module.
Also make sure you have a look at that assignment
which you find in this module.
It's a great practice
and I recommend that you take advantage of that.
Attached to the last lecture of this module
so the lecture after this one,
you find a cheat sheet with the key commands and concepts
you should know after this module
so that can be great as well as an additional help
to also keep all these concepts in mind
and have a resource for quickly looking up certain concepts.
So definitely also take advantage of that cheat sheet
attached to the next lecture.
And with that, let's move on
and let's dig deeper into Docker.