So as mentioned,
we don't just have containers,
we also have images, when working with Docker.
Now, what is the difference,
and why do we need both?
We already heard about Containers
in the first course module.
You learned that containers in the end are small packages,
you could say, that contain both your application,
your website, your Node server,
whatever it is, and also,
and that's important, the entire environment
to run that application.
So a container is there's a running unit of software.
It is the thing which you run in the end.
But when working with Docker,
we also need dissolver concept called Images,
because images will be the templates,
the blueprints for containers,
it's actually the image,
which will contain the code
and the required tools to execute the code.
And it's the container that then runs and executes the code.
And we have this split, this separation here,
so that we can create an image
with all these setup instructions and all our code once,
but then we can use this image
to create multiple containers based on that image.
So that, for example,
if we talk about a Node.js web server application,
we can define it once,
but run it multiple times on different machines,
and different servers.
And the image is that sharable package
with all the setup instructions and all the code.
And the container will be the concrete running instance
off such an image.
So we run containers, which are based on images.
That is the core fundamental concept,
Docker is all about in the end.
Images and containers,
where images are the blueprints,
the templates which contained the code
and the application, and containers,
are then the running application.
And this will become clearer throughout this module,
once we start working with images and containers,
and actually let's start working with that, right now.
Let's see how we can work with images,
and containers when using Docker.