For a couple different reasons, one of them being that Docker and containerization, in

general, are becoming more and more prevalent in the architectures that people are working

in in AWS or if you ship something to Digital Ocean.

They are just very important to be able to do this, but it's also incredibly important

in our development environments, and as I go through tutorials in the future I want

to be able to use Docker images in order to ship code as a starting point for some of

the applications and projects that we're going to look into.

I'm going to take this standpoint working from a mac, we're going to go from start to

finish with install Docker and working with Docker images that already exist, to creating

Docker containers, and understanding what it's like for us to create our own images

and then share those with the public.

We're going to get started using Docker for Mac, which is a new application that can be

installed into the /Applications directory, and there is also an equivalent version for

Windows.

If you're working on Linux, you don't actually have to worry about either of these things

because Linux can support it natively.

So for this I already have Docker for Mac downloaded.

I'm going to move over here and just install this.

In order to do this I had to uninstall everything that I had on my system so that we could make

this as thorough and realistic as possible.

So just drag and drop.

Now we're going to run Docker for Mac... there it is.

So you do have to allow this to use some network privileges, so you have to be an admin user

or a sudoer to be able to do this, but it's going to get you set up pretty fast.

So it goes on and does it's own thing here, but this will give us a couple different tools.

We'll just watch this.

So it is currently running.

This will give us Docker the command line utility, it's going to run Docker the server

for us and then it's going to create a VM that's actually running the Docker server

on, and from there it will also give us Docker Compose, which is an orchestration tool that

I'm not going to get into at all today, but I will in future videos just because it's

so useful from a development standpoint.

So, if I type "docker" it gave us this utility.

If I run "docker" and look at the version, this is the newest version that came out, as of

the time of recording this, just a few days ago.

If we look at the containers that are running, we don't actually have anything running, and

that's because we didn't tell it to run anything, but we also don't have any images yet.

If we look at Docker images you'll see that we have none here.

The first thing that you're going to do when working with Docker is you're going to have

to start a base image to work off of.

For us we're going to just pretend that we're just working with ubuntu.

For that we're going to need to run "docker pull ubuntu" and wait for it to download.

Before we move too much further on, we should talk about a few of the terms that are going

to be thrown around as we deal with more and more Docker.

The first one is "images".

Images are prepackaged bundles of changes that you've made to a file system, so image

that you start with ubuntu in this case which is just going to be the bare bones operating

system, and then if we wanted to build something more we would apply changes to it that that

we install something new or make a configuration change and that would become a different image

by stacking layers.

And then from there we'll get into probably the most important thing that we deal with,

and that's "containers", and that's actually when you take the image and you run it, and

you make use of that container.

So for us we'll do that right now.

We can do that by doing "docker run" and we'll pass it a few flags to make it interactive,

and then we'll give it the command, so we give it the image and the command name, and

this will go and run bash inide of an ubuntu thing.

So that we can make sure that we're not running on our mac by typing 'uname' and you can see

that we're running on Linux.

The first thing that we're going to do here is we're going to make a change and see what

happens.

I'm going to echo "STuff" into Test.txt and then just make sure it's there.

Yep, it's right there, right at the beginning.

So we'll exit this, and we'll run "docker ps".

There are no containers running.

Which I didn't actually show you what a container looks like when it is running, but we'll go

back into ubuntu and see if we can take a look at what's going on here.

So if we run this again and we run "ls" you'll notice that the Test.txt that we had up here

is not here, and that is because every time you create a container or you run and image

you create something that is entirely new, it is whatever the starting point was for

that image, but everything that happens while it's running is ephemoral, or it doesn't matter,

it just kind of keeps on churning.

There are ways to get around that by sharing some volumes or connecting some network things

together, but that's a little bit more complicated and we'll get into that when we talk about

docker-compose.

If I split this right now and I run "docker ps" you'll see that we do have a container

running.

Oh this is really ugly to look at though isn't it?

So we'll slide this over for a second.

And this gives us our container ID, the image that we used, the command that it's running,

and how old it is.

It also gives it a name, which if you don't provide a name for it, it comes up with some

pretty comical names.

So this is a "cranky turing".

So if we separate this back out.

We know that since we ran this container from an image that it always starts at the same

spot, regardless of how many times we run a container using the exact same image.

From here we're going to transition into something a little bit different, and that is containers

are cool and images are cool, but what happens if we want to make our own image.

So, imagine that we want to ship somebody ubuntu and we want it to come pre-installed

with some things.

So, in my particular case, I want to make sure that "wget" is there so that it's easy

to install things, and if we run our ubuntu image and we run "wget" you'll see that "oh

it's not there".

So that's kind of a bummer.

There's a really neat way of doing this in Docker and that is through what's known as

a Dockerfile.

And then from here the Dockerfile is a way to specify the recipe essentially, the steps

that we're going to take in order to take an image that already exists, in this case

"ubuntu", and turn it into something that more fits our needs, which in this case is

that we need ubuntu with wget and we need it to always be there.

So for that I'm going to open up Atom, I'm going to create a Dockerfile.

The Dockerfile has a slightly different syntax than a normal programming language because

its more just a series of steps, kind of like a script except you don't have the same power

of calculation that you would have if you were writing something like a ruby or a bash

script.

You have to follow a certain structure.

So the first thing that you have to do when creating a Dockerfile is that you have to

say what it's coming from, this is the starting image, or the layer that you're going to begin

with.

For us we're going to start with Ubuntu, and then from here we need to run some things.

Everything that comes after "RUN" is going to be processed inside, and then like I was

kind of saying earlier if you install something new, that creates a new layer.

Each of these command will create something, a different layer on top of of this.

And our image will actually be the final layer that is created because it was built up of

all the layers that existed before it.

For us we're going to "apt-get update" and then pass it a few flags to make it a little

quiet, and the we will also say "apt-get install wget" and we'll pass this just to make it

a little quiet too.

From here the other thing that you need to have is what is actually going to happen when

you run an image, and that is by default you can actually do "docker run ubuntu" and it

will go off an run something.

I actually don't remember off hand what ubuntu does when you run it by itself, but you can

define a default command so that if it's something that's going to, say you have an image that's

going to go and process some data and then close, you can just type "docker run my_data_processor_image"

and then it will go off, do it's thing, and then just the process itself will die and

the container will go away.

So we don't have to do that, but in our case I want to because I don't want to have to

type "bash" every single time.

I'm going to put this in here to where it's just going to run "bash" whenever we do this.

We're going to save it.

We're going to bounce back over to our terminal sothat we can build this.

Behind the scenes I moved us into a different directory, but what you're going to do here

is type "docker build", we're going to name our image, in this case it's called "tagging",

but we're going to tag it as "wget" and then we're going to say build with the current

context, which just means use this directory and look for the Dockerfile that's here.

So it's going to go off and figure everything that it needs and then you'll see that these

are the steps that it takes.

Our first step was to say from this, this represents the layer that is "ubuntu", and

then our next step here is run "apt-get update" and also install wget.

It will show you everything that it's installing.

And then when it's finished, you'll see that it gives you this.

So it created an image here, and then you're going to come down here and this next step,

yet another layer that we're going to be adding to this is to say that you're going to run

"bash" as your default thing.

So now if we run "docker images" you can see that we have multiple images here, that is

the successful build of the image that we just made for "wget", and then we have the

ubuntu one which gives you this original SHA too.

The neat thing here is that you can also see the difference in what we did, us running

"apt-get update" and "apt-get install" on wget actually installed an extra 46MB worth

of space.

Let's run our image and see the fruits of our labor here.

So if we "docker run -it" and just type "wget", remember that we told it the command it should

run is bash.

So it should open us right into bash.

And we're going to "wget google.com" and it should just work.

There you go, so we went and we downloaded the index.html from google.com with the tool

that we installed and now everytime we want to work with something that needs "wget" we

can run our own image instead of working with the ubuntu image that didn't have that package

installed to begin with.

So the last thing that I said we were going to do in this short tutorial is that we're

going to take our image and we're going to put it on the web so that other people can

access it, but I'm also going to show you how to find other images that you can work

with.

So if we go back to the web browser, if you go to hub.docker.com you can see all of the

other images that exist out here.

This is looking at my profile page, but if we go to the dashboard here, well "explore",

you'll see that there are a bunch of different "official repositories", so Nginx is one for

instance that if you just type "docker pull nginx" it will pull this exact image.

Normally, you have to work off of things by username and then image name, but ubuntu for

instance, this is the exact image that we were using for our purposes before we installed

wget on top of it.

There are many of these things, so there are a lot of different things that you need necessarily,

or that you might want to work with, like say you want to play around with node, but

you don't want to install it on your local machine, you can pull the official node image

and then you can go into the container that it starts and run bash in there for instance

to give youself a shell so that you can work with node directly.

Wordpress for instance, you just spin up a container that is already running wordpress

and go from there.

If we look back at the dashboard, I have a couple just random projects that I've sort

of worked with, but this one, the "elixir-ide" is me experimenting and putting an ubuntu

image out there that had everything that I needed for working with elixir, so I put a