Welcome back.


In this part of the course


I want to spend some time


introducing all of the key components of Docker.


We're going to be focusing on what each component is


and does, as well as how these components


relate or interact with each other.


This is one of the most important parts of the course


because it will act as a foundation for everything else.


So let's jump in and get started.


I want to keep this part of the course high level.


I'm only introducing things now


before you'll learn about them in detail


and use them practically later in the course.


Now, when you hear the term Docker or Docker Engine


think about a client server application.


We start with the Docker Host, and it's a Docker Host


because it's running the Docker Daemon.


This is the part which does the heavy lifting.


It's the brains of the Docker platform.


This is the server part of the Docker Engine


Client Server architecture.


The Docker Daemon is a long-running service


and it provides API access to be able to interact with it.


The API access is used by Docker clients


which are the client side of the Docker Engine.


This can either be the Docker command line


or Docker Desktop, but it can also be applications


which you or a developer might code,


which interact with the Docker Daemon directly.


On the Docker Host under the control of the Docker Daemon


are two main things, containers and container images.


Now, there are other elements such as storage and networking


but I'll be talking about those in much more detail


elsewhere in the course.


We gain nothing by over complicating it


at this point in the course.


There's another component which I haven't mentioned yet


and that's a registry or a hub


and this is a public or private store for Docker images.


Images are used to run containers,


so if you want to run an application within a container,


you need an image which has that application,


as well as any libraries which it uses,


and any runtime environments


and registries store these images.


So in this example, you might have a base Linux image


or maybe an image for a game server.


In this case, let's assume both are public.


Now, to run a container on a Docker Host


like ours in the middle, in this example,


we need to have images on the Docker Host itself,


and we can get images in two different ways.


We can download them or we can create them


on the Docker Host.


To download Docker images onto a Docker Host,


we'd need to run a Docker pull command via the Docker client


and this would communicate with the Docker Daemon


which would pull those images down from the registry


to the Docker Host.


Another way you can obtain Docker images is to create them


and this is done using the Docker build command


also via the client.


This command takes as an input


something known as a Dockerfile.


Now, a Dockerfile is a list of directives or statements


on how to create a Docker image


and don't worry, I'll be covering this later in the course.


You're even going to create your own.


The client gives that Dockerfile to the Docker Daemon


and the Docker Daemon uses this Dockerfile


to create an image.


Once you have one or more images running on the Docker Host


you can use the Docker run command


and the Docker Daemon will use this command


and run containers using Docker images.


A container is just like a Docker image


only instead of being read only


we add a read write component, and this becomes a container.


It allows data to be stored within that container


and allows the container to be run on a Docker Host.


Once containers are running


they can be stopped and started during their lifecycle.


You can also, once you've created images


push these into a registry, for example, Dockerhub


and again, these can be public or private.


And you do this using the Docker push command.


Docker push takes an image that's on the Docker Host


and pushes it into a registry.


Now, at a high level


this is the architecture of a typical Docker deployment.


You might have one host or 100,


one image or 1,000, one container or many containers.


The architecture at a high level is the same.


Now, there are many other components


that I've yet to talk about,


and I've kept this to a high level


so there are certain things that I've said


that do have some technical nuance.


But this is the foundation that we'll build on and expand


as we move through this part of the course.


At this point though


that's everything that I wanted to talk about right now.


I hope it was understandable.


If not, just go ahead and watch


this part of the course again.


Otherwise, when you're ready,


go ahead and move on to the next part of the course.