The Docker flow: Images to containers

- [Instructor] Now that we've got Docker installed and talked a little bit about what Docker is, let's talk about what Docker does. The Docker flow the fundamental concept, in Docker it all begins with an image. An image is every file that makes up just enough of the operating system to do what you need to do. Traditionally you'd install a whole operating system with everything for each application you do. With Docker you pair it way down so that you have a little container with just enough of the operating system to do what you need to do, and you can have lots and lots of these efficiently on a computer.

Let's take a look at that. So let's take a look at Docker images. Amazingly creatively, the command to look into your Docker images is Docker images. It's a little bit squished, let me stretch that out for us, there we go. So here we have where the image came from, the repository, a tag is a version number. The repository for the image is where it came from.

In this case it was named ubuntu, this is the example we use in the installation movies. Tag is the version of it, in this case it's tag latest. And then there's image ID which is the internal Docker representation of this image. So you could always refer to this image by the combination of its name and its tag, ubuntu colon latest in any Docker command or you can refer to it by its number. It's useful to be able to refer to them by number because sometimes they don't have a name, they don't have to.

But if they do have a name it's a little more convenient to use it. Now what good is an image if not to do something with it? The Docker run command takes an image and turns it into a living running container with a process in it that's doing something, hopefully something useful, but at least something. So let's take a look at running an image to make a container. So now that I've got my image, I want to actually run something in it so I'm gonna use the ever conveniently named Docker run, and I'm gonna put this couple of flags in here, TI stands for terminal interactive.

It just causes it to have a full terminal within the image so that you can run the shell and get things like tab completion and formatting to work correctly. When you're running commands by typing on a keyboard inside an image, this is a very useful flag to put in. Most of the other times you don't need it, TI for terminal interactive. Now we need to say which image we'd like to run this thing in, ubuntu with the latest tag. What would we like to do? Well, since I'm gonna by typing on this keyboard I'm just gonna run the bash shell in my image.

Alright, I'm in my image. If I look around I'm in an ubuntu environment. Let's take a look at the standard place to see what distribution I'm using. Ah, I'm using ubuntu 1604 here. To exit this you can type exit or you can just press control D. So now we have a running image. I'm gonna run that image again and bring up another terminal so we can take a look at it from the outside.

There we are. I've got my ubuntu container running in the terminal on the left here, so on the right I'm gonna use the Docker PS command to take a look at the running images. So let's just run Docker PS. Now on my screen it looks a little squished here, and I prefer to look at things vertically so just for my personal preference I have defined a format string which will print them out vertically instead of horizontally.

This is completely optional, you don't have to use it but some people will find it more convenient. We'll take a look at that format string in a moment. For now let's take a look at what we got here. So our container, the running container has an ID which is different than the image ID that was used to run it from. These are not the same thing. Images have one set of IDs, containers have their own sets of IDs. They don't overlap and there's no place in Docker where you can interchange image and container IDs.

At least not that I know of. So that's the ID of the container. Here we see the image that it was made from, the command that's running in it and when it was created, its status and its name. Since I didn't specify a name when I started this container, Docker helpfully made me a nice creative one. So that format string I mentioned, this is just a convenience for my personal preference. It looks like this. You might see things differently in the terminal on your computer if you just run Docker PS without the dash dash format.

You're getting the same information, you're just getting it laid out horizontally instead of vertically. And you can freely play with format strings to format the output of most Docker commands in almost any way. It's very flexible, even if it doesn't look very pretty. Alright, now we have a running container. So this next part is sort of the important crux of what makes Docker different from virtual machines or running things on a real computer.

When you're inside a container you start from an image and that image is fixed, it doesn't change. When I make a container from an image, I don't change the image. So in my container over here which I made from the ubuntu image, ubuntu latest image I made this container, I'm gonna create a file. So we're at the root of the file system and I'm gonna make a big file. The touch command just makes empty blank files. Make a file called my file here in big letters.

If I do LS, right there, there's my file here. If I go over to this other terminal, if I start up another container from the same image that I made this one from, so I'm just gonna run that same command again. Docker run dash TI to make it pretty ubuntu latest bash, so I've started from the same place and made a new container. Do an LS, I do not see that file.

See, my file here shows up on this side, it's in this container but it's not in another container made from the same image. And if I exit this container and I start it up again, the file is not there. Files go into containers, but that doesn't put them back into the image that the container came from. They stay in that container.