🐳 What is Docker?#

Docker is a platform used to build, ship, and run applications inside containers.

🔹 What is a Container?#

A container is a lightweight, portable package that includes everything needed for an application to run — code, libraries, dependencies, and environment settings — so it runs the same on any system.

⚙️ Why Use Docker?#

Works the same on all systems (solves “it works on my machine” issue)
Fast, lightweight, and uses fewer resources than Virtual Machines
Easy to deploy and scale across environments
Great for DevOps, AppSec, and automation tasks

Docker Syntax Categories#

Running a container
Managing & Inspecting containers
Managing Docker images
Docker daemon stats & info

Managing Docker Images#

Pulling Images#

Download an image with docker pull IMAGE[:TAG].

If no tag is specified → defaults to latest.

1
docker pull nginx
2
docker pull ubuntu
3
docker pull ubuntu:22.04
4
docker pull ubuntu:20.04
5
docker pull ubuntu:18.04

Tags:

ubuntu:latest → latest release (could change)
ubuntu:22.04 → Jammy
ubuntu:20.04 → Focal
ubuntu:18.04 → Bionic

Docker Image Management#

1
shohan@kali:~$ docker image
2

3
Usage:  docker image COMMAND
4

5
Manage images
6

7
Commands:
8
  build       Build an image from a Dockerfile
9
  history     Show the history of an image
10
  import      Import the contents from a tarball to create a filesystem image
11
  inspect     Display detailed information on one or more images
12
  load        Load an image from a tar archive or STDIN
13
  ls          List images
14
  prune       Remove unused images
15
  pull        Pull an image or a repository from a registry
16
  push        Push an image or a repository to a registry
17
  rm          Remove one or more images
18
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
19
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
20

21
Run 'docker image COMMAND --help' for more information on a command.
22
shohan@kali:~$

Example:

pull (we have done this above!)
ls (list images)
rm (remove an image)
build (we will come onto this in the “Building your First Container” task)

Docker Image ls#

This command allows us to list all images stored on the local system. We can use this command to verify if an image has been downloaded correctly and to view a little bit more information about it (such as the tag, when the image was created and the size of the image).

1
shohan@kali:~$ docker image ls
2
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
3
ubuntu       22.04     2dc39ba059dc   10 days ago   77.8MB
4
nginx        latest    2b7d6430f78d   2 weeks ago   142MB
5
shohan@kali:~$

Repository	Tag	Image ID	Size
ubuntu	22.04	2dc39ba059dc	77.8MB
nginx	latest	2b7d6430f78d	142MB

Docker Image rm#

If we want to remove an image from the system, we can use docker image rm along with the name (or Image ID). In the following example, I will remove the “ubuntu” image with the tag “22.04”. My command will be docker image rm ubuntu:22.04:

It is important to remember to include the tag with the image name.

1
shohan@kali:~$ docker image rm ubuntu:22.04
2
Untagged: ubuntu:22.04
3
Untagged: ubuntu@sha256:20fa2d7bb4de7723f542be5923b06c4d704370f0390e4ae9e1c833c8785644c1
4
Deleted: sha256:2dc39ba059dcd42ade30aae30147b5692777ba9ff0779a62ad93a74de02e3e1f
5
Deleted: sha256:7f5cbd8cc787c8d628630756bcc7240e6c96b876c2882e6fc980a8b60cdfa274
6
shohan@kali:~$

Running Containers#

Syntax#

1
docker run [OPTIONS] IMAGE [COMMAND] [ARGS...]

RUN Container#

1
docker run -it helloworld /bin/bash

Common Options#

Option	Description	Example
`-it`	Interactive shell	`docker run -it helloworld /bin/bash`
`-d`	Detached mode	`docker run -d helloworld`
`-v`	Mount volume	`docker run -v /host:/container helloworld`
`-p`	Port mapping	`docker run -p 80:80 webserver`
`--rm`	Remove container after exit	`docker run --rm helloworld`
`--name`	Assign name	`docker run --name mycontainer helloworld`

Listing Containers#

1
docker ps      # list running
2
docker ps -a   # list all (including stopped)

Intro to Dockerfiles#

Dockerfiles are instruction manuals for building Docker images. They contain commands that define what a container should do.

Syntax: INSTRUCTION argument

🔑 Core Instructions

1
| Instruction | Description | Example |
2
|-------------|------------|---------|
3
| FROM        | Base image | FROM ubuntu:22.04 |
4
| RUN         | Execute cmd| RUN whoami |
5
| COPY        | Copy files | COPY ./app/ /app/ |
6
| WORKDIR     | Set dir    | WORKDIR / |
7
| CMD         | Default cmd| CMD ["./script.sh"] |

🚀 Example 1: Simple Dockerfiles

Goal:

Use Ubuntu 22.04
Set working directory to root (/)
Create a helloworld.txt file

Dockerfiles:

1
# THIS IS A COMMENT
2
# Use Ubuntu 22.04 as the base operating system of the container
3
FROM ubuntu:22.04
4

5
# Set the working directory to the root of the container
6
WORKDIR /
7

8
# Create helloworld.txt
9
RUN touch helloworld.txt

Build the image:

1
docker build -t helloworld .

1
shohan@kali:~$ docker build -t helloworld .
2
Sending build context to Docker daemon  4.778MB
3
Step 1/3 : FROM ubuntu:22.04
4
22.04: Pulling from library/ubuntu
5
2b55860d4c66: Pull complete
6
Digest: sha256:20fa2d7bb4de7723f542be5923b06c4d704370f0390e4ae9e1c833c8785644c1
7
Status: Downloaded newer image for ubuntu:22.04
8
 ---> 2dc39ba059dc
9
Step 2/3 : WORKDIR /
10
 ---> Running in 64d497097f8a
11
Removing intermediate container 64d497097f8a
12
 ---> d6bd1253fd4e
13
Step 3/3 : RUN touch helloworld.txt
14
 ---> Running in 54e94c9774be
15
Removing intermediate container 54e94c9774be
16
 ---> 4b11fc80fdd5
17
Successfully built 4b11fc80fdd5
18
Successfully tagged helloworld:latest
19
shohan@kali:~$

Check built images:

1
shohan@kali:~$ docker image ls
2
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
3
helloworld   latest    4b11fc80fdd5   2 minutes ago   77.8MB
4
ubuntu       22.04     2dc39ba059dc   10 days ago     77.8MB
5
shohan@kali:~$

🌐 Example 2: Apache Web Server

Goal:

Use Ubuntu 22.04
Install Apache2
Expose port 80
Start Apache at container launch

Dockerfile:

1
# THIS IS A COMMENT
2
FROM ubuntu:22.04
3

4
# Update the APT repository to ensure we get the latest version of apache2
5
RUN apt-get update -y
6

7
# Install apache2
8
RUN apt-get install apache2 -y
9

10
# Tell the container to expose port 80 to allow us to connect to the web server
11
EXPOSE 80
12

13
# Tell the container to run the apache2 service
14
CMD ["apache2ctl", "-D","FOREGROUND"]

Build & Run:

1
docker build -t webserver .
2
docker run -d --name webserver -p 80:80  webserver

Open in browser: http://localhost

⚡ Optimizing Dockerfiles

Why optimize?

Smaller images
Faster builds
Easier to maintain

Techniques:

Install only what you need
Clean caches & temp files
Use minimal base images (e.g., alpine, ubuntu-minimal)
Reduce layers by chaining commands

❌ Before (many layers):

1
FROM ubuntu:latest
2
RUN apt-get update -y
3
RUN apt-get upgrade -y
4
RUN apt-get install apache2 -y
5
RUN apt-get install net-tools -y

✅ After (fewer layers):

1
FROM ubuntu:latest
2
RUN apt-get update -y && \\
3
    apt-get upgrade -y && \\
4
    apt-get install -y apache2 net-tools

Docker Compose#

Common Commands#

1
docker-compose up
2
docker-compose start
3
docker-compose stop
4
docker-compose down
5
docker-compose build

Example `docker-compose.yml`#

1
version: '3.3'
2
services:
3
  web:
4
    build: ./web
5
    networks:
6
      - ecommerce
7
    ports:
8
      - '80:80'
9

10
  database:
11
    image: mysql:latest
12
    networks:
13
      - ecommerce
14
    environment:
15
      - MYSQL_DATABASE=ecommerce
16
      - MYSQL_USERNAME=root
17
      - MYSQL_ROOT_PASSWORD=helloworld
18

19
networks:
20
  ecommerce:

Summary#

Built and managed Docker images using Dockerfiles and docker build
Pulled, listed, and removed images efficiently (docker pull, docker image ls, docker image rm)
Deployed and managed containers with key options for interactivity, detached mode, port mapping, and volume mounting (docker run -it/-d -p -v)
Utilized Docker Compose for orchestrating multi-container applications
Optimized Dockerfiles to minimize image size, reduce layers, and improve build efficiency