I set out to strengthen my DevOps fundamentals by building a structured 6 day hands on project series.I wanted to understand each layer before combining everything into a working remote deployment.
By the end of the week, I had automated the provisioning of a remote Ubuntu EC2 instance, containerized a Flask application, configured Nginx as a reverse proxy, and deployed everything through a single script.
Environment
- Ubuntu (local and EC2)
- Bash
- Docker
- Docker Compose
- Nginx
- AWS EC2
- SSH and SCP
Day 1: Linux Essentials
I revisited core Linux concepts including:
- File permissions
- Services and systemctl
- Log inspection
- Basic system commands
I wrote a Bash script to check disk usage, memory usage, and uptime. This forced me to understand what the commands were actually doing instead of just running them.
This step reinforced comfort with the terminal, which is non negotiable in DevOps work.
Day 2: Bash Scripting
I focused on:
- Variables
- Loops
- Conditionals
- Logging
- Basic error handling
Using these, I built a script that installs Docker, Git, and Nginx automatically on an Ubuntu server or container.
Instead of manually installing packages every time, I could now provision a machine with one script. This was my first clear shift from manual work to automation thinking.
Day 3: Docker Fundamentals
I containerized a simple Flask application.
This included:
- Writing a Dockerfile
- Building the image
- Running the container locally
This step clarified how containers package applications and how runtime behavior differs from running an app directly on the host.
Day 4: Docker Compose and Nginx
I extended the setup into a multi container environment. I defined two services in Docker Compose for Flask and Nginx, allowing the containers to communicate over an internal network. Requests were routed through Nginx to Flask and health checks validated service availability.
Seeing traffic flow through the reverse proxy made the networking piece much clearer. It also demonstrated how containers communicate internally within a defined network.
Day 5: SSH Automation
I automated remote script execution using SCP and SSH on EC2 instances.
This involved:
- Securely connecting to a remote Ubuntu server
- Transferring scripts via SCP
- Executing scripts remotely
- Managing permissions and environment variables
This step tied local automation to real infrastructure. It moved the project from theory to practical remote execution.
Day 6: Full Deployment
I combined everything into a single script that:
- Connects to a remote EC2 Ubuntu instance
- Installs Docker and Git
- Builds the Flask container
- Configures Nginx as a reverse proxy
After execution, the application was accessible through the instance’s public IP address.
That moment validated the full workflow from provisioning to deployment.
This project was intentionally foundational. The goal was not complexity, but correctness and understanding of how the pieces connect.
Repository
All scripts, Docker configurations, and deployment steps are available in my GitHub repository here https://github.com/amilola/30Days-Devops/tree/main/Phase1
Top comments (0)