by the end of this course,

we'll have a deep understanding of all the main concepts

and also a great big picture overview of how

Docker is used in the whole software development process.

The course is a mix of animated theoretic explanations,

but also hands on demos for you to follow along.

So get your first hands on experience and confidence

using Docker in your projects.

So let's quickly go through the topics

I'll cover in this course.

We will start with the basic concepts of what Docker actually

is and what problems it solves.

Also will understand the difference between

Docker and virtual machine. And after installing Docker,

we will go through all the main documents to start

and stop containers, debugging containers, etc..

After that,

we'll see how to use Docker in practice

by going through a complete workflow with a demo project.

So first we'll see how to develop

locally with containers.

Then we'll run multiple containers or services with Docker

Compose, we'll build our own Docker image with Dockerfile

and will push that built image into a private

docker repository on AWS and finally will deploy our

containerized application. Last but not least,

we look at how to persist data in Docker,

learning the different volume types and afterwards configure

persistance for our demo project.

If you get stuck anywhere,

just comment under the video and I will try my

best to answer your questions. Also,

you can join the private tech world.

We're not a community group on Facebook,

which is there to exchange your knowledge

with others and connect with them,

if you like the course by the end of the video.

Be sure to subscribe to my channel for more

related content. So let's get started.

So we'll talk about

what a container

is and what problems it solves.

We will also look at a container repository,

which is basically a storage for containers.

We'll see how a container can actually make

the development process much easier and more efficient

and also how they solve some of the problems

that we have in the deployment process of applications.

So let's dive right into it. What a container is,

a container is a way to package applications with everything

they need inside of the package,

including the dependencies and all the configuration necessary.

And that package is portable,

just like any other artifact is in.

That package can be easily shared and moved around

between a development team or development

and operations team.

And that portability of containers plus everything

packaged in one isolated environment gives it some

of the advantages that makes development

and deployment process more efficient.

And we'll see some of the examples of how

that works in later slides, so as I mentioned,

containers are portable,

so there must be some kind of a storage for those

containers so that you can share them and move them around.

So containers leave in a container repository.

This is a special type of storage for containers.

Many companies have their own private repositories where

the host or the way they store all the containers

and this will look something like this where

you you can push all of the containers that you have.

But there is also a public repository for docker

containers where you can browse and probably

find any application container that you want.

So let's head over to the browser and see

how that looks like.

So if I hear search for a Docker,

which is the name of the public repository for Docker,

I will see this official web. So here, if you scroll down,

you see that they're.

More than a hundred thousand container images

of different applications hosted or stored

in this repository.

So here you see just some of the examples.

And for every application,

there is this official docker container or container image.

But if you are looking for something else,

you can search it here.

And I see there is an official image for, let's say, Jenkins',

but there's also a lot of non official images or container

images that developers or for or even

from Jenkins' itself, they actually store it here.

So public repository is where you usually get started

when you're using or when you're starting

to use the containers where you can find any

application image.

So now let's see how container's improved

the development process by specific examples,

how did we develop applications before the containers?

Usually when you have a team of developers

working on some application,

you would have to install most of the services on your

operating system directly. Right. For example,

you you're developing some JavaScript

application and you need to be cool and ready for messaging.

And every developer in the team would then have

to go and install the binaries of those services and.

Configure them and run them on their local development

environment and depending on which operating

system they're using,

the installation process will look actually different.

Also, another thing with installing services

like this is that you have multiple steps of installation.

So you have a couple of commands that you have to execute.

And the chances of something going wrong and error

happening is actually pretty high

because of the number of steps required to install

each service.

And this approach or this process of setting

up a new environment can actually be pretty tedious,

depending on how complex your application is.

For example,

if you have 10 services that your application is using,

then you would have to do that 10 times on each

operating system environment.

So now let's see how containers solve some of these

problems with containers.

You actually do not have to install any of the services

directly on your operating system because the container

is its own isolated operating system layer

with Linux based image.

As we saw in the previous slides,

you have everything packaged in one isolated environment.

So you have the postgresql with the specific version

packaged with a configuration in the start script

inside of one container. So as the developer,

you have to go and look for the binaries to download

on your machine,

but rather you just go ahead and check out

the container repository to find that specific

container and download on your local machine.

And the download step is just one docker command

which fetches the container and starts it at the same time.

And regardless of which operating

system you're on, the command,

the doc recommend for starting the container

will not be different. It will be the exactly the same.

So we have 10 applications that your JavaScript

application uses and depends on.

You would just have to run 10 docker commands for each

container and that will be it.

Which makes the setting up your local development environment

actually much easier and much more efficient

than the previous version. Also,

as we saw in the demonstration before,

you can actually have different versions of the same

application running on your local environment

without having any conflict.

So now let's see how container's can improve

the deployment process before the containers,

a traditional deployment process will look like this.

Development team will produce artifacts together with a set

of instructions of how to actually install

and configure those artifacts on the server.

So you would have a jar file or something

similar for your application. And in addition,

you would have some kind of a database service or some

other service also with a set of instructions of how

to configure and set it up on the server.

So development team would give those artifacts

over to the operations team and the operations team will

handle setting up the environment to deploy

those applications. Now,

the problem with this kind of approach is that,

first of all,

you need to configure everything and install

everything directly on the operating system,

which we saw in the previous example that could actually

lead to conflicts with dependency version

and multiple services running on the same host.

In other problems that could arise

from this kind of process is when there

is misunderstanding between the development team

and operations because everything

is in a textual guide as instructions.

So there could be cases where developers forget

to mention some important point about configuration.

Or maybe when operations team misinterpreted some of those

instructions and when that fails,

the operations team has to go back to the developers

and ask for more details.

And this could lead to some back and forth

communication until the application

is successfully deployed on the server with containers.

This process is actually simplified because, no,

you have the developers and operations working

in one team to package the whole configuration

dependencies inside the application,

just as we saw previously.

And since it's already encapsulated in one single

environment and you're going to have to configure any

of this directly on the server.

So the only thing you need to do is run a docker command

that pulls that container image that you've stored somewhere

in the repository and then run it. This is,

of course, a simplified version,

but that makes exactly the problem that we saw

on the previous slide much more easier.

No environmental configuration needed on the server.

The only thing, of course,

you need to do is you have to install and set up

the DOCA runtime on the server before you will be able to run.

Container's there, but that's just one time effort.

Now that you know

what a container concept is,

let's look at what a container is technically.

So technically container is made up of images.

So we have layers of stacked images on top of each other.

And at the base of most of the containers,

you would have a Linux based image,

which is either Alpina with a specific version

or it could be some other Linux distribution.

And it's important for those base images to be small.

That's why most of them are actually Alpine,

because that will make sure that the containers

stay small in size,

which is one of the advantages of using container.

So on top of the base image,

you would have application image and

this is a simplified diagram.

Usually you would have these intermediate images

that will lead up to the actual application image that is going

to run in the container. And of course, on top of that,

you will have all this configuration data. So, no,

I think it's time to dove into a practical example

of how you can actually use a docker container and how

it looks like when you install it and downloaded and run

it on your local machine.

So to give you a bit of an idea of how this works,

let's head over to Docker Hub and search

for Posterous Keywell.

So here,

which is a doctor official image,

I can see some of the versions and let's say I'm looking