Learn Docker in 7 Easy Steps - Full Beginner's Tutorial

Summary

This video script offers an in-depth tutorial on Docker for developers, focusing on containerizing a Node.js application. It covers Docker's basics, including Dockerfiles, images, and containers, and addresses advanced topics like port forwarding and volumes. The tutorial guides viewers through installation, writing Dockerfiles, building and running images, and managing multi-container setups with Docker Compose, aiming to demystify Docker and empower developers to package and deploy applications consistently across any environment.

Takeaways

• 📦 Docker is a tool for packaging software so it can run on any hardware, helping to standardize development environments.
• 🛠️ The core components of Docker are Dockerfiles, images, and containers, which work together to build, distribute, and run applications consistently.
• 💡 Docker solves the 'it works on my machine' problem by allowing developers to define and reproduce environments with Dockerfiles.
• 📝 A Dockerfile is a script with instructions to build a Docker image, which serves as a template for creating containers.
• 🚀 The process of Dockerizing an application involves creating a Dockerfile, installing dependencies, and defining how the application runs within a container.
• 🖥️ Docker Desktop is recommended for Mac or Windows users, providing both command-line access and a GUI for managing containers.
• 🔍 Docker extensions for IDEs like VS Code enhance development by providing language support for Dockerfiles and integration with registries.
• 🔑 The 'FROM' instruction in a Dockerfile starts with a base image, which can be an official image like 'node:12' to simplify setup.
• 🔄 Efficient layer caching in Dockerfiles is achieved by installing dependencies before copying the source code, minimizing rebuild times.
• 🔒 Dockerignore files help to exclude unnecessary files like 'node_modules' from being copied into the Docker image, keeping the image lean.
• 🔌 Port forwarding is essential for accessing applications running inside containers from the host machine, using the '-p' flag in 'docker run'.
• 🔄 Volumes in Docker allow data persistence and sharing across containers, useful for databases and other stateful services.
• 🔧 Docker Compose simplifies the management of multi-container applications by defining and running services, volumes, and networking in a YAML file.
• 🔄 Debugging Dockerized applications can be done through logs, direct CLI access within containers, or using Docker Desktop's GUI.

Q & A

What is one of the leading causes of imposter syndrome among developers mentioned in the script?

Not knowing Docker and feeling left out during discussions about advanced topics like Kubernetes, swarms, and sharding at parties.

What is the main goal of the video?

To teach developers everything they need to know about Docker, including installation, Dockerfile instructions, and advanced concepts like port forwarding, volumes, and Docker Compose.

What are the three essential concepts in Docker that one must understand?

The three essential concepts are Dockerfiles, images, and containers. A Dockerfile is a blueprint for building a Docker image, an image is a template for running containers, and a container is a running process of that image.

Why is Docker useful for developers?

Docker is useful for developers because it packages software so it can run on any hardware, ensuring that applications run consistently across different environments and avoiding issues like 'it works on my machine'.

What is the purpose of a Dockerfile?

A Dockerfile is used as a blueprint to build a Docker image, which is then used to create containers. It contains a set of instructions that define the environment in which the application will run.

How does Docker solve the problem of different environments causing application failures?

Docker solves this problem by allowing developers to define the environment in a Dockerfile, creating an immutable snapshot known as an image. This image can be used to spawn the same process in multiple places, ensuring consistency.

What command should one memorize after installing Docker?

The 'docker' command should be memorized as it lists all the running containers on the system.

Why is it important to install the Docker extension for VS Code or another IDE?

The Docker extension provides language support when writing Dockerfiles, and it can also link up to remote registries, offering additional functionality and convenience.

What is the significance of the 'FROM' instruction in a Dockerfile?

The 'FROM' instruction specifies the base image to start from when building the Docker image. It's typically a specific version of an operating system or a language runtime environment.

Why should dependencies be installed before the app source code in a Dockerfile?

Installing dependencies first allows Docker to cache them, which means that they don't need to be reinstalled every time the app source code changes, making the build process more efficient.

What is the purpose of the 'docker build' command?

The 'docker build' command is used to build a Docker image from a Dockerfile. It processes each instruction in the Dockerfile and creates an image that can be used to run containers.

How can one access a running Docker container's logs and interact with its command line?

One can access logs and interact with a Docker container's command line using Docker Desktop's GUI, which provides a dashboard for viewing logs and a CLI button for executing commands, or by using the 'docker exec' command from the command line.

What is Docker Compose and how does it help with running multiple containers?

Docker Compose is a tool for defining and running multi-container Docker applications. It allows you to configure your application's services, networks, and volumes in a 'docker-compose.yaml' file and start all the containers together with a single command.

Why should each container in a Dockerized application ideally run only one process?

Running only one process per container helps keep the containers simple and maintainable. It also aligns with the microservices architecture, making it easier to manage and scale individual components of the application.

Outlines

00:00

📦 Understanding Docker Basics for Developers

This paragraph introduces the concept of imposter syndrome among developers due to unfamiliarity with Docker, a tool for containerization. It outlines the importance of Docker in modern development practices and promises a step-by-step guide to mastering Docker by containerizing a Node.js application. The paragraph explains the basic components of Docker, including Dockerfiles, images, and containers, and emphasizes Docker's role in creating reproducible software environments. It also touches on advanced Docker concepts such as port forwarding, volumes, and Docker Compose for managing multiple containers.

05:01

🛠 Docker Installation and Dockerfile Essentials

The second paragraph delves into the installation process of Docker, recommending Docker Desktop for Mac and Windows users. It details the first Docker command to memorize and the importance of the Docker extension for IDEs like VS Code. The main focus then shifts to the Dockerfile, which is the core of building a Docker image. The paragraph walks through creating a Dockerfile, starting with choosing a base image, adding app source code, and installing dependencies. It also discusses best practices for Dockerfile instructions, such as caching layers for efficiency and using the 'docker ignore' file to avoid copying unnecessary files into the image. The paragraph concludes with how to set environment variables, expose ports, and the significance of the 'command' instruction in the Dockerfile for running the application.

10:02

🔧 Building and Running Docker Images

This paragraph explains the process of building a Docker image using the 'docker build' command, including how to tag images for easy identification and retrieval. It describes the build process starting from pulling the base image to executing each step in the Dockerfile. The paragraph also covers how to run a Docker container locally using the 'docker run' command and the importance of port mapping for external access to the container's services. Additionally, it discusses the persistence of container data using volumes and how to manage and debug containers using Docker Desktop or command-line tools like 'docker exec'. The paragraph wraps up with a brief introduction to Docker Compose for orchestrating multiple containers, which is particularly useful for complex applications requiring services like databases.

🔄 Orchestrating Containers with Docker Compose

The final paragraph introduces Docker Compose as a tool for defining and running multi-container Docker applications. It provides an overview of creating a 'docker-compose.yaml' file to configure services, such as a Node.js app and a MySQL database, along with volume definitions for data persistence. The paragraph explains how to use YAML syntax to simplify the configuration of multiple containers and services. It concludes with the execution of 'docker compose up' to start all services together and 'docker compose down' to shut them down, emphasizing the ease of managing containerized applications with Docker Compose.

Keywords

💡Imposter Syndrome

Imposter syndrome is a psychological pattern where individuals doubt their skills and fear being exposed as a 'fraud'. In the script, it's mentioned as a leading cause among developers, particularly when they feel they lack knowledge in areas like Docker, which can make them feel out of place in technical discussions.

💡Docker

Docker is a platform that allows developers to package applications into containers that can run consistently across different environments. The video aims to teach viewers how to use Docker, emphasizing its importance for developers to ensure their applications run seamlessly on any hardware.

💡Container

A container in the context of Docker is a lightweight, standalone, and executable package of software that includes everything needed to run an application. The script explains that containers are running processes that can be created from an image, which helps in solving environment-related issues like 'it works on my machine' problems.

💡Dockerfile

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. The script details the importance of Dockerfiles in defining the environment for an application, allowing for the creation of a Docker image that can be shared and reused.

💡Docker Image

A Docker image is a read-only template with instructions for creating a Docker container. The script uses the term to describe the output of a Dockerfile, which can be used to create containers and is stored as an immutable snapshot.

💡Port Forwarding

Port forwarding is a technique that allows a networked request made to a specific port on a local machine to be forwarded to a specified port on a remote machine. In the script, port forwarding is explained as a way to make a Docker container's port accessible from the local machine.

💡Volumes

In Docker, a volume is a way to persist data generated by and used by Docker containers. The script mentions volumes as a means to share data across multiple containers and to persist data even after the containers are stopped.

💡Docker Compose

Docker Compose is a tool for defining and running multi-container Docker applications. The script introduces Docker Compose as a solution for managing multiple containers, such as a Node.js application and a MySQL database, by using a YAML file to configure the services.

💡Node.js

Node.js is a JavaScript runtime that allows developers to write server-side code in JavaScript. The script uses Node.js as an example application that is containerized using Docker, demonstrating the process of creating a Dockerfile and building a Docker image for a Node.js application.

💡Environment Variables

Environment variables are a set of dynamic values that can affect the way running processes will behave on a computer. In the script, environment variables are used within the Docker container to configure the application, such as setting the port on which the Node.js application listens.

💡Microservices

Microservices is an architectural style that structures an application as a collection of loosely coupled services. The script suggests that each container should run a single process, advocating for microservices architecture to keep containers simple and maintainable.

Highlights

Imposter syndrome among developers can be caused by a lack of Docker knowledge.

Docker helps package software to run on any hardware, solving 'it works on my machine' problems.

Understanding Docker involves knowing about Dockerfiles, images, and containers.

A Dockerfile is a blueprint for building a Docker image.

Docker images are templates for running Docker containers.

Containers are running processes that can be created from an image.

Docker can reproduce environments defined by developers to ensure consistency.

Images can be uploaded to public and private registries for easy access.

Docker Desktop application is recommended for Mac and Windows users.

Docker extension for VS Code provides language support and remote registry linking.

The Dockerfile contains instructions to build a Docker image and run an application.

Base images like 'node:12' are used to provide a starting environment for Dockerfiles.

Dependencies should be installed first in a Dockerfile to leverage Docker's layer caching.

Dockerignore file helps to exclude unnecessary files like 'node_modules' from being copied.

Environment variables and port exposure are set in the Dockerfile for container configuration.

The 'exec form' in Dockerfile is preferred for running the application process.

Docker images are built using the 'docker build' command with a tag for easy access.

Port forwarding is implemented using the '-p' flag to make containers accessible locally.

Volumes are used in Docker to share data across multiple containers and persist data.

Docker Compose is a tool for running multiple Docker containers simultaneously.

Docker Compose uses a 'docker-compose.yaml' file to define and run services and volumes.

Docker Compose allows for easy scaling of containers with tools like Kubernetes and Swarm.

Debugging Docker containers can be done through logs, CLI access, and Docker Desktop GUI.

Docker encourages the development of simple, maintainable microservices.

Transcripts

one of the leading causes of imposter

syndrome among developers is not knowing

docker it makes it hard to go to parties

where everybody's talking about

kubernetes

swarms shuffle sharding while you hide

in the corner googling what is a

container we've all been there at one

point or another

in today's video you'll learn everything

you need to know about docker to survive

as a developer in 2020

we'll take a hands-on approach by

containerizing a node.js application

i'll assume you've never touched a

docker container before so we'll go

through installation and tooling

as well as the most important

instructions in a dockerfile in addition

we'll look at very important advanced

concepts like port forwarding

volumes and how to manage multiple

containers with docker compose

we'll do everything step by step so feel

free to skip ahead with the chapters in

the video description

what is docker from a practical

standpoint it's just a way to package

software so it can run on any hardware

now in order to understand how that

process works there are three things

that you absolutely must know

docker files images and containers a

docker file is a blueprint for building

a docker image

a docker image is a template for running

docker containers

a container is just a running process in

our case we have a node application we

need to have a server that's running the

same version of node and that has also

installed these dependencies

it works on my machine but if someone

else with a different machine tries to

run it with a different version of node

it might break

the whole point of docker is to solve

problems like this by reproducing

environments the developer who creates

the software can define the environment

with a docker file

then any developer at that point can use

the docker file to rebuild the

environment which is saved as an

immutable snapshot known as an image

images can be uploaded to the cloud in

both public and private registries

then any developer or server that wants

to run that software

can pull the image down to create a

container which is just a running

process of that image in other words one

image file can be used to spawn the same

process multiple times in multiple

places

and it's at that point where tools like

kubernetes and swarm come into play

to scale containers to an infinite

workload the best way to really learn

docker

is to use it and to use it we need to

install it if you're on mac or windows i

would highly recommend installing the

docker desktop application it installs

everything you need for the command line

and also gives you a gui where you can

inspect your running containers

once installed you should have access to

docker from the command line and here's

the first command you should memorize

docker which gives you a list of all the

running containers on your system

you'll notice how every container has a

unique id and is also linked to an image

and keep in mind you can find the same

information from the gui as well now the

other thing you'll want to install is

the docker extension for vs code or for

your ide

this will give you language support when

you write your docker files and can also

link up to remote registries and a bunch

of other stuff

now that we have docker installed we can

move on to what is probably the most

important section of this video and

that's the docker file

which contains code to build your docker

image and ultimately run your app as a

container

now to follow along at this point you

can grab my source code from github or

fireship io or better yet

use your own application as a starting

point in this case i just have a single

index.js file

that exposes an api endpoint that sends

back a response

docker is easy then we expose our app

using the port environment variable

and that'll come into play later the

question we're faced with now is how do

we dockerize this app

we'll start by creating a docker file in

the root of the project

the first instruction in our docker file

is from and if you hover over it it will

give you some documentation about what

it does

you could start from scratch with

nothing but the docker runtime however

most docker

files will start with a specific base

image for example

when i type ubuntu you'll notice it's

underlined and when i control click it

it will take me to all the base images

for this flavor of linux and then you'll

notice it supports a variety of

different tags which are just different

variations on this base image

ubuntu doesn't have nodejs installed by

default we could still use this image

and install node.js manually

however there is a better option and

that's to use the officially supported

node.js image

we'll go ahead and use the node version

12 base image which will give us

everything we need to start working with

node in this environment

the next thing we'll want to do is add

our app source code to the image

the working directory instruction is

kind of like when you cd into a

directory

now any subsequent instructions in our

docker file will start from this app

directory

now at this point there is something

very important that you need to

understand

and that's that every instruction in

this docker file is considered its own

step or layer

in order to keep things efficient docker

will attempt to cache layers

if nothing is actually changed now

normally when you're working on a node

project

you get your source code and then you

install your dependencies but in docker

we actually want to install our

dependencies first so they can be cached

in other words we don't want to have to

reinstall all of our node modules every

time we change our app source code we

use the copy instruction which takes two

arguments

the first argument is our local package

json location

and then the second argument is the

place we want to copy it in the

container which is the current working

directory

and now that we have a package json we

can run the npm install command

this is just like opening a terminal

session and running a command

and when it's finished the results will

be committed to the docker image as a

layer

now that we have our modules in the

image we can then copy over our source

code

which we'll do by copying over all of

our local files to the current working

directory

but this actually creates a problem for

us because you'll notice that we have a

node modules folder here in our local

file system

that would also be copied over to the

image and override the node modules that

we install there

what we need is some kind of way for a

docker to ignore our local node modules

we can do that by creating a docker

ignore file

and adding node modules to it it works

just like a git ignore file which you've

probably seen before

okay so at this point we have our source

code in the docker image

but in order to run our code we're using

an environment variable we can set that

environment variable in the container

using the env

instruction now when we actually have a

running container we also want it to be

listening on port 8080 so we can access

the nodejs express app publicly

and we'll look at port some more detail

in just a minute when we run the

container

and that brings us to our final

instruction command there can only be

one of these per docker file and it

tells the container how to run the

actual application

which it does by starting a process to

serve the express app you'll also notice

that unlike run

we've made this command an array of

strings this is known as exec form

and it's the preferred way to do things

unlike a regular command it doesn't

start up a shell session

and that's basically all there is to it

we now have a full set of instructions

for building a docker image

and that brings us to the next question

how do we build a docker image

you build a docker image by running the

docker build command there's a lot of

different options you can pass with the

command but the one you want to know for

right now

is tag or t this will give your image a

name tag that's easy to remember so you

can access it later

when defining the tag name i'd first

recommend setting up a username on

docker hub

and then do that username followed by

whatever you want to call this image

so in my case it would be fireship slash

demo app and you could also add a

version number separated by a colon

from there you simply add the path to

your docker file which in our case is

just a period for the current working

directory

when we run it you'll notice it starts

with step one which is to pull the node

12 image remotely

then it goes through each step in our

docker file and finally it says

successfully built the

image id and now that we have this image

we can use it as a base image to create

other images or we can use it to run

containers

in real life to use this image you'll

most likely push it to a container

registry somewhere

that might be docker hub or your

favorite cloud provider and the command

you would use to do that is

docker push then a developer or server

somewhere else in the world could use

docker pull to pull that image back down

but we just want to run it here locally

in our system so let's do that with the

docker run command

we can supply it with the image id or

the tag name and all that does

is create a running process called a

container and we can see in the terminal

it should say app listening on localhost

8080. but if we open the browser and go

to that address we don't see anything

so why can't i access my container

locally remember we exposed port 8080 in

our docker file

but by default it's not accessible to

the outside world let's refactor our

command to use the p

flag to implement port forwarding from

the docker container to our local

machine

on the left side we'll map a port on our

local machine 5000 in this case

to a port on the docker container 8080

on the right side

and now if we open the browser and go to

localhost 5000 we'll see the app running

there

now one thing to keep in mind at this

point is that the docker container will

still be running even after you close

the terminal window

let's go ahead and open up the dashboard

and stop the container you should

actually have two running containers

here if you've been following along

when you stop the container any state or

data that you created inside of it will

be lost

but there can be situations where you

want to share data across multiple

containers

and the preferred way to do that is with

volumes a volume is just a dedicated

folder on the host machine

and inside this folder a container can

create files that can be remounted into

future containers or multiple containers

at the same time

to create a volume we use the docker

volume create command

now that we have this volume we can

mount it somewhere in our container when

we run it

multiple containers can mount this

volume simultaneously and access the

same set of files

and the files stick around after all the

containers are shut down

now that you know how to run a container

let's talk a little bit about debugging

when things don't go as planned you

might be wondering how do i inspect the

logs and how do i get into my container

and start interacting with the command

line

well this is where docker desktop really

comes in handy if you click on the

running container you can see all the

logs right there

and you can even search through them you

can also execute commands in your

container by clicking on the cli button

and keep in mind you can also do this

from your own command line using the

docker exec command

in any case it puts us in the root of

the file system of that container so we

can then ls to see files

or do whatever we want in our linux

environment that's useful to know but

one of the best things you can do to

keep your containers healthy

is to write simple maintainable micro

services each container should only run

one process

and if your app needs multiple processes

then you should use multiple containers

and docker has a tool designed just for

that called docker compose

it's just a tool for running multiple

docker containers at the same time

we already have a docker file for our

node app but let's imagine that our node

app also needs to access a mysql

database

and we also likely want a volume to

persist the database across multiple

containers

we can manage all that with docker

compose by creating a

docker-compose.yaml file in the root of

our project

inside that file we have a services

object where each key

in that object represents a different

container that we want to run

we'll use web to define our node.js app

that we've already built

and then we'll use build to point it to

the current working directory which is

where it can find the docker file

and then we'll also define the port

forwarding configuration here as well

then we have a separate container called

db which is our mysql database process

after services we'll also define a

volume to store the database data across

multiple containers

and then we can mount that volume in our

db container and hopefully you're

starting to see how much

easier it is to define this stuff as

yaml as opposed to writing it out as

individual commands

and now that we have this configuration

set we can run docker compose up from

the command line which will find this

file

and run all the containers together we

can mess around with our app for a

little while

and then run docker compose down to shut

down all the containers together

i'm going to go ahead and wrap things up

there if this video helped you please

like and subscribe and consider becoming

a pro member at fireship io

where we use docker in a variety of

different project-based courses

thanks for watching and i will see you

in the next one