username

password

Gain insights into Docker's architecture, images, and containers. Learn about running databases, using WordPress and Node.js with Docker, and confidently apply Docker in web development projects.

tarballverified.tar.gz

sqlJob

wordpressJob

nodejsJob

quizJob

ch4_2

ch4_3

ch4_3_2

ch4_3_3

ch4_4

ch4_challenge

ch5_3_nginx

drupal

cdToUsercode

ch6_4

ch6_4_2

ch_6_5

ch_6_5_2

ch_6_6

ch_7_2

ch_7_3

debugging_gui

cdToUsercode_gui

ch_5_3

adminerWordPress

executeJob

ch10_3

ch_5_4_drupal

PROJECT

PROJECT_prod

PROJECT_DEV

ch_5_3-copy

debugging_gui-copy

ch_5_3-copy-vgib6g

ch_5_4_drupal-copy

PROJECT-copy

PROJECT_DEV-copy

ch_6_5_2-copy

Docker is the most useful web development tool you’re not using. This course is your guide for building all kinds of web applications with Docker.

You will be introduced to Docker basics including its architecture, images, and containers. Then you'll run various databases and view them via CLI or Adminer. Next, you will learn how easy it is to use WordPress with Docker. After that is the Node.js app and its live editing and debugging with Chrome's devTools. Finally, you will make your own project to practice your Docker knowledge.

By the end of the course, you will be able to confidently use Docker in any of your further projects.

Docker for Web Developers

## Dockerfile

A `Dockerfile` is a plain-text file describing the steps to build an image, typically for your own application. To build a Docker image from a `Dockerfile` in the current directory, enter:

```sh
docker image build -t <image_name> .
```

The period at the end of the command references the current directory. Append `-f <file>` to use an alternative path or file name.

The commands below will be used most often.


## `#` comment

Lines beginning with `#` denote a comment:

```dockerfile
#my comment
```

## `ARG` arguments

Variables can be passed at build time with the `--build-arg <name>=<value>` option. The value is imported with an `ARG` statement:

```dockerfile
#get myvar
ARG myvar
```

A default value can be defined when nothing is passed:

```dockerfile
#get myvar, with default of "myimage"
ARG myvar=myimage
```

Use its value elsewhere by prepending a `$` symbol:

```dockerfile
RUN echo $myvar
```

Where the value must be set in part of a string, a `${name}` substitution can be defined:

```dockerfile
FROM ${myvar}:latest
```


## `ENV` environment variables

Set an environment variable:

```dockerfile
ENV HOME=/home/app
```

Use its value elsewhere by prepending `$` symbol or `${}` container:

```dockerfile
RUN echo $HOME
RUN echo ${HOME}
```


## `FROM <image>` starting image

Create a new image using an existing image as a starting point. This will usually be the first command in a `Dockerfile`:

```dockerfile
#latest Node LTS on Alpine Linux
FROM node:lts-alpine
```


## `WORKDIR` working directory

Set the working directory for any following [`COPY`](#copy-files-from-the-host-to-image), [`ADD`](#add-files), [`RUN`](#run-a-command), [`CMD`](#cmd-execute-container) and [`ENTRYPOINT`](#entrypoint-execute-container) instructions:

```dockerfile
WORKDIR /home/myapp
```


## `COPY` files from the host to an image

Using file patterns:

```dockerfile
#copy all files to current folder
COPY . .

#copy all txt files to /doc/ folder
COPY *.txt /doc/

#copy all files and assign ownership to a user and group
#(Linux containers only)
COPY --chown=myuser:mygroup . .
```


## `ADD` files

`ADD` is similar to `COPY`, but it also supports using URLs and tar files as the source. This may be useful, although using a [`RUN`](#run-a-command) with chained `curl` and `tar` commands will create a smaller Docker image with fewer layers.


## Mount a `VOLUME`

By creating a mount point we can make files and folders accessible to other containers, e.g., in the following the data in the folder `/data/myvol` is available to other containers in the network too,

```dockerfile
RUN mkdir -p /data/myvol
VOLUME /data/myvol
```

Multiple volumes or mount points can be specified as:

```dockerfile
VOLUME /myvol1 /myvol2 /myvol3
```
Example use: If you are serving a Node.js application to NGINX and you want to share some Node.js files with NGINX, you can mount the client-side HTML, CSS, JavaScript, and media files in a `static` folder on a Node.js container. Now these files can be served directly by an NGINX web server running in another container.


## Set a `USER`

Define the user (and optionally a group) to use for [`RUN`](#run-a-command), [`CMD`](#cmd-execute-container) and [`ENTRYPOINT`](#entrypoint-execute-container) instructions:

```dockerfile
USER myuser
```

## `RUN` a command

`RUN` issues instructions during the build, such as installation or configuration commands. Any number is permitted in the `Dockerfile`.

Execute commands using shell form:

```dockerfile
RUN npm install
```

Or an `exec` (array) form to run an executable directly, which is the recommended option:

```dockerfile
RUN ["npm", "install"]
```

> 📌 The `Exec` form correctly receives Unix signals such as the signal to terminate. It is the most commonly used and is also recommended over the `Shell` form. The `Shell` omits weird array notations. Docker executes the command via a command shell. It prefixes the given command with `/bin/sh -c`, so in our case, it runs `/bin/sh -c node ./index.js`. This form is avoided because it does not pass signals to its subprocesses, which causes issues later in the termination of the server.

## `EXPOSE` a port

Informs Docker that the container will listen on a specified network port. Note that the exposed port must be published with `-p` when using `docker run`:

```dockerfile
EXPOSE 3000
```


## `CMD` execute container

`CMD` sets a default application start instruction if one isn't specified when launching the container with `docker run`. Only one is permitted in the `Dockerfile`, so only the last is processed.

Commands can be executed using shell form:

```dockerfile
CMD node ./index.js
```

Or an `exec` (array) form to directly run the executable:

```dockerfile
CMD ["node", "/index.js"]
```

In general, use `CMD` to provide a default command that can be overridden on the command line when the container is launched.


## `ENTRYPOINT` execute container

`ENTRYPOINT` sets a start instruction when building an executable Docker image. The application will run when the container is launched. Only one is permitted in the `Dockerfile` and it overrides any [`CMD`](#cmd-execute-container) instructions.

Commands can be executed using shell form:

```dockerfile
ENTRYPOINT node ./index.js
```

or `exec` (array) form -- the recommended option -- to directly run the executable:

```dockerfile
ENTRYPOINT ["node", "/index.js"]
```


## `.dockerignore` file patterns

`.docekerignore` specifies filename patterns to omit when using [`COPY`](#copy-files-from-the-host-to-image) and [`ADD`](#add-files). For example:



# Dockerfile

A `Dockerfile` is a plain-text file describing the steps to build an image, typically for your own application. To build a Docker image from a `Dockerfile` in the current directory, enter:

```sh
docker image build -t <image_name> .
```

The period at the end of the command references the current directory. Append `-f <file>` to use an alternative path or file name.

The commands below will be used most often.


# `#` comment

Lines beginning with `#` denote a comment:

```dockerfile
#my comment
```

# `ARG` arguments

Variables can be passed at build time with the `--build-arg <name>=<value>` option. The value is imported with an `ARG` statement:

```dockerfile
#get myvar
ARG myvar
```

A default value can be defined when nothing is passed:

```dockerfile
#get myvar, with default of "myimage"
ARG myvar=myimage
```

Use its value elsewhere by prepending a `$` symbol:

```dockerfile
RUN echo $myvar
```

Where the value must be set in part of a string, a `${name}` substitution can be defined:

```dockerfile
FROM ${myvar}:latest
```


# `ENV` environment variables

Set an environment variable:

```dockerfile
ENV HOME=/home/app
```

Use its value elsewhere by prepending `$` symbol or `${}` container:

```dockerfile
RUN echo $HOME
RUN echo ${HOME}
```


# `FROM <image>` starting image

Create a new image using an existing image as a starting point. This will usually be the first command in a `Dockerfile`:

```dockerfile
#latest Node LTS on Alpine Linux
FROM node:lts-alpine
```


# `WORKDIR` working directory

Set the working directory for any following [`COPY`](#copy-files-from-the-host-to-image), [`ADD`](#add-files), [`RUN`](#run-a-command), [`CMD`](#cmd-execute-container) and [`ENTRYPOINT`](#entrypoint-execute-container) instructions:

```dockerfile
WORKDIR /home/myapp
```


# `COPY` files from the host to an image

Using file patterns:

```dockerfile
#copy all files to current folder
COPY . .

#copy all txt files to /doc/ folder
COPY *.txt /doc/

#copy all files and assign ownership to a user and group
#(Linux containers only)
COPY --chown=myuser:mygroup . .
```


# `ADD` files

`ADD` is similar to `COPY`, but it also supports using URLs and tar files as the source. This may be useful, although using a [`RUN`](#run-a-command) with chained `curl` and `tar` commands will create a smaller Docker image with fewer layers.


# Mount a `VOLUME`

By creating a mount point we can make files and folders accessible to other containers, e.g., in the following the data in the folder `/data/myvol` is available to other containers in the network too,

```dockerfile
RUN mkdir -p /data/myvol
VOLUME /data/myvol
```

Multiple volumes or mount points can be specified as:

```dockerfile
VOLUME /myvol1 /myvol2 /myvol3
```
Example use: If you are serving a Node.js application to NGINX and you want to share some Node.js files with NGINX, you can mount the client-side HTML, CSS, JavaScript, and media files in a `static` folder on a Node.js container. Now these files can be served directly by an NGINX web server running in another container.


# Set a `USER`

Define the user (and optionally a group) to use for [`RUN`](#run-a-command), [`CMD`](#cmd-execute-container) and [`ENTRYPOINT`](#entrypoint-execute-container) instructions:

```dockerfile
USER myuser
```

# `RUN` a command

`RUN` issues instructions during the build, such as installation or configuration commands. Any number is permitted in the `Dockerfile`.

Execute commands using shell form:

```dockerfile
RUN npm install
```

Or an `exec` (array) form to run an executable directly, which is the recommended option:

```dockerfile
RUN ["npm", "install"]
```

> 📌 The `Exec` form correctly receives Unix signals such as the signal to terminate. It is the most commonly used and is also recommended over the `Shell` form. The `Shell` omits weird array notations. Docker executes the command via a command shell. It prefixes the given command with `/bin/sh -c`, so in our case, it runs `/bin/sh -c node ./index.js`. This form is avoided because it does not pass signals to its subprocesses, which causes issues later in the termination of the server.

# `EXPOSE` a port

Informs Docker that the container will listen on a specified network port. Note that the exposed port must be published with `-p` when using `docker run`:

```dockerfile
EXPOSE 3000
```


# `CMD` execute container

`CMD` sets a default application start instruction if one isn't specified when launching the container with `docker run`. Only one is permitted in the `Dockerfile`, so only the last is processed.

Commands can be executed using shell form:

```dockerfile
CMD node ./index.js
```

Or an `exec` (array) form to directly run the executable:

```dockerfile
CMD ["node", "/index.js"]
```

In general, use `CMD` to provide a default command that can be overridden on the command line when the container is launched.


# `ENTRYPOINT` execute container

`ENTRYPOINT` sets a start instruction when building an executable Docker image. The application will run when the container is launched. Only one is permitted in the `Dockerfile` and it overrides any [`CMD`](#cmd-execute-container) instructions.

Commands can be executed using shell form:

```dockerfile
ENTRYPOINT node ./index.js
```

or `exec` (array) form -- the recommended option -- to directly run the executable:

```dockerfile
ENTRYPOINT ["node", "/index.js"]
```


# `.dockerignore` file patterns

`.docekerignore` specifies filename patterns to omit when using [`COPY`](#copy-files-from-the-host-to-image) and [`ADD`](#add-files). For example:



# Dockerfile

A `Dockerfile` is a plain-text file describing the steps to build an image, typically for your own application. To build a Docker image from a `Dockerfile` in the current directory, enter:

```sh
docker image build -t <image_name> .
```

The period at the end of the command references the current directory. Append `-f <file>` to use an alternative path or file name.

The commands below will be used most often.


# `#` comment

Lines beginning with `#` denote a comment:

```dockerfile
#my comment
```

# `ARG` arguments

Variables can be passed at build time with the `--build-arg <name>=<value>` option. The value is imported with an `ARG` statement:

```dockerfile
#get myvar
ARG myvar
```

A default value can be defined when nothing is passed:

```dockerfile
#get myvar, with default of "myimage"
ARG myvar=myimage
```

Use its value elsewhere by prepending a `＄` symbol:

```dockerfile
RUN echo $myvar
```

Where the value must be set in part of a string, a `＄{name}` substitution can be defined:

```dockerfile
FROM ${myvar}:latest
```


# `ENV` environment variables

Set an environment variable:

```dockerfile
ENV HOME=/home/app
```

Use its value elsewhere by prepending `＄` symbol or `＄{}` container:

```dockerfile
RUN echo $HOME
RUN echo ${HOME}
```


# `FROM <image>` starting image

Create a new image using an existing image as a starting point. This will usually be the first command in a `Dockerfile`:

```dockerfile
#latest Node LTS on Alpine Linux
FROM node:lts-alpine
```


# `WORKDIR` working directory

Set the working directory for any following [`COPY`](#copy-files-from-the-host-to-image), [`ADD`](#add-files), [`RUN`](#run-a-command), [`CMD`](#cmd-execute-container) and [`ENTRYPOINT`](#entrypoint-execute-container) instructions:

```dockerfile
WORKDIR /home/myapp
```


# `COPY` files from the host to an image

Using file patterns:

```dockerfile
#copy all files to current folder
COPY . .

#copy all txt files to /doc/ folder
COPY *.txt /doc/

#copy all files and assign ownership to a user and group
#(Linux containers only)
COPY --chown=myuser:mygroup . .
```


# `ADD` files

`ADD` is similar to `COPY`, but it also supports using URLs and tar files as the source. This may be useful, although using a [`RUN`](#run-a-command) with chained `curl` and `tar` commands will create a smaller Docker image with fewer layers.


# Mount a `VOLUME`

By creating a mount point we can make files and folders accessible to other containers, e.g., in the following the data in the folder `/data/myvol` is available to other containers in the network too,

```dockerfile
RUN mkdir -p /data/myvol
VOLUME /data/myvol
```

Multiple volumes or mount points can be specified as:

```dockerfile
VOLUME /myvol1 /myvol2 /myvol3
```
Example use: If you are serving a Node.js application to NGINX and you want to share some Node.js files with NGINX, you can mount the client-side HTML, CSS, JavaScript, and media files in a `static` folder on a Node.js container. Now these files can be served directly by an NGINX web server running in another container.


# Set a `USER`

Define the user (and optionally a group) to use for [`RUN`](#run-a-command), [`CMD`](#cmd-execute-container) and [`ENTRYPOINT`](#entrypoint-execute-container) instructions:

```dockerfile
USER myuser
```

# `RUN` a command

`RUN` issues instructions during the build, such as installation or configuration commands. Any number is permitted in the `Dockerfile`.

Execute commands using shell form:

```dockerfile
RUN npm install
```

Or an `exec` (array) form to run an executable directly, which is the recommended option:

```dockerfile
RUN ["npm", "install"]
```

> 📌 The `Exec` form correctly receives Unix signals such as the signal to terminate. It is the most commonly used and is also recommended over the `Shell` form. The `Shell` omits weird array notations. Docker executes the command via a command shell. It prefixes the given command with `/bin/sh -c`, so in our case, it runs `/bin/sh -c node ./index.js`. This form is avoided because it does not pass signals to its subprocesses, which causes issues later in the termination of the server.

# `EXPOSE` a port

Informs Docker that the container will listen on a specified network port. Note that the exposed port must be published with `-p` when using `docker run`:

```dockerfile
EXPOSE 3000
```


# `CMD` execute container

`CMD` sets a default application start instruction if one isn't specified when launching the container with `docker run`. Only one is permitted in the `Dockerfile`, so only the last is processed.

Commands can be executed using shell form:

```dockerfile
CMD node ./index.js
```

Or an `exec` (array) form to directly run the executable:

```dockerfile
CMD ["node", "/index.js"]
```

In general, use `CMD` to provide a default command that can be overridden on the command line when the container is launched.


# `ENTRYPOINT` execute container

`ENTRYPOINT` sets a start instruction when building an executable Docker image. The application will run when the container is launched. Only one is permitted in the `Dockerfile` and it overrides any [`CMD`](#cmd-execute-container) instructions.

Commands can be executed using shell form:

```dockerfile
ENTRYPOINT node ./index.js
```

or `exec` (array) form -- the recommended option -- to directly run the executable:

```dockerfile
ENTRYPOINT ["node", "/index.js"]
```


# `.dockerignore` file patterns

`.docekerignore` specifies filename patterns to omit when using [`COPY`](#copy-files-from-the-host-to-image) and [`ADD`](#add-files). For example:



Learn which instructions can be used in Dockerfile.

Dockerfile

Why Docker for Web Developers?

Introduction

What is Docker?

Launch a MySQL Database with Docker

WordPress Development with Docker

Application Development with Docker

Push Your Docker Image to a Repository

Docker Orchestration on Production Servers

Docker CLI Commands

Dockerfile and Docker Compose

Project: Never-Ending Quizzery

Assessment - Docker for Web Developers

APPENDIX

Dockerfile

Dockerfile

`#` comment

`ARG` arguments

`ENV` environment variables

Assessment - Docker for Web Developers

Dockerfile

Dockerfile

# comment

ARG arguments

ENV environment variables

`#` comment

`ARG` arguments

`ENV` environment variables