SOBRE ESTE EPISÓDIO
Summary:
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.
WEBVTT
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
PHP.
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
image.
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
Hi.
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
test.
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 reg.home.cloudgenie.us.
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
now.
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, gcr.io 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
fashion.
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 hello.py 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
Inglês
Estados Unidos da América
NESTE EPISÓDIO
TRANSCRIÇÃO 🔗
Are you the producer of this podcast?
Add a podcast transcript
Need Audio-to-Text?
Transcribe with Listen411 in Just 60 Seconds
PESQUISAR EPISÓDIOS PASSADOS
Pesquisar episódios anteriores de The Cloud Seminar.
OUTROS EPISÓDIOS NESTE PODCAST
Summary:
Akshay is a problem solver, a curious, passionate tinkerer, explorer and builder of solutions of problems that catches his attention.I keenly observe the younger generation and @AkshayNarisetti caught my attention.So here we go talking 1x1 on a Twitter space followed by open questions/ans…
Summary:
In this hands-on live session, I demonstrate how to use docker to run TLS-protected services behind a reverse proxy in a machine in the cloud.
AI-Generated Transcript
Hit the ► button below
AMA Open 🎤 & Governor Swaraj@governorswaraj shows up in the Twitter Space discussion ☺️
Summary
In this hands-on live session, I demonstrate how to run WordPress with MySQL behind a TLS-protected reserve proxy on a machine in the cloud.
Error resolution
I ran into an error in the live stream. This gist contains the fix for the issue.
version 3 fixed after livestream
version 3 fixed…
Summary:
In this session, I describe the end-to-end trust chain behind a certificate used to enable Transport Layer Security TLS between any two endpoints.
Next, I demonstrate the creation and use of a real TLS cert using the LetsEncrypt open and automated TLS generation technique and test to veri…
Aviso: O podcast e a arte incorporada nesta página são de Nilesh from Cloud Genius®, que é propriedade de seu proprietário e não é afiliado ou endossado por Listen Notes, Inc.
EDITAR
Obrigado por ajudar a manter a base de dados dos podcasts atualizada.
