Project Case Study

Containerization Project – Beelink + Docker + Nginx

I used a dedicated Beelink mini PC to learn containerization in a practical, hands-on way. What began as a simple Nginx deployment developed into building my own custom Docker image, serving a custom HTML page through Nginx, and learning the real workflow of building, stopping, removing, and recreating containers.

Back to Projects Get in Touch

Objective

Build a first real containerized web deployment on dedicated hardware and understand the full workflow instead of just launching a premade image once. The goal was to move from theory into practice: create the project files, write a Dockerfile, build an image, run the container, map the port correctly, and verify that the hosted page worked after rebuilding and recreating the container.

Core stack

  • Beelink mini PC
  • Windows 11 host operating system
  • Docker Desktop with WSL2 backend
  • Nginx base image
  • Custom Dockerfile
  • Custom index.html served through the container
  • Browser based localhost testing

What I built

  • Created a dedicated project folder for the containerized site.
  • Built a simple custom HTML page to be served through Nginx.
  • Created a Dockerfile to define how the image should be built.
  • Built a custom image instead of relying only on the default Nginx image as is.
  • Mapped host port 8080 to container port 80.
  • Stopped, removed, and recreated the container to apply changes properly.
  • Verified the page was loading successfully in the browser from the rebuilt container.

Issues I had to solve

This project became useful because it forced me to troubleshoot real mistakes rather than just copy commands. I ran into several command line and build issues that helped me understand how Docker actually works.

  • Learned that docker run requires an image name at the end of the command.
  • Learned that docker stop requires an existing container name or ID.
  • Hit a build failure because the project folder did not yet contain a Dockerfile.
  • Corrected the Dockerfile after initially using the wrong nginx file path.
  • Learned that a successful image build does not automatically update an already running container.
  • Reinforced the difference between an image and a container through rebuilding and rerunning the project.

Commands I used

  • docker build -t beelink-nginx-site .
  • docker stop beelink-nginx
  • docker rm beelink-nginx
  • docker run -d -p 8080:80 --name beelink-nginx beelink-nginx-site
  • docker ps

Why this project matters

This project shows more than just “I installed Docker.” It demonstrates that I can work through the actual container workflow: writing build instructions, understanding image creation, correcting mistakes, recreating services properly, and verifying that the final deployment works in the browser. It also gives me a strong base for moving into Docker Compose, multi container projects, and more self hosted infrastructure later.

Build Breakdown

How I moved from a basic container to a custom image

I kept the project small on purpose so I could understand each layer clearly instead of hiding the learning behind too much complexity.

Step 1

Project setup

Created a dedicated container project folder on the Beelink and placed my custom index.html inside it as the content I wanted Nginx to serve.

Step 2

Dockerfile creation

Added a Dockerfile that used the official Nginx image as the base and copied my custom HTML file into the correct nginx web root inside the image.

Step 3

Image build and container recreation

Built the image with docker build, then stopped and removed the old container so I could recreate it from the newly built image instead of assuming the running container updated itself.

Step 4

Validation and troubleshooting

Checked container status with docker ps, verified port mapping, and confirmed the page loaded correctly in the browser on localhost:8080.

Evidence

Proof snapshots

These images can show the host machine, Docker environment, successful build, running container, and the custom page loading in the browser.

Beelink mini PC used as the container host
Dedicated Beelink mini PC used as the host machine for the project.
Docker Desktop running on Windows 11 with the environment active
Docker Desktop active on the host system with the container environment running.
Terminal output showing the rebuilt container and mapped port
Terminal proof showing the running container and mapped host to container port.
Browser displaying the custom page served through the container
Browser based proof that the custom page was being served from the rebuilt Nginx container.

What I learned

Key takeaways from this stage

Images and containers are different

Building an image and running a container are separate steps. Rebuilding does not automatically replace what is already running.

Small mistakes matter

Missing a Dockerfile, forgetting the image name in docker run, or using the wrong nginx path can completely break the build or deployment.

Repetition builds confidence

Repeating the cycle of build, stop, remove, rerun, and verify made the Docker workflow much more concrete.

Next Stage

Where this project should go next

Docker Compose setup

Move the project into a Compose based workflow so the build and deployment steps are cleaner, easier to repeat, and ready for expansion.

Custom CSS in container

Expand the hosted site beyond a single HTML file by serving a styled multi file page from the container and rebuilding it as the project grows.

Multi container growth

Later expand into a reverse proxy, persistence, or additional services to turn this into a more complete self hosted infrastructure project.