Building Custom Docker Images #0004

62 min read


In this session, I describe how WordPress builds their official images by traversing through its official Dockerfile and it's series of dependencies on php-apache, debian docker images all way down to scratch.

Next, I build a custom Dockerfile that would create our own custom docker image containing a customized runtime output. I then push our image to our own custom docker registry while describing how one could use Azure, Google, or Amazon container registries apart from Docker Hub.

AI Generated Transcript


00:00.000 --> 00:10.440
And the recording will become available as a podcast in a location that you may or may

00:10.440 --> 00:11.440
not know.

00:11.440 --> 00:16.140
But if you go to my Twitter profile, you will see that there is this button right there

00:16.140 --> 00:17.640
meeting video recordings.

00:17.640 --> 00:20.560
If you hit on that button, it takes you to the podcast.

00:20.560 --> 00:23.980
That's where the recordings show up in Spotify.

00:23.980 --> 00:27.760
So today's recording will show up right here in like 24 hours.

00:27.760 --> 00:30.560
So that's where you can see the recording later on.

00:30.560 --> 00:33.480
And I am beginning our discussion.

00:33.480 --> 00:37.320
We are not streaming today for some technical reasons.

00:37.320 --> 00:45.600
Having said the topic for today is this, which you can read and it is about taking any application

00:45.600 --> 00:48.720
in any language that you have.

00:48.720 --> 00:55.560
And I will containerize it and run it in some cloud.

00:55.560 --> 00:56.840
That's the idea.

00:56.840 --> 00:58.400
So what is containerization?

00:58.400 --> 01:02.320
I think you probably kind of sort of know, but I will demonstrate that by doing it and

01:02.320 --> 01:04.720
then also describe as we go along.

01:04.720 --> 01:10.880
Now to containerize something, we need to have an application already that we will then

01:10.880 --> 01:14.960
run it directly first on the computer if you want.

01:14.960 --> 01:16.100
But that's not the goal.

01:16.100 --> 01:21.320
The goal is to containerize it and then run it inside a Docker container so that we can

01:21.320 --> 01:24.660
take that container image and put that in a cloud.

01:24.660 --> 01:30.640
So that's the portions that we will basically deal with where to get an app already.

01:30.640 --> 01:32.280
If you have an app, give it to me.

01:32.280 --> 01:37.760
If you don't have an app, I will get an app from somewhere open source.

01:37.760 --> 01:43.520
And then containerize it like that's the meat of the discussion today is taking an app and

01:43.520 --> 01:44.520
how do you do that?

01:44.520 --> 01:46.280
That's the most of the discussion.

01:46.280 --> 01:52.560
And then once you have it containerized, running it in any cloud is a subsequent step.

01:52.560 --> 01:56.080
We'll do that also later on.

01:56.080 --> 01:57.080
Probably not.

01:57.080 --> 01:58.080
It may not happen today.

01:58.080 --> 02:00.040
Just so you know, it may extend into another session.

02:00.040 --> 02:04.160
So we'll take this application and begin the direction.

02:04.160 --> 02:08.160
Apparently, you don't have any app to give it to me, which is fine.

02:08.160 --> 02:10.840
So I'll just pick an app myself.

02:10.840 --> 02:16.000
What I intend to pick is what we discussed briefly in the last session about an application

02:16.000 --> 02:19.600
known as WordPress.

02:19.600 --> 02:23.800
This is a open source product.

02:23.800 --> 02:25.400
It's available from here.

02:25.400 --> 02:30.080
You can download it and install it.

02:30.080 --> 02:31.160
And how do you install it?

02:31.160 --> 02:34.200
You read the installation guide.

02:34.200 --> 02:37.920
And this is the installation instructions.

02:37.920 --> 02:43.840
So we'll basically follow these instructions in a manner that will help us run this application

02:43.840 --> 02:49.920
in a container, in a Docker container, not directly on a computer, but in a container.

02:49.920 --> 02:52.680
That's the idea.

02:52.680 --> 02:55.200
So we will begin doing that.

02:55.200 --> 03:01.960
The easiest way, the cheat way, the cheating way is to not bother about containerization,

03:01.960 --> 03:08.720
but actually just use an existing image that these guys already created for us.

03:08.720 --> 03:12.640
So there is the WordPress Docker image.

03:12.640 --> 03:15.840
It's readily available already right there.

03:15.840 --> 03:19.600
You can just pull it if you like.

03:19.600 --> 03:21.760
And that's what I will be doing the first time.

03:21.760 --> 03:26.160
What I will do now is go to a Linux computer.

03:26.160 --> 03:29.200
By the way, what I'm working on is not Linux.

03:29.200 --> 03:31.880
This is a Macintosh.

03:31.880 --> 03:36.320
As you can see, it's a Macintosh computer.

03:36.320 --> 03:38.740
It says Darwin.

03:38.740 --> 03:41.960
And so I need to go to a Linux machine.

03:41.960 --> 03:46.600
I already have a Linux machine at my hand right below my feet.

03:46.600 --> 03:50.720
And that machine is a iMac that runs Ubuntu.

03:50.720 --> 03:56.560
I will connect to it simply by typing this, like that.

03:56.560 --> 04:02.040
That takes me to an Ubuntu machine that is available.

04:02.040 --> 04:09.640
It has Docker already installed and lots of containers running already.

04:09.640 --> 04:16.120
What I want to do is get this ready-made container image already available.

04:16.120 --> 04:25.620
I want to pull it and bring it down to my Ubuntu machine so it's coming down.

04:25.620 --> 04:27.180
And then I have it locally.

04:27.180 --> 04:30.640
So that's the easiest cheating method.

04:30.640 --> 04:31.640
I already got it.

04:31.640 --> 04:34.200
I can just run it simply.

04:34.200 --> 04:36.440
And you already saw me running it in the last session.

04:36.440 --> 04:42.400
So that's how you can run it if you like a WordPress image running your own inside your

04:42.400 --> 04:43.920
Docker containers.

04:43.920 --> 04:45.520
But this is the cheating method.

04:45.520 --> 04:50.620
The easiest method is to use the ready-made images like this.

04:50.620 --> 04:52.840
But that's not what you're talking about.

04:52.840 --> 04:55.640
What we're talking about is to understand how they build these images.

04:55.640 --> 04:58.760
And so we can build our own.

04:58.760 --> 05:03.920
And so building our own images basically is a good idea to look at how people build images.

05:03.920 --> 05:07.580
These are smart people that make the software called WordPress.

05:07.580 --> 05:13.280
And they have built various image versions.

05:13.280 --> 05:21.800
And let's go find out the latest version that they have and look at what they built.

05:21.800 --> 05:29.960
So here is the latest Docker image that I just downloaded like that.

05:29.960 --> 05:35.880
And let us go see how they build this particular WordPress Docker latest image by looking at

05:35.880 --> 05:37.800
what is called a Docker file.

05:37.800 --> 05:40.960
So we'll go and examine what did they do to build that image.

05:40.960 --> 05:46.440
And the way to do that is to go to the source code for how they build this Docker image

05:46.440 --> 05:49.880
for this application, WordPress.

05:49.880 --> 05:55.540
So what I will do is go to GitHub, which is the place to usually find source code.

05:55.540 --> 06:03.200
And there I will look for WordPress Docker image GitHub.

06:03.200 --> 06:09.440
That should take us to the Docker library WordPress, where the code is to work for how

06:09.440 --> 06:14.080
WordPress people create this Docker image.

06:14.080 --> 06:17.020
Which one?

06:17.020 --> 06:18.560
This one.

06:18.560 --> 06:21.440
That's place called this place is called Docker Hub.

06:21.440 --> 06:26.560
That's where WordPress people are storing Docker images.

06:26.560 --> 06:30.200
And this is how they build it.

06:30.200 --> 06:32.120
This is the source code.

06:32.120 --> 06:36.800
So we're going to examine the source code and understand how they build it and then

06:36.800 --> 06:42.200
modify it to begin with slight small simple modifications we can make so that we can understand

06:42.200 --> 06:44.400
how this image is being built.

06:44.400 --> 06:48.880
And then as we go deeper, we can build everything from scratch our own.

06:48.880 --> 06:56.000
And let's first understand how did these guys build the Docker image on the left side using

06:56.000 --> 06:59.320
the source code on the right side.

06:59.320 --> 07:01.960
That's what I want to understand.

07:01.960 --> 07:23.960
So it is a file called latest that uses a Docker file here.

07:23.960 --> 07:27.360
That's the file, by the way, that they use to create the image on the left.

07:27.360 --> 07:30.520
So this is a fairly detailed file.

07:30.520 --> 07:34.840
So I don't want to scare you by going into straight into the details, but I want to simplify

07:34.840 --> 07:37.240
the understanding of how they built it.

07:37.240 --> 07:41.600
And then we'll begin small to construct our own images and then reach up to this level

07:41.600 --> 07:45.080
of understanding level of complexity needed to make this happen.

07:45.080 --> 07:50.320
I'm not scaring you by showing you a giant Docker file like this.

07:50.320 --> 07:53.720
It can be daunting to read and understand, so I'll simplify it.

07:53.720 --> 07:57.760
Make very small simple images to begin us begin, you know, take us the journey towards

07:57.760 --> 08:07.480
building complex setups to create our own Docker images that you can put on Docker hub.

08:07.480 --> 08:19.120
But you need to have a Docker file that you basically build to create this.

08:19.120 --> 08:23.240
So this is an image.

08:23.240 --> 08:26.200
And this is a source code for that image.

08:26.200 --> 08:31.080
Here are the instructions, step by step.

08:31.080 --> 08:39.860
It has a beginning point and subsequent steps like that.

08:39.860 --> 08:48.840
So I will now look at the beginning step for this particular Docker file.

08:48.840 --> 08:50.620
Where does it begin?

08:50.620 --> 08:53.400
It begins from something.

08:53.400 --> 08:55.400
What is that something?

08:55.400 --> 08:56.400

08:56.400 --> 08:59.120
Why PHP?

08:59.120 --> 09:07.560
Because this guy, the instructions for basic instructions require you to have PHP.

09:07.560 --> 09:11.280
In fact, that's a requirement for this application.

09:11.280 --> 09:13.640
It requires PHP.

09:13.640 --> 09:17.700
And requires MySQL database or some other database.

09:17.700 --> 09:25.760
And it requires some kind of, it's called, you know, an application server to render

09:25.760 --> 09:29.780
what you see on the website that you create using WordPress.

09:29.780 --> 09:34.040
So it's called Apache as an example, is one of the web servers that you can use.

09:34.040 --> 09:36.140
There are other servers you can also use like NGINX.

09:36.140 --> 09:40.300
So basically you need a couple of things for this to run.

09:40.300 --> 09:46.680
You need something like Apache, which is a web server.

09:46.680 --> 09:50.440
You also need PHP, the language.

09:50.440 --> 09:53.880
That's what these guys are using.

09:53.880 --> 09:58.920
And you need some database like MySQL is recommended.

09:58.920 --> 10:01.320
And these needs to run on some Linux machine.

10:01.320 --> 10:05.240
You can also run it on other places, by the way, but we'll be using Linux.

10:05.240 --> 10:09.640
So that's the requirement for this Docker, sorry, WordPress application.

10:09.640 --> 10:13.400
One, two, three.

10:13.400 --> 10:21.440
And these two things, the first one and two are taken care of right here.

10:21.440 --> 10:29.560
So they're beginning with something ready-made, PHP and Apache already included.

10:29.560 --> 10:39.520
And they add certain things like WordPress itself in here to create the image needed

10:39.520 --> 10:41.720
for WordPress to run successfully.

10:41.720 --> 10:46.160
And then they add another container running MySQL separately, like just like we did the

10:46.160 --> 10:48.240
last time.

10:48.240 --> 10:51.320
So let us go investigate what this thing is.

10:51.320 --> 10:56.080
It contains two things, PHP and Apache.

10:56.080 --> 10:59.320
So let's go see what that image is.

10:59.320 --> 11:06.000
It is actually a separate image created by somebody else, not WordPress, not these guys.

11:06.000 --> 11:07.160
Somebody else created it.

11:07.160 --> 11:08.160
Who creates it?

11:08.160 --> 11:09.160
Let's go find out.

11:09.160 --> 11:11.800
Let's go find out who created this image.

11:11.800 --> 11:19.840
So we'll take that name, copy it, search it in Docker Hub, like that.

11:19.840 --> 11:25.520
We'll take this name, go to Docker Hub and search who created this.

11:25.520 --> 11:28.160
Oh, sorry, I copy pasted incorrectly.

11:28.160 --> 11:39.280
So who creates the PHP Apache image?

11:39.280 --> 11:40.280
Let's go.

11:40.280 --> 11:44.720
If it tells us the result, probably it doesn't give us a direct answer.

11:44.720 --> 11:50.840
So we're going to break it into parts and look for the PHP Docker image.

11:50.840 --> 11:59.660
And here is the PHP Docker image, which has a tag, which you will find 8.2 Apache.

11:59.660 --> 12:01.840
That should be there, like right there.

12:01.840 --> 12:02.840
That's a tag.

12:02.840 --> 12:06.960
So that's what we are interested in, because that's what the WordPress guys use to begin

12:06.960 --> 12:09.840
their WordPress image creation.

12:09.840 --> 12:13.640
So this happens to be a completely different image that gives you two things already to

12:13.640 --> 12:15.880
begin with.

12:15.880 --> 12:20.360
So you can see the layers and layers and layers of how we are going to go deep all the way

12:20.360 --> 12:29.200
to ground zero, which is nothing, which is also known as scratch, empty space.

12:29.200 --> 12:32.720
We'll reach there soon.

12:32.720 --> 12:37.360
So we began with understanding what WordPress uses to create the WordPress image by looking

12:37.360 --> 12:39.320
at the WordPress Docker file.

12:39.320 --> 12:42.600
And we found out that it begins with this.

12:42.600 --> 12:50.760
If you look at this particular Docker image, we'll have to go and hunt down its Docker file.

12:50.760 --> 12:53.800
And you will see that it contains these two things, PHP and Apache.

12:53.800 --> 12:55.960
So let's go hunt.

12:55.960 --> 12:59.280
Where is the Docker file for this?

12:59.280 --> 13:08.560
And we'll go hunt simply by clicking the link somewhere here to find it.

13:08.560 --> 13:14.760
And so we can just hit on maybe this, not this.

13:14.760 --> 13:21.960
So if you don't find it, just take that code or take that string and look for Docker file

13:21.960 --> 13:26.060
for PHP and that code number 8.2.

13:26.060 --> 13:30.440
And there you will have and also put GitHub.

13:30.440 --> 13:37.840
So you'll find a Docker file reference to that particular PHP image.

13:37.840 --> 13:39.720
There it is, by the way.

13:39.720 --> 13:42.600
So what are you looking at now?

13:42.600 --> 13:48.320
On the left side is the image that we are interested in, which is PHP 8.2.

13:48.320 --> 13:57.480
And on this right side, 8.2 Buster Apache Docker file.

13:57.480 --> 14:05.620
That's the Docker file that was used to create the image on the left side here.

14:05.620 --> 14:09.980
It contains PHP version 8.2 and also includes Apache.

14:09.980 --> 14:16.360
And that's the Docker file that creates this image that WordPress Docker file uses.

14:16.360 --> 14:19.760
It begins with this beginning point.

14:19.760 --> 14:28.340
But this beginning point itself has another beginning point, which is right there.

14:28.340 --> 14:35.880
This image uses another image called Buster Slim, Debian OS.

14:35.880 --> 14:37.960
Debian is a Linux OS.

14:37.960 --> 14:45.460
It uses another image to construct this image.

14:45.460 --> 14:50.200
So we'll go deeper and understand where this thing comes from.

14:50.200 --> 14:52.560
This thing comes from Debian Buster.

14:52.560 --> 14:58.100
So let's go hunt and find out where does Debian Buster comes from.

14:58.100 --> 15:10.580
So we'll go copy this and look at Docker Hub, and then search for Debian Buster Slim.

15:10.580 --> 15:15.240
And you don't find it like that, so just look for Debian alone.

15:15.240 --> 15:17.720
And then you find it.

15:17.720 --> 15:24.600
And then look for the tag reference and search for it, like Buster Slim, and you will find

15:24.600 --> 15:25.600
it there.

15:25.600 --> 15:28.060
So that's the image.

15:28.060 --> 15:32.280
That PHP Apache Docker file uses.

15:32.280 --> 15:34.360
But where is the source code for this?

15:34.360 --> 15:38.200
We go to another hunting on GitHub.

15:38.200 --> 15:39.520
And then I will summarize this whole thing.

15:39.520 --> 15:44.920
We are going down the deep, all the way to the rabbit hole, all the way to ground zero.

15:44.920 --> 15:47.900
That's where we are reaching slowly, step by step.

15:47.900 --> 15:56.040
So we'll go GitHub and look for Debian Buster Docker file.

15:56.040 --> 16:00.720
And here it is, the source code for that.

16:00.720 --> 16:08.200
Library Debian, hold on, let me go full screen.

16:08.200 --> 16:13.840
This is not the Docker file, but we're going to go and look for that particular Docker

16:13.840 --> 16:22.000
file in Debian, which is not readily visible here.

16:22.000 --> 16:30.760
Docker file is in a different location apparently here.

16:30.760 --> 16:36.320
So they give you a link here, somebody else is maintaining it apparently.

16:36.320 --> 16:40.000
So that's the Docker file somewhere, it's just a Docker generator.

16:40.000 --> 16:41.800
So stack-brewed library generator.

16:41.800 --> 16:46.320
So you will see that this is a generator to generator Docker file.

16:46.320 --> 16:52.960
So there's lots of variations here to basically lead to a situation which creates a Docker

16:52.960 --> 16:56.480
file to build a Debian Buster.

16:56.480 --> 17:05.200
And to create a Debian Buster Docker file, we have to begin from literally, let's see

17:05.200 --> 17:10.840
if we can find a separate simple example of how they build Debian images.

17:10.840 --> 17:20.920
Debian Docker file and then scratch.

17:20.920 --> 17:24.120
I'm going to select an alternative example.

17:24.120 --> 17:36.560
How do you create a simple Docker file that contains basically nothing to begin with?

17:36.560 --> 17:41.760
And so that's what I'm trying to hunt.

17:41.760 --> 17:47.040
Not in this page, scratch, and I think this is the beginning point.

17:47.040 --> 17:52.460
This scratch basically contains nothing, Docker pulls scratch.

17:52.460 --> 17:54.560
It has literally nothing.

17:54.560 --> 18:01.120
And then you add the Debian OS artifacts, which is the operating system itself.

18:01.120 --> 18:05.720
So now I will draw a picture and help you understand the whole game.

18:05.720 --> 18:09.840
For that, I need to bring up a sheet of paper.

18:09.840 --> 18:13.040
And here it is.

18:13.040 --> 18:20.040
In this sheet of paper, I will draw a picture of how we begin creating step by step the

18:20.040 --> 18:21.720
things that we need.

18:21.720 --> 18:28.120
At the foundation, we will have nothing also known as scratch.

18:28.120 --> 18:34.840
This is the scratch thing that I mentioned.

18:34.840 --> 18:36.320
That basically means a beginning point.

18:36.320 --> 18:38.000
It has nothing in it.

18:38.000 --> 18:42.120
Then on top, you add the Debian OS.

18:42.120 --> 18:43.720
In our example, we are using Debian.

18:43.720 --> 18:48.160
You can use any OS, the Debian OS artifacts.

18:48.160 --> 18:52.320
By the way, these things are already done for you.

18:52.320 --> 18:55.360
Most of the time, you will not be beginning from here and here.

18:55.360 --> 18:57.920
You will begin at a higher level.

18:57.920 --> 19:01.120
It's easier as we begin working.

19:01.120 --> 19:05.800
I'm showing you the ground-up, bottom-up approach of how people build these things so that you

19:05.800 --> 19:07.120
will understand.

19:07.120 --> 19:09.160
You don't need to start here at all.

19:09.160 --> 19:12.960
This is not your starting point right now.

19:12.960 --> 19:20.080
But the Debian OS artifacts, when these artifacts get added, then you get the Debian image.

19:20.080 --> 19:26.640
Debian image, which you can, you know, version of the operating system here can be Buster

19:26.640 --> 19:29.540
is a code name for Debian.

19:29.540 --> 19:35.800
So that Buster becomes a tag for that image, Debian Buster and the Slim variation.

19:35.800 --> 19:42.440
The smaller, simple variation of Debian Buster Slim is the operating system image that is

19:42.440 --> 19:49.540
added on to scratch, to nothing, to get us a Debian Docker image.

19:49.540 --> 19:57.340
That is used by PHP people, the people who write PHP code, the language, PHP.

19:57.340 --> 20:02.260
And they are using, what, 8.2 version of PHP.

20:02.260 --> 20:10.280
And then they also add Apache, the web server, on top of this ready-made image that you can

20:10.280 --> 20:12.680
just use.

20:12.680 --> 20:20.440
And this image is used by the WordPress people to create WordPress colon latest image.

20:20.440 --> 20:28.680
So if you now see, typically, if you want to go ready-made, you go use this.

20:28.680 --> 20:32.480
You want to customize a little bit, you go one step below.

20:32.480 --> 20:37.080
You want to modify PHP 8.2 and make it 8.1.

20:37.080 --> 20:42.360
You can do that by just changing the image, or you can modify by changing the operator

20:42.360 --> 20:48.160
underlying Docker file itself to get the right version of operating system, the right version

20:48.160 --> 20:53.240
of your PHP language, the right version of Apache, or whatever you need under the hood

20:53.240 --> 20:56.840
is how you begin creating whatever you need.

20:56.840 --> 21:01.120
So Docker file needs to be rewritten.

21:01.120 --> 21:03.560
So that was the example of WordPress.

21:03.560 --> 21:08.720
So this was multiple levels of abstraction beginning from scratch.

21:08.720 --> 21:14.280
Add the operating system, choose a specific version, add a language, choose the language

21:14.280 --> 21:21.080
version, add a web server, then create the application on top to create the WordPress

21:21.080 --> 21:22.080

21:22.080 --> 21:25.160
Lots of detail here involved.

21:25.160 --> 21:26.480
It's a complex application.

21:26.480 --> 21:35.240
I'll simplify it to the simple possible example I will now take, which is let's choose Nginx

21:35.240 --> 21:44.200
as an application, which is a web server.

21:44.200 --> 21:50.820
And we will add this on top of an operating system called Ubuntu, which is built on top

21:50.820 --> 21:55.760
of scratch, basically nothing.

21:55.760 --> 21:59.480
So empty slate, you add Ubuntu operating system.

21:59.480 --> 22:05.080
And then on top, we will add our application Nginx.

22:05.080 --> 22:10.100
And then we'll add something else on top to make it visible to us so we can see what we

22:10.100 --> 22:12.560
are doing and understand it and make use of.

22:12.560 --> 22:19.240
So this is a slightly simple example of what we will be doing actually in a hands-on exercise.

22:19.240 --> 22:25.480
So we'll begin here because I don't want to unnecessarily complicate things by helping

22:25.480 --> 22:29.040
you understand how do you begin from scratch and add the operating system.

22:29.040 --> 22:32.800
That's unnecessarily complicated to begin with as the first thing you do.

22:32.800 --> 22:34.400
So don't do that.

22:34.400 --> 22:40.240
Begin simpler by beginning from Ubuntu and then add Nginx.

22:40.240 --> 22:42.560
So let's go see how you do that.

22:42.560 --> 22:43.920
So we have to get Ubuntu first.

22:43.920 --> 22:45.820
Where do you get Ubuntu?

22:45.820 --> 22:53.600
You get it from Docker Hub, Ubuntu.

22:53.600 --> 22:56.000
There it is.

22:56.000 --> 23:04.480
So that is the place where you can pull Ubuntu image from somebody waiting apparently on

23:04.480 --> 23:05.480
the meeting.

23:05.480 --> 23:11.260
So we let them in and they are coming in.

23:11.260 --> 23:14.600
And so hello, hello.

23:14.600 --> 23:15.600
Somebody just joined.

23:15.600 --> 23:16.600
Hi, Suraj.

23:16.600 --> 23:17.600

23:17.600 --> 23:23.520
So we're talking about this thing called using the Ubuntu image as the foundation and add

23:23.520 --> 23:26.000
an application on top.

23:26.000 --> 23:30.400
So what I will now do is Docker pull Ubuntu.

23:30.400 --> 23:35.400
So it brings down the latest version of Ubuntu operating system container image available

23:35.400 --> 23:38.120
to me on my Linux machine.

23:38.120 --> 23:40.000
I now have it.

23:40.000 --> 23:43.840
It just pulled a Docker image.

23:43.840 --> 23:45.560
So now I have that image.

23:45.560 --> 23:51.400
What I want to be able to do now is to create a Docker file that uses that image.

23:51.400 --> 23:53.680
How do you create that?

23:53.680 --> 23:58.640
Simply you start a.

23:58.640 --> 24:03.760
A empty file and start typing in the beginning point.

24:03.760 --> 24:06.880
Beginning point happens to be in our case Ubuntu.

24:06.880 --> 24:11.140
So what I want to do is go to that Linux machine.

24:11.140 --> 24:16.440
So I will go to that Linux machine called iMac and hit that button.

24:16.440 --> 24:19.800
So I enter that machine remotely.

24:19.800 --> 24:25.720
And there I will create a separate folder for us to play with.

24:25.720 --> 24:28.680
And in there I will create a separate folder.

24:28.680 --> 24:29.680
Let's call it.

24:29.680 --> 24:31.320
What do you want to call today?

24:31.320 --> 24:34.840
So let's let's create a new folder.

24:34.840 --> 24:37.960
And we'll call it.

24:37.960 --> 24:40.760
Docker test.

24:40.760 --> 24:44.200
And in that folder will create a new file.

24:44.200 --> 24:47.320
I'll call it Docker file.

24:47.320 --> 24:48.560
And it's an empty file.

24:48.560 --> 24:51.640
I want to begin from Ubuntu.

24:51.640 --> 24:52.840
That's my beginning point.

24:52.840 --> 24:53.840
That's it.

24:53.840 --> 24:54.840
That's my Docker file.

24:54.840 --> 24:57.720
It's a complete Docker file, by the way, so close it.

24:57.720 --> 25:00.200
I can see it again and it's there.

25:00.200 --> 25:05.840
I can now go back here in the machine and say CD Docker test.

25:05.840 --> 25:08.440
And there I will find the Docker file that I created.

25:08.440 --> 25:10.440
I can see and inspect it.

25:10.440 --> 25:14.960
And I see that it has the content that I created.

25:14.960 --> 25:17.880
It says from Ubuntu.

25:17.880 --> 25:19.500
That's the beginning point.

25:19.500 --> 25:21.600
So now I have the Docker file created.

25:21.600 --> 25:26.120
It has one line, which is this line from Ubuntu.

25:26.120 --> 25:28.840
And I want to create a Docker image using that.

25:28.840 --> 25:30.440
How do you do that?

25:30.440 --> 25:33.280
The Docker build.

25:33.280 --> 25:37.280
And then put a dot.

25:37.280 --> 25:43.560
The dot basically means a reference to location where the Docker file exists.

25:43.560 --> 25:48.040
The Docker file exists in this location right here.

25:48.040 --> 25:53.320
And so I want to say Docker build whatever you have in this folder.

25:53.320 --> 25:55.720
The dot means right here.

25:55.720 --> 25:59.480
So it builds and it builds successfully.

25:59.480 --> 26:02.720
It was easy for it to build because there was nothing much to do.

26:02.720 --> 26:05.900
Just use an existing image called Ubuntu.

26:05.900 --> 26:06.900
So it builds.

26:06.900 --> 26:10.120
Now we have a new image created already.

26:10.120 --> 26:12.520
We can even run it if you like.

26:12.520 --> 26:18.060
But it is the same thing as running our own image as same thing as running Ubuntu image.

26:18.060 --> 26:23.680
So we have the images that we created right now like that.

26:23.680 --> 26:29.520
We can give it a name, a specific name I want to give, like this, dash T, and call it Docker

26:29.520 --> 26:30.520

26:30.520 --> 26:32.560
That's the name I want to give.

26:32.560 --> 26:40.360
But a proper way to name is not just the name, but a place to store the image eventually,

26:40.360 --> 26:45.560
like a library where you can push your images and store them, for example, Docker Hub.

26:45.560 --> 26:50.800
So Docker Hub has a name of, let's go see what names that these guys use.

26:50.800 --> 26:55.800
So every company that provides you a place to store images will have a name, a way to

26:55.800 --> 26:58.040
represent that name.

26:58.040 --> 27:03.560
And so these guys have a name called Docker pull Ubuntu, but the right way to say that

27:03.560 --> 27:07.960
is actually Docker dot IO library reference.

27:07.960 --> 27:14.080
I'm forgetting what the name reference is.

27:14.080 --> 27:21.520
So I'm going to search it container name reference, and that should show us the pull reference

27:21.520 --> 27:26.160
as to how you write the name of an image.

27:26.160 --> 27:36.400
So the way to write an example Docker image when you pull from Docker Hub is just the

27:36.400 --> 27:41.400
name library Debian or library Ubuntu.

27:41.400 --> 27:47.600
And when you pull from other locations, it is not clear as to which location are you

27:47.600 --> 27:49.400
coming from.

27:49.400 --> 27:54.600
So just like Docker Hub, there are other places to store container registry images, and those

27:54.600 --> 28:05.240
are Azure Container Registry, not this ACR, but Azure.

28:05.240 --> 28:08.540
So Azure Container Registry is right there.

28:08.540 --> 28:12.800
And so here you can also find certain images available.

28:12.800 --> 28:17.600
Similar to that, there is this Amazon Container Registry from Amazon Cloud.

28:17.600 --> 28:21.720
They provide you a place to store images just like Docker Hub does.

28:21.720 --> 28:25.160
Similar to that, there is Google Container Registry from Google.

28:25.160 --> 28:28.560
And they also provide a place to store images like this.

28:28.560 --> 28:34.440
So lots of people, lots of companies provide you a place to store images.

28:34.440 --> 28:40.920
And my company, I have my own place to store images, and that thing is simply this location.

28:40.920 --> 28:47.600
I do not show you anything because it is actually accessible through an API call.

28:47.600 --> 28:49.080
And you have to log in and so on.

28:49.080 --> 29:05.520
Let me see if I can log in.

29:05.520 --> 29:13.800
Yes, I logged in.

29:13.800 --> 29:20.440
And here are some images that I have stored in my own local registry.

29:20.440 --> 29:26.280
So I can push my image that I create into this registry that I hold in my company.

29:26.280 --> 29:33.520
That's just my own registry, very, very similar to these guys, or these guys, or these guys.

29:33.520 --> 29:36.040
It looks different, but functions the same way.

29:36.040 --> 29:40.720
This is mine, like hosted in my company.

29:40.720 --> 29:49.440
So an example of this thing called Photo Prism is an image that I have pushed to my registry.

29:49.440 --> 29:53.680
And the way I reference my registry is with the name that I have given it.

29:53.680 --> 30:04.120
And the name that I chose to give my registry is simply the URL that you go to.

30:04.120 --> 30:15.540
This is the name of my registry.

30:15.540 --> 30:35.120
And so the way I recommend naming my employees to use a Docker image name is like this.

30:35.120 --> 30:47.640
So for example, we can use something like

30:47.640 --> 30:51.400
And you can call it Ubuntu test, like that.

30:51.400 --> 30:57.320
So that's the proper way to name an image that you want to store in a registry location

30:57.320 --> 30:59.540
provided to you by some company.

30:59.540 --> 31:03.040
You can run your own registry, like I run myself.

31:03.040 --> 31:06.680
So this is a way, we'll talk about how to create your own registry later on, not right

31:06.680 --> 31:07.840

31:07.840 --> 31:10.960
But this is my registry, here is how you name it.

31:10.960 --> 31:17.080
So if you have a thing stored in Google Cloud, it is something like this, slash and

31:17.080 --> 31:23.520
some other names that Google will dictate, followed by Ubuntu test.

31:23.520 --> 31:26.640
That's how you will store it in Google Cloud.

31:26.640 --> 31:32.960
In Azure Cloud, it will be very similar, followed by some name that Azure will want you to use.

31:32.960 --> 31:41.840
And then your name of the image in Elastic Cloud from Amazon, it will be ECR.

31:41.840 --> 31:46.400
So various companies will have their own naming conventions, you need to follow their conventions.

31:46.400 --> 31:51.760
I will follow my company's conventions, which is line number four.

31:51.760 --> 31:56.400
If you don't follow any convention that is also legally acceptable, you can just go with

31:56.400 --> 31:58.040
line number one.

31:58.040 --> 32:00.680
I will choose line number three.

32:00.680 --> 32:07.360
I will choose that and actually go to my command line and give that name to my image and build

32:07.360 --> 32:10.300
that same image one more time.

32:10.300 --> 32:12.240
And here it goes, it builds.

32:12.240 --> 32:18.840
It also assigns it a name like that, what I chose.

32:18.840 --> 32:24.240
And what I can do now is push this image to my own registry, I created a new image, you

32:24.240 --> 32:30.260
can see it, it did create, let's go see Docker images and then look for the name and it shows

32:30.260 --> 32:36.400
up created and then I will now talk or push this image.

32:36.400 --> 32:44.520
So it goes to my registry in my home and it did and it succeeded.

32:44.520 --> 32:52.640
Let's go back to that website and here you don't see Ubuntu test yet, but when I refresh,

32:52.640 --> 32:55.000
you see it.

32:55.000 --> 32:59.240
So that is how I push images to a registry.

32:59.240 --> 33:06.720
Same exact method, you can push it to this cloud, this Google cloud or to this cloud,

33:06.720 --> 33:10.800
Amazon cloud or to this cloud, Azure cloud or to some other cloud, who knows what.

33:10.800 --> 33:14.640
It doesn't matter, anybody and everybody can bring in their own registry.

33:14.640 --> 33:18.640
So I bring my own homemade registry and I pushed it.

33:18.640 --> 33:21.880
Once I have it in my registry, I can pull it from there and push it to there and do

33:21.880 --> 33:22.880
whatever I want.

33:22.880 --> 33:23.880
But that's an image.

33:23.880 --> 33:24.880
I can consume it.

33:24.880 --> 33:26.660
I have assigned it a name.

33:26.660 --> 33:35.160
My name is line number three.

33:35.160 --> 33:39.160
I will ignore line number five, six, seven, eight, all that.

33:39.160 --> 33:42.880
And that number one is a simple name to the same thing.

33:42.880 --> 33:56.360
I build it using this instruction in line number two.

33:56.360 --> 34:12.800
You can also build the same thing without a name at all.

34:12.800 --> 34:13.800
Just like that.

34:13.800 --> 34:17.920
Or you can build it with a simple name like that.

34:17.920 --> 34:23.240
There is the same thing, except if you properly name it like line number one, you can push

34:23.240 --> 34:28.440
it and pull from by using these commands, dot or push.

34:28.440 --> 34:33.120
And then give it a reference name to the exact fully qualified name of the image.

34:33.120 --> 34:34.120
And it pushes.

34:34.120 --> 34:38.720
You want to pull, it pulls from that location that you have.

34:38.720 --> 34:43.280
And of course, it requires login name and password and some permission because I don't

34:43.280 --> 34:47.480
allow anybody and everybody to be able to push and pull from my home.

34:47.480 --> 34:51.840
It is my property and I don't allow other people to consume it.

34:51.840 --> 34:55.640
So line seven and eight requires permission from me.

34:55.640 --> 35:05.540
Similarly, these guys, they require permission from you, require permission from them.

35:05.540 --> 35:08.940
And same thing with this guy, Docker Hub.

35:08.940 --> 35:12.640
They also need you to log in and put some.

35:12.640 --> 35:15.680
I think most of it is free, but sometimes they charge you money.

35:15.680 --> 35:18.160
So we do sometimes need a credit card.

35:18.160 --> 35:20.600
Most of it is free, by the way, as you begin learning.

35:20.600 --> 35:23.000
So it's not a problem at all.

35:23.000 --> 35:26.900
However, we have created an image and we pushed it.

35:26.900 --> 35:30.400
Now let us see if you can run that image.

35:30.400 --> 35:31.840
How do you run an image?

35:31.840 --> 35:38.640
You simply go like this.

35:38.640 --> 35:44.160
Here and say.

35:44.160 --> 35:52.120
Docker run an image interactively and put in an image name like line number 13 is the

35:52.120 --> 35:54.880
name of my image.

35:54.880 --> 35:57.040
And then give me a badge prompt.

35:57.040 --> 36:01.400
So that's the command you want to be able to run to execute to run that container that

36:01.400 --> 36:03.920
you just created.

36:03.920 --> 36:07.160
So we use this Docker file.

36:07.160 --> 36:14.240
And command in line number one to build the image command in line number seven to push

36:14.240 --> 36:16.020
the image.

36:16.020 --> 36:20.880
And then command in line number 17 to run the image.

36:20.880 --> 36:22.880
Here's how it runs.

36:22.880 --> 36:25.480
Sorry, I didn't copy properly.

36:25.480 --> 36:27.840
Here's how it runs.

36:27.840 --> 36:30.860
It is running now.

36:30.860 --> 36:37.640
You can see that the version number of this particular Linux, the kernel version is 515,

36:37.640 --> 36:40.480
which is the same thing as the kernel I have.

36:40.480 --> 36:58.400
You can see that this version is also hold on.

36:58.400 --> 37:02.900
Let's put something in this container for us to make use of it in a in a slightly better

37:02.900 --> 37:03.900

37:03.900 --> 37:11.980
Let's go back to the notes here and what I have done up till now, sorry.

37:11.980 --> 37:18.120
In this context, what I have done up till now is that I was able to use the Ubuntu image

37:18.120 --> 37:23.240
and create my own Docker file to create my own image, which is basically identical to

37:23.240 --> 37:26.200
the Ubuntu image because I haven't even modified anything.

37:26.200 --> 37:36.440
The next thing I want to be able to do is add nginx to my basic foundation of Ubuntu

37:36.440 --> 37:42.160
for which I need to add a line to my Docker file and I will do that right now.

37:42.160 --> 37:52.280
So I will go back to my Docker file and here I will say add nginx in the way you add in

37:52.280 --> 38:09.400
a Ubuntu image is you need to first of all run apt update and then run apt install nginx.

38:09.400 --> 38:13.360
That's how you run it in a actual Ubuntu machine.

38:13.360 --> 38:17.800
So in a Docker file context, you add the run commands in line number two and three to make

38:17.800 --> 38:19.460
things happen.

38:19.460 --> 38:24.880
Now I have expanded my Docker file, added two layers to it to create nine line number

38:24.880 --> 38:29.520
two and line number three, and I will use this Docker file to build my own image one

38:29.520 --> 38:30.520
more time.

38:30.520 --> 38:33.040
How do I build my image?

38:33.040 --> 38:34.040
Line number one.

38:34.040 --> 38:44.160
So I take that and execute in my command line, exit out of my container, go back to check

38:44.160 --> 38:49.800
my Docker file and I see that it has now three lines as opposed to one, I added these two

38:49.800 --> 38:57.760
things to the Ubuntu basic foundation and then I build my image one more time.

38:57.760 --> 39:01.080
You will see this time the Docker building process is actually doing the two things,

39:01.080 --> 39:05.440
line number two and line number three again for us, like this is the line happening and

39:05.440 --> 39:06.720
then this is happening.

39:06.720 --> 39:11.240
You can see that the nginx installation is happening right now.

39:11.240 --> 39:15.980
When this finishes, you will have a new image created, which is our own customized image

39:15.980 --> 39:21.640
called reg home cloud genius went to test.

39:21.640 --> 39:26.360
That created a new image for us because that's what we wanted.

39:26.360 --> 39:32.260
We wanted a new custom Docker image containing nginx.

39:32.260 --> 39:35.100
So we now have it.

39:35.100 --> 39:39.360
How do we make sure that it actually does have what we wanted it to have?

39:39.360 --> 39:48.120
We can do that by running that image again this time, same way like before, Docker run

39:48.120 --> 39:50.480
and there we have that Ubuntu image running again.

39:50.480 --> 39:59.240
But this time if you see it has nginx running or not running yet, is it not running?

39:59.240 --> 40:14.720
Hold on, let's check it should be running.

40:14.720 --> 40:15.720
Now we have to run it.

40:15.720 --> 40:17.640
We have to actually, this is just installed.

40:17.640 --> 40:24.040
So there is nginx installed, we haven't run it yet, so we have to run it.

40:24.040 --> 40:28.840
The way to execute that I think is cmd and then you have to pass some argument like say

40:28.840 --> 40:30.680
run nginx please or something like that.

40:30.680 --> 40:35.720
We're going to do some command like line number five shows in our Docker file for the nginx

40:35.720 --> 40:38.280
binary to execute.

40:38.280 --> 40:42.960
And that's what I will have to investigate as to what do we write here exactly to get

40:42.960 --> 40:47.940
nginx to run after you install it in line number three.

40:47.940 --> 40:53.240
What is it that is needed for nginx to run at the runtime when you run this image?

40:53.240 --> 40:55.760
And for that we have to go reference the documentation.

40:55.760 --> 40:59.100
So that's the best way to learn is to read the documentation.

40:59.100 --> 41:04.560
So let's go find out how do you run something in a Docker image.

41:04.560 --> 41:13.000
You simply go Docker file run command.

41:13.000 --> 41:19.840
And you hunt for it and you will find the Docker reference to it.

41:19.840 --> 41:24.960
And here are some examples of run echo something.

41:24.960 --> 41:27.620
Run echo hello world example.

41:27.620 --> 41:42.680
So we'll go look for a specific example of run nginx.

41:42.680 --> 41:48.760
And you will see that people may have given you instructions on how do you do this so.

41:48.760 --> 41:54.720
You can we can copy paste or cheat cheating is totally fine and it's a it's a great idea

41:54.720 --> 41:58.680
to look at what other people are doing and then do what you want to be able to do.

41:58.680 --> 42:00.220
And so I support cheating.

42:00.220 --> 42:03.520
I actually support everything open.

42:03.520 --> 42:07.440
And you know the whole Internet available to you and you know chat GPT available to

42:07.440 --> 42:12.440
you and fully cheat to make it easy for you to get things done.

42:12.440 --> 42:28.280
And so here let's go see if they have a Docker file example or that that they're cheating

42:28.280 --> 42:30.520
even further and using a readymade nginx image.

42:30.520 --> 42:33.520
So not this.

42:33.520 --> 42:42.080
Yeah, these guys should have it.

42:42.080 --> 42:43.720
And there it is.

42:43.720 --> 42:52.240
So the command is this to run nginx at the runtime without a daemon so it doesn't have

42:52.240 --> 42:57.560
to run by itself but only run when you run it the run it in the Docker way.

42:57.560 --> 43:03.880
So this line number five that you see is actually going to invoke nginx at the runtime when

43:03.880 --> 43:06.840
you invoke that particular Docker image.

43:06.840 --> 43:11.000
Since we added this new command in line number four in the Docker file we need to build our

43:11.000 --> 43:16.040
container image one more time using line number one.

43:16.040 --> 43:21.760
So I'll copy that line number one again go back to my command line exit out of the existing

43:21.760 --> 43:30.120
container and run the build instruction one more time so it builds then we'll run it how

43:30.120 --> 43:37.220
do you run like line number 17 we'll copy that and run it here and it runs something

43:37.220 --> 43:44.200
let us go see what is running right now and you still don't see anything running in nginx

43:44.200 --> 43:50.560
because we are not invoking it let's go let's go run it in a different fashion.

43:50.560 --> 43:58.120
So I'm going to exit this and describe the different fashion of running this Docker run

43:58.120 --> 44:06.400
in a daemon mode the same image like before but not run it like interactively instead

44:06.400 --> 44:10.760
run it like a daemon in the background and then we'll go and examine as to what it is

44:10.760 --> 44:17.000
doing so let us see if this thing gets us the result we want so it started some container

44:17.000 --> 44:29.840
let us examine what is running by Docker ps-a and then looking for Ubuntu test and we see

44:29.840 --> 44:36.960
that something is actually running like right there 15 seconds ago up and running for last

44:36.960 --> 44:44.440
14 seconds something is running that is nice and so we will go and examine what is running

44:44.440 --> 44:51.760
by entering the container from outside for which we need to grab the image ID sorry it's

44:51.760 --> 45:00.240
a container at runtime ID this number 505 and execute into that and get a bash prompt

45:00.240 --> 45:05.120
and there you check the process is running and you will see nginx is running that's a

45:05.120 --> 45:11.320
good sign now let us see if you can actually open a website and a browser to see what is

45:11.320 --> 45:16.880
running in that container for that I would like you to understand what we did the last

45:16.880 --> 45:24.680
time clearly and so let's summarize what we have done up till now what we have done up

45:24.680 --> 45:35.280
till now is we have modified our Dockerfile to not only add nginx but also run nginx by

45:35.280 --> 45:42.080
typing in a cmd in the Dockerfile cmd run command we added on that thing and then we

45:42.080 --> 45:48.480
ran this we built this entire image and then we ran it it seems to run but I want to feel

45:48.480 --> 45:55.800
happy by seeing it visually in a browser that is possible but you need to work towards it

45:55.800 --> 46:05.920
what does it mean it means we have in a Docker container running nginx on port number 80

46:05.920 --> 46:15.160
inside the container on a machine which is the imac that I talk about but this port number

46:15.160 --> 46:21.320
80 is not visible to us outside so we need to do a port mapping if you refer to the previous

46:21.320 --> 46:26.360
meeting like the week ago I think I described this concept clearly but I will do it again

46:26.360 --> 46:35.600
simply I want to be able to map this port number 80 to the imac port of some number

46:35.600 --> 46:41.720
like I need to map this number 80 to some port here on the imac so that I can see what

46:41.720 --> 46:49.120
is going on here so on this machine we need to look up ports that are available in open

46:49.120 --> 46:58.020
so one of the ports that I have available in open is 8760 that I like to use there are

46:58.020 --> 47:02.760
other things you can use like 80 is also sometimes available in most cases you can use that port

47:02.760 --> 47:07.700
if you're like on a new machine or an empty new fresh new cloud you can use that but I

47:07.700 --> 47:12.960
have my machines already occupied the port is taken I cannot use this so I have to map

47:12.960 --> 47:19.440
a different port to this port inside the container so this port mapping thing I think I discussed

47:19.440 --> 47:25.480
in a previous session you should go look at that if you are missing that concept but the

47:25.480 --> 47:34.360
idea will be to use that concept of port mapping like we did the last time by expanding this

47:34.360 --> 47:42.360
line number 20 and making it a new line 22 out of it and including the port mapping like

47:42.360 --> 47:55.400
that map it to 80 that's all that's all it takes what does this do what it does is exactly

47:55.400 --> 48:04.280
what we wanted which is map port number 80 in the container to port number 8760 on the

48:04.280 --> 48:18.320
iMac rest of it is all the same I inserted this portion in the command sequence to let

48:18.320 --> 48:26.240
the port mapping succeed and when you see that and run it like line number 22 you should

48:26.240 --> 48:32.480
be able to see what that nginx container is showing you by visiting the iMac on port number

48:32.480 --> 48:39.920
8760 you can modify your ports the way you like if you want to have a discussion on what

48:39.920 --> 48:43.360
these ports are you should refer to the previous meeting because we discussed these things

48:43.360 --> 48:51.920
last time so let us go line number 22 and run that but before that we have to kill what

48:51.920 --> 49:00.440
we did in line number 20 and so that's what I will do now and I will open up my terminal

49:00.440 --> 49:08.880
and kill this docker container that is already running there and that is this number 505

49:08.880 --> 49:19.800
I will say docker rm-f and the number is 505 so it dies then I will also check any docker

49:19.800 --> 49:33.760
processes running in my machine with the name docker test and there is none nothing is there

49:33.760 --> 49:40.120
that is running right now so now our machine is clear for us to run this command in line

49:40.120 --> 49:49.440
number 22 which is what we just discussed so I will copy that 22 bring it here run it

49:49.440 --> 49:56.600
and it runs so now you can see that there is this docker container running oh so docker

49:56.600 --> 50:06.280
test is ubuntu test what am I talking about okay there it is now it is running again and

50:06.280 --> 50:14.320
that is what we just started so let us go examine what did we just start and why is

50:14.320 --> 50:19.360
it you know working the way it is so let's go first of all read and understand what did

50:19.360 --> 50:29.200
we start and how it shows in our result in docker ps-a and then grab for ubuntu test

50:29.200 --> 50:38.720
and there it is so let us go see what it shows us examine here is the image id sorry image

50:38.720 --> 50:44.680
container runtime reference here is the image name that we chose it is running the nginx

50:44.680 --> 50:52.160
in daemon off and it is up and running for last 39 seconds and it has this port mapping

50:52.160 --> 51:01.600
that I wanted on the imac map to the container port number 80 so that mapping seems to be

51:01.600 --> 51:09.120
successfully showing which means if you visit the imac on that port number 8760 you should

51:09.120 --> 51:15.800
see what the nginx container is showing you inside on port number 80 that is a port mapping

51:15.800 --> 51:30.000
so now let us go visit the imac on port number 8760 and we should be greeted by a nginx response

51:30.000 --> 51:39.040
so here is your imac and the port number 8760 and you see nginx now I can prove to you that

51:39.040 --> 51:50.920
I am not cheating by looking at that docker image and killing it

51:50.920 --> 52:02.480
so I killed it and I will examine that there is nothing running in my computer containing

52:02.480 --> 52:08.880
the name ubuntu test is empty it's all dead you can see that in this browser window if

52:08.880 --> 52:16.040
I refresh unable to connect I go back here to the command line and run that same line

52:16.040 --> 52:23.320
number 22 one more time this is your line number 22 for you like right here same line

52:23.320 --> 52:32.640
number 22 I run it in the command line like that then I go to the browser and refresh

52:32.640 --> 52:38.680
and it shows back up so that is how you build a docker image and run some application in

52:38.680 --> 52:45.660
the simplest fashion very simply let us summarize what do we do questions by the way are welcome

52:45.660 --> 52:50.800
anytime you have a question you should ask that if you don't ask questions it is bad

52:50.800 --> 52:55.720
really bad you know I don't know whether you understanding or not or whether I am talking

52:55.720 --> 53:00.360
to myself so that is something that I want to avoid so you should keep it interactive

53:00.360 --> 53:12.400
okay so now I will draw the picture again and see what we did so what do we do we began

53:12.400 --> 53:28.560
with we began with ubuntu and we chose that as a foundation from then we installed

53:28.560 --> 53:44.920
apt-get update to update the system cache for apt to be able to pull other applications

53:44.920 --> 53:57.500
then we get the application we want apt-get install nginx that actually installs nginx

53:57.500 --> 54:02.360
and this dash y means shut up and install don't ask me questions should I install yes

54:02.360 --> 54:12.000
or no don't do that shut up install that's the idea shut up and install the next thing

54:12.000 --> 54:24.120
we actually execute cmd nginx in some detail about how exactly you write it so that you

54:24.120 --> 54:30.160
look up the documentation or copy paste or cheat but this is how you do it how do you

54:30.160 --> 54:46.320
do it like that line number 4 cmd nginx dash g and then daemon off that basically means

54:46.320 --> 54:58.480
don't run nginx in daemon run it in foreground but invoke once you start this container so

54:58.480 --> 55:04.720
that's the idea so you install this is bring the update update the app cache install nginx

55:04.720 --> 55:11.200
application and run the actual application when the container runs and you begin from

55:11.200 --> 55:17.440
a one two that's how you build docker images of course you can keep on adding complexity

55:17.440 --> 55:21.760
and you guys you have seen like as we started you have seen bigger docker files you will

55:21.760 --> 55:25.900
get there you will get there but you have to understand basics first before you jump

55:25.900 --> 55:37.840
into a complex example so that's the underlying idea questions are welcome go ahead the cmd

55:37.840 --> 55:44.840
portion yes i will do that so you know if you remember how did i find this out i did

55:44.840 --> 55:53.120
not remember what did i do i cheated how did i cheat i google searched let's go where where

55:53.120 --> 56:00.880
did i go i went to the nginx official company's documentation and found out how they are running

56:00.880 --> 56:10.800
it how they are building their docker files for nginx so if you see here on this nginx

56:10.800 --> 56:19.440
company website there is this reference which i copied from right so now let us go see what

56:19.440 --> 56:29.880
they are doing on this page it basically describing to you how to run nginx plus which is a different

56:29.880 --> 56:36.400
application not exactly nginx nginx plus is an enhanced version of nginx commercial version

56:36.400 --> 56:41.160
from the nginx company we are not interested in the nginx plus piece we are interested

56:41.160 --> 56:47.960
only nginx and these guys describe to you how to invoke it so i cheated and what did

56:47.960 --> 56:53.480
i do i looked at their command to execute it it's basically the same command you would

56:53.480 --> 56:59.920
otherwise run if you're running plain nginx and not nginx plus so now let us dissect what

56:59.920 --> 57:11.760
this command actually does nginx you can run it without these guys it will also work however

57:11.760 --> 57:22.600
it goes in demon mode and it keeps on running we don't want that so we disable demon mode

57:22.600 --> 57:32.480
that's the idea nothing else and you if you if you eliminate this and just keep the closing

57:32.480 --> 57:45.080
bracket that is also okay so simply the cmd idea is to invoke or execute this thing at

57:45.080 --> 57:52.480
run time when you run this image not when you build it but when you run it so that's

57:52.480 --> 58:02.360
the difference in between this thing when you have the run steps these are build time

58:02.360 --> 58:11.640
build time executions when you have the cmd step it does nothing at build time except

58:11.640 --> 58:19.560
making a node that when you run it that's what needs to happen so build time you will

58:19.560 --> 58:25.240
actually install this and install that and do this and do that but number four is simply

58:25.240 --> 58:36.640
a way for the image to know what to do when you run it at the run time not at the build

58:36.640 --> 58:42.400
time so when you build the image this basically does nothing except make a note that when

58:42.400 --> 58:55.280
you run this image run engine x in demon off that's it there's nothing more to it does

58:55.280 --> 59:20.040
that clarify but yeah go ahead thank you thank you thank you okay so now let us expand

59:20.040 --> 59:27.320
it a little bit further like slightly improved version of the same thing you know but what

59:27.320 --> 59:40.140
you saw here is what you see in this page when I run that thing you see nginx right

59:40.140 --> 59:53.120
what I want to see here is not what nginx gives me by default but I want to see priti's

59:53.120 --> 01:00:06.200
name showing up how do you do that not what nginx gives me but priti so you have to tell

01:00:06.200 --> 01:00:12.000
your docker image to you know modify something somewhere so that when you open that browser

01:00:12.000 --> 01:00:16.200
it should say hello priti or welcome priti or something like that right that's what

01:00:16.200 --> 01:00:28.600
I want to see so we need to create something we need to go back to our docker file and

01:00:28.600 --> 01:00:38.720
in the docker file you to modify things like what like here somewhere you say you to add

01:00:38.720 --> 01:00:55.200
a file that replaces the default and which file not any file but add a file containing

01:00:55.200 --> 01:01:05.000
the name priti so you add a priti file that replaces the default file that's what we have

01:01:05.000 --> 01:01:13.760
to do so this priti file doesn't exist so you have to create it so we create that like

01:01:13.760 --> 01:01:28.600
this there we go that's a file and I will put that in my computer in that same folder

01:01:28.600 --> 01:01:36.520
by this name index html so that's the file that I created now I have that file so I need

01:01:36.520 --> 01:01:44.680
to add that file priti file it's called index html into a location to replace the default

01:01:44.680 --> 01:01:54.720
right that's what I want to be able to do so how do I do it that's the next thing so

01:01:54.720 --> 01:02:01.520
we have to somehow get this file inside in that location where the default is and delete

01:02:01.520 --> 01:02:09.800
the override delete the old file that exists inside and put this new index html right on

01:02:09.800 --> 01:02:16.720
top of that location you can do it multiple different ways the simplest way is to not

01:02:16.720 --> 01:02:22.360
modify a docker file but pass a file reference from the outside so if you have attended the

01:02:22.360 --> 01:02:28.840
previous sessions you probably know how to map a file if you don't remember I can show

01:02:28.840 --> 01:02:34.160
you both both examples but I will go and give you the cheating example first like how do

01:02:34.160 --> 01:02:43.000
you cheat if you don't know what to do so what do you do you go back to a browser window

01:02:43.000 --> 01:02:51.200
and in there you open up firefox and say add a file to docker file so somewhere there'd

01:02:51.200 --> 01:02:57.480
be how do you add a file to an image so there it is injecting files into your image using

01:02:57.480 --> 01:03:04.120
add so there is an instruction we'll cheat and see what the what the image says so here

01:03:04.120 --> 01:03:16.280
is the usage example we'll just copy it and bring it to our docker file like that here

01:03:16.280 --> 01:03:30.120
if we don't have we have index.html and we don't have a location where this file

01:03:30.120 --> 01:03:41.720
needs to go so where would it go I don't know so what do you do you cheat again and you

01:03:41.720 --> 01:03:56.360
go and ask where does the nginx image store the default index and the answer is here somewhere

01:03:56.360 --> 01:04:00.200
and so you will read this documentation and you will find out that the location happens

01:04:00.200 --> 01:04:10.960
to be this and I just remember it so I just wrote it but you don't have to memorize anything

01:04:10.960 --> 01:04:16.080
you can always cheat you have google you have the entire internet available to you and you

01:04:16.080 --> 01:04:20.760
these days you have ai tools available to you so use all of them to hunt down the thing

01:04:20.760 --> 01:04:28.280
you need don't memorize anything ever I happen to remember it so that's the location where

01:04:28.280 --> 01:04:35.720
it needs to go so I'll put this index.html file this file hello Preeti into that location

01:04:35.720 --> 01:04:45.280
where it's supposed to be overriding the old location which shows us what we see when you

01:04:45.280 --> 01:05:03.760
go here so now we'll go and build our docker image one more time line number 22 once again

01:05:03.760 --> 01:05:09.360
and so before we go I want to kill the existing container images that I have from a previous

01:05:09.360 --> 01:05:33.720
attempt so I look it up we want to test and I find it I am going to kill it

01:05:33.720 --> 01:05:40.160
and I killed it so now I have nothing running by that name open to test then I will go to

01:05:40.160 --> 01:05:47.320
this line number 22 again and run it so now we have something running again and I will

01:05:47.320 --> 01:05:59.440
go back to this browser and refresh and what do you see you still see the old nginx image

01:05:59.440 --> 01:06:10.080
the old nginx index html why is that why is it that is still showing you old one any ideas

01:06:10.080 --> 01:06:17.480
do you know why because browsers cache everything that they saw so we have to open a different

01:06:17.480 --> 01:06:23.040
browser to see what's going on there there's the there's the reason I think it's it's probably

01:06:23.040 --> 01:06:27.160
caching or maybe there's some other reason so it's not caching it's something else happening

01:06:27.160 --> 01:06:32.720
so let's go investigate if we actually correctly place the file in the right location which

01:06:32.720 --> 01:06:40.800
means we have to go inside this image and actually examine if the location is correct

01:06:40.800 --> 01:06:47.200
that I mentioned that I assumed going by my memory line number four is that actually correct

01:06:47.200 --> 01:06:52.760
user share nginx html is that the correct location that's what I want to examine so

01:06:52.760 --> 01:07:01.960
I'll go inside the image and examine it by running an execute command dr exec and then

01:07:01.960 --> 01:07:08.400
the number 7c1 which you see here in the image id that is the container id that's running

01:07:08.400 --> 01:07:17.240
right now and then getting a bash prompt then we will go and examine the user share nginx

01:07:17.240 --> 01:07:23.240
html folder and there you have this index html and we have to examine what it contains

01:07:23.240 --> 01:07:32.140
and it still has the old file it did not overwrite why did it not overwrite I don't know it should

01:07:32.140 --> 01:07:37.480
have overwritten that but it didn't so we have to go and investigate what went wrong

01:07:37.480 --> 01:07:48.520
something went wrong somewhere so we'll go back to our code and find out why did this

01:07:48.520 --> 01:07:55.320
line number four did not get executed did I forget to build an image probably probably

01:07:55.320 --> 01:08:02.280
I forgot to build the image I don't know so I will go in first of all look at my runtime

01:08:02.280 --> 01:08:12.080
images containing the name ubuntu test and then I will delete that image so now I have

01:08:12.080 --> 01:08:18.680
nothing then I will build the docker image one more time but before I build it I want

01:08:18.680 --> 01:08:29.800
to kill my existing image so docker images that I have and then I will like to remove

01:08:29.800 --> 01:08:34.800
the image that I created at the last time so rmi-f and then the image name what's my

01:08:34.800 --> 01:08:44.240
image name here so I will remove that image by saying docker rmi and then line number

01:08:44.240 --> 01:08:54.000
24 should delete the image completely from my computer like that and it deleted and then

01:08:54.000 --> 01:09:09.760
I will want to build the image one more time like line number 22 and it built so I will

01:09:09.760 --> 01:09:16.880
like to now run it and how do I run it no I did not build it see I am not building I

01:09:16.880 --> 01:09:23.680
am running it I am not building stupid me line number one is how you build it not 22

01:09:23.680 --> 01:09:29.040
number one is how you build it now I built it I think I forgot to build the image I

01:09:29.040 --> 01:09:38.360
just ran line number 22 without actually building it so now I run it and it is running let us

01:09:38.360 --> 01:09:44.680
go inside the image by the way these commands that I type without describing to you you

01:09:44.680 --> 01:09:50.120
should go look at docker documentation and find out how am I dealing with these things

01:09:50.120 --> 01:09:56.600
you should go study it on your own I will like to go inside that container and get a

01:09:56.600 --> 01:10:04.320
bash prompt then get into the user share nginx location go to html location find out the

01:10:04.320 --> 01:10:10.640
file called index html and cat it and we should see hello prithi there there it is nice so

01:10:10.640 --> 01:10:21.960
now I go to the browser and refresh and it is still showing me that is fun is not it

01:10:21.960 --> 01:10:30.800
so let us go check one more time still showing me same old setup even though we do not have

01:10:30.800 --> 01:10:40.280
that file there and we see hello prithi inside which is crazy so it is okay it happens all

01:10:40.280 --> 01:10:44.800
the time you know so we have to go understand why it is happening that is more important

01:10:44.800 --> 01:10:54.520
than you know this file contains the right file now let us see if we have the correct

01:10:54.520 --> 01:11:10.800
process is running yes then we go and examine it in curl to see if we can get to the local

01:11:10.800 --> 01:11:19.480
host 8760 and we have some response then we get the curl browser and we still get the

01:11:19.480 --> 01:11:30.920
old welcome to nginx page the old page we do not know why so this method did not work

01:11:30.920 --> 01:11:37.520
we do not know why it did not work let us go another method of running the same thing

01:11:37.520 --> 01:11:41.560
maybe it is picking up from some other location maybe this location itself is not where it

01:11:41.560 --> 01:11:47.640
picks from some other location where it picks from so you can go investigate that or let

01:11:47.640 --> 01:11:57.080
us go find out where it is actually picking up so docker ps dash a by grep open to test

01:11:57.080 --> 01:12:05.360
and that image that we have running here will go inside the image docker exec and then identify

01:12:05.360 --> 01:12:11.560
where does nginx actually is storing that image that it expects to pop from like where

01:12:11.560 --> 01:12:16.960
does it showing it from that is the question so we have to go and look at the configuration

01:12:16.960 --> 01:12:23.880
of how nginx is actually looking up that file and that is what i want to hunt down as to

01:12:23.880 --> 01:12:28.640
why is it not picking up the file from that location which we wanted it to because what

01:12:28.640 --> 01:12:34.480
i am doing is i am asking it to look at line number four user share nginx html but it seems

01:12:34.480 --> 01:12:40.280
like it is picking up from some other location not the location we have in line number four

01:12:40.280 --> 01:12:46.200
so where is that location that is what i want to find out which means i need to go do some

01:12:46.200 --> 01:13:11.280
investigation so this requires understanding of how nginx actually runs and apparently

01:13:11.280 --> 01:13:20.560
it is pulling up from var www html as opposed to user share html so line number four was

01:13:20.560 --> 01:13:30.320
wrong sorry line number four was wrong it is seems to be pulling from var www html according

01:13:30.320 --> 01:13:37.280
to the configuration that i am looking at inside the container for nginx right there

01:13:37.280 --> 01:13:48.880
that is where it is picking up from not line four that means line number four was wrong

01:13:48.880 --> 01:13:56.200
my memory was incorrect this is the right location according to what i see in the configuration

01:13:56.200 --> 01:14:04.680
that means this was wrong line number five is correct okay fine found out this is what

01:14:04.680 --> 01:14:09.120
happens in real life when you go by memory and you try something and it does not work

01:14:09.120 --> 01:14:13.560
and then you crashed your head against hard objects to struggle to figure out what is

01:14:13.560 --> 01:14:19.600
going on then you study then you find out that your line number four was wrong then

01:14:19.600 --> 01:14:28.000
you change it and then let us try it again and so we quit the docker container we go

01:14:28.000 --> 01:14:46.460
look at the docker container runtime and we kill that docker container

01:14:46.460 --> 01:14:53.800
we also do a docker image delete so we have to kill the docker image that we created like

01:14:53.800 --> 01:15:05.160
line number 24 then we build the docker image like that line number one and then we run

01:15:05.160 --> 01:15:17.360
it line number 22 and now something is running and let us go quickly check what is running

01:15:17.360 --> 01:15:24.120
and we see hello welcome prithi and then we go to the browser and we see that it shows

01:15:24.120 --> 01:15:36.640
what we expect to see right here so that's how it was so yes struggle happens it needs

01:15:36.640 --> 01:15:42.280
to happen otherwise you will never learn even i don't learn unless i struggle so that's

01:15:42.280 --> 01:15:50.760
the way of life you make mistakes like i did line number four it's okay mistakes are okay

01:15:50.760 --> 01:15:57.120
i mean learn to accept mistakes it happens and it needs to happen otherwise you will

01:15:57.120 --> 01:16:05.160
never learn things change by the way i'm not i'm not mistaken when i said this is what

01:16:05.160 --> 01:16:13.400
i memorize and i remember from my memory and i used it but things changed somewhere and

01:16:13.400 --> 01:16:18.120
they seem to be using this location as opposed to this location so this is the right one

01:16:18.120 --> 01:16:25.880
not that and that is totally fine and things keep changing all the time that's how real

01:16:25.880 --> 01:16:31.720
life is so what you just saw is a real life example it used to be line number four but

01:16:31.720 --> 01:16:38.840
now it is line number five fine you struggle you find out and you fix it so that's how

01:16:38.840 --> 01:16:45.200
you build docker images for your situation containing your files that you create that

01:16:45.200 --> 01:17:03.960
you add and then you run when you build an image so does that help you clarify as to

01:17:03.960 --> 01:17:10.960
what we did and is that you know do you have a question associated with any of these ideas

01:17:10.960 --> 01:17:19.880
that we just handled any any questions on this concept how to build a docker image how

01:17:19.880 --> 01:17:25.480
to push it to a registry i push it to my own registry but you can push it to wherever you

01:17:25.480 --> 01:17:36.600
like like the way i push is in line number seven to my own registry so i can go and push

01:17:36.600 --> 01:17:44.600
it like that and it goes

01:17:44.600 --> 01:17:49.280
and i can see it in a browser window and this is only available to me it's not even outside

01:17:49.280 --> 01:17:58.480
my home that's where you see it it's very rudimentary the user interface is very raw

01:17:58.480 --> 01:18:04.140
i don't care as long as it works i don't have to be fancy looking like this or any any other

01:18:04.140 --> 01:18:08.400
big sites like this i don't have to be fancy looking it needs to work the right way and

01:18:08.400 --> 01:18:18.200
it does so what i do is actually run another docker image to create that thing that is

01:18:18.200 --> 01:18:29.240
called a registry using a image called registry and here it is this image called docker registry

01:18:29.240 --> 01:18:35.960
is just a name of a docker file called registry which creates a docker registry like like

01:18:35.960 --> 01:18:44.240
this that's it it's another docker container that holds images for me it's not complicated

01:18:44.240 --> 01:18:54.600
it's dead simple you just run the registry image on docker hub which means you run it

01:18:54.600 --> 01:19:07.040
like this start your registry pull some image push tag some image push something basic commands

01:19:07.040 --> 01:19:10.240
that's how you begin of course you need to have a computer to run these things and all

01:19:10.240 --> 01:19:17.560
that if you don't have it in your home or your office you use the cloud so that i think

01:19:17.560 --> 01:19:22.760
should cover the topic that we just discussed today what i want to be able to do the next

01:19:22.760 --> 01:19:31.600
time is when we when we run this exact image that we just ran in our own machine locally

01:19:31.600 --> 01:19:35.920
i want to run it in the cloud and that's what we will do next time unless you have a different

01:19:35.920 --> 01:19:42.780
idea you want me to cover and i will tweet about it and we'll run the next step the next

01:19:42.780 --> 01:19:49.840
exercise continuation of what we did today next time same day same time next week and

01:19:49.840 --> 01:19:54.600
i will tweet the details and push the same detail on our website which is this website

01:19:54.600 --> 01:20:02.280
and here you will find the instructions on how to join and you need to put your email

01:20:02.280 --> 01:20:09.640
address here and the tweet will show you the next agenda for the next in the next session

01:20:09.640 --> 01:20:17.120
the next week exactly the same time so that's the idea for for today any questions before

01:20:17.120 --> 01:20:27.520
we disconnect

01:20:27.520 --> 01:20:33.280
and if you don't have any questions that's okay

01:20:33.280 --> 01:20:42.600
so thank you thank you for attending and i will see you guys next time bye bye thanks

01:20:42.600 --> 01:20:47.000
for the session sir i'm disconnecting now