🗓️ Docker Learning Journal

Lotanna — Mon, 10 Nov 2025 21:33:58 +0000

🧠 Week 1 Overview

Last week, I built a solid foundation in Docker. I got to understand containers and images, explore networks and persistent storage.

🧩 Key Concepts Covered

🐳 1. Docker Basics

I installed Docker for Mac and learned about the difference between images and containers:

Images: Templates used to create containers.

Containers: Running instances of images. They are isolated environments that include an app and all its dependencies.

💡 I learnt the hard way that on Mac and Windows, Docker Desktop must be running for Docker commands, or managing resources to work. Docker Desktop provides the background service (Docker Engine) that powers the CLI.

🔧 2. Core Commands

The table below contains some of the essential Docker commands I learnt to manage containers and images:

Command	Description
`docker ps`	Lists running containers
`docker ps -a`	Lists all containers(running and stopped)
`docker images`	Lists available images
`docker start <container>`	Starts a stopped container
`docker attach <container>`	Attaches to a running container
`docker stop <container>`	Stops one or more containers

🏗️ 3. Building and Running Images

I learned to create images using Dockerfiles, with key instructions like:

FROM → sets the base image

COPY → copies files from the host into the image

RUN → executes commands during the image build process (e.g., installing dependencies or packages)

CMD → defines the command to run when the container starts

I explored how docker build works and how to tag images.
I also used docker run to create containers from images, and the -d flag to run them in detached mode.

Additionally, I learned more about tags. Docker uses tags to identify different versions of the same image.
If I want to replace or create a new tag, I can use:

docker tag image1:latest image1:version1

This lets me manage image versions more clearly, making it easier to track updates or maintain stable releases.

I also learned how to push custom images to Docker Hub.
To do this, I first log in using:

docker login

Then, I had to tag my image correctly with my Docker Hub username before pushing, because Docker would deny the request. For example:

docker tag image1:version1 tannababy/image1:version1

Finally, I could push the image to Docker Hub:

docker push tannababy/image1:version1

If no tag is specified, Docker automatically assigns the default tag latest to the most recently built image.

🧱 4. Creating Images from Containers

I discovered that you can also create images from existing containers using:

docker commit <container-name>

The --change flag allows modifying commands that the new image executes first.

🌐 5. Networking

I learned that docker network is used for managing container communication. By default, containers run in a bridge network.

Commands explored:

ip addr show → displays network interfaces
arp-scan --interface=eth0 --localnet → shows all containers on the network
ping <IP> → tests connectivity
curl → interacts with web apps or APIs

The three main network types are:

Type	Description
bridge	Default; containers communicate via internal bridge
host	Shares the host network, no isolation
none	No network access

Other concepts learned:

Detach from containers using Ctrl + P, then Ctrl + Q
Bind container ports to host ports using -P tag
Specify container networks using --network <network-name>

💾 6. Persistent Storage

Docker handles data persistence using 3 storage types:

Bind Mounts: link host directories to containers

They are good for development. Changes made on the host are instantly reflected inside the container without needing to rebuild the image.
You must know the exact path on the host.

Volumes: managed by Docker, ideal for production and sharing data between containers.

Docker decides where the data lives, so you don’t need to specify host paths.
Supports external storage and different drivers (more on that later).

tmpfs: in-memory temporary storage in RAM, useful for sensitive or short-lived data that shouldn’t persist on disk.

To attach storage to a container, I learned about the --mount flag, which provides a consistent way to define different storage types:

docker run --mount type=bind,source=/path/on/host,target=/path/in/container <image-name>

type= specifies the storage type (bind, volume, or tmpfs)
source= defines the host directory or volume name (not needed for tmpfs)
target= defines the directory path inside the container

This syntax made it clearer how Docker connects external data to running containers and how flexible storage setups can be depending on the use case.

⚙️ Skills Progressed

By the end of Week 1, I’ve learned to:
✅ Understand Docker’s architecture and use cases.
✅ Build and run images using Dockerfiles.
✅ Manage container lifecycle (start, stop, inspect, delete).
✅ Use networking features to connect containers.
✅ Set up persistent storage strategies.

A key takeaway this week was understanding that Docker helps ensure applications run consistently across different environments.

I can now recognise why Dockerfiles are preferred, they make images version-controlled, shareable, and automatable.

DEV Community: Lotanna