Docker Journey: From Zero to Hero

Introduction

Today, I embarked on a Docker journey, starting from cloning a repository to running multi-stage builds. The experience was full of learning and challenges. Here's a detailed account of my day, the commands I used, and the lessons learned.

Cloning the Repository

The first step was to clone the Docker-Zero-to-Hero repository from GitHub. This repository is a great starting point for anyone looking to get hands-on experience with Docker.

git clone git@github.com:aut0b0ts/Docker-Zero-to-Hero.git
cd Docker-Zero-to-Hero/examples
ls

Building and Running Docker Images

I began with building a simple Docker image and running a container from it. Here are the steps I followed:

Logging into Docker:
```
 docker login
```

Building the Docker Image:

 docker build -t kaka750/test01 first-docker-file

Listing Docker Images:
```
 docker images
```
Running the Docker Container:
```
 docker run -it kaka750/test01
```
Pushing the Docker Image to Docker Hub:
```
 docker push kaka750/test01
```

Challenges Faced

During this phase, I encountered some challenges:

Incorrect Commands: I mistakenly used incorrect commands such as docker images head -2 and docker images -5 head. The correct way to list images is just docker images.
Typos: There was a typo in the command docker push kaka750/text01 which should have been docker push kaka750/test01.

Building a Python Web App Docker Image

Next, I worked on a Python web application:

Navigating to the App Directory:
```
 cd python-web-app
 vi Dockerfile
```

Building the Docker Image:

 docker build -t kaka750/test02 python-web-app

Running the Container:

 docker run -p 8080:3000 kaka750/test02

Inspecting the Container:
```
 docker inspect 093fa6c7d75e
```
Fixing Issues: There were several attempts to build and run the container, indicating some trial and error. Adjustments in the Dockerfile were necessary to get the application running correctly.

Learning Points

Dockerfile Syntax: Proper understanding of Dockerfile syntax and directives is crucial. Mistakes in the Dockerfile can lead to multiple build failures.
Port Mapping: Correctly mapping ports (-p 8080:3000) is essential to access the running application.

Exploring Multi-Stage Builds

Finally, I explored multi-stage builds with a Go application:

Navigating to the Directory:

 cd golang-multi-stage-docker-build/dockerfile-without-multistage
 vi Dockerfile

Building and Running the Docker Image:

 docker build -t withoutmulti/staging .
 docker run withoutstaging

Switching to Multi-Stage Build:

 docker build -t withstaging .
 docker run withstaging

Challenges and Learning

Multi-Stage Builds: Understanding the benefits of multi-stage builds in reducing image size and improving build efficiency.
Debugging Builds: Fixing issues related to build context and dependencies in the Dockerfile.

Conclusion

Today's journey with Docker was enlightening. From simple builds to complex multi-stage ones, I faced several challenges but learned a lot in the process. Docker is a powerful tool for containerization, and with each step, I am becoming more proficient in using it effectively.

Feel free to reach out if you have any questions or need further assistance in your Docker journey. Happy containerizing!

Docker Journey