From Docker Demos to EC2 Deployments

Introduction

Hello there! 👋 The past week marked Week 6 of my DevOps journey, and it was the beginning of something more hands-on and real-world focused. After completing most of the fundamental concepts, I was about to start learning Docker and Kubernetes, but a YouTube video changed the course a bit.

It is recommended learning cloud computing first, then explore containerization and deployment tools in the context of the cloud. That clicked for me. So, this week, I started exploring containerization concepts, got familiar with microservices architecture, and kicked off with AWS Fundamentals. Here's how the week unfolded:

Understanding Containerization and Docker

I began with a simple question: "What is a container?"

Containers are lightweight, portable environments that package an application and all its dependencies together.

Advantages of Containers:

• Consistency across development, testing, and production.

• Portability across platforms (Docker, Podman).

• Scalability for service expansion and contraction.

• Efficiency compared to VMs.

The most widely used tool for containerization, as we all know, is Docker. So, I learned about Docker, a platform for developing, shipping, and running applications in containers.
I understood the flow for creating a Docker container -

• Write a Dockerfile with commands like FROM, RUN, CMD, etc.

• Build a Docker Image from the Dockerfile.

• Use that image to run a Docker Container.

Docker Architecture

Docker follows a Client-Server model:

• Docker Client → CLI or GUI for user interaction

• Docker Daemon → Manages containers in the background

• Docker Registry → Stores Docker images (e.g., DockerHub)

Scenario: Nginx Web Server in Docker

I noted a simple scenario for reference: running an Nginx Web Server in Docker. It involves the following steps -

1. Install Docker on your system.

2. Pull the Nginx image** from DockerHub

    docker pull nginx
    docker run -d -p 8080:80 --name my-nginx nginx
   

   Visit http://localhost:8080 to see it in action.

3. Container Management

    docker ps
    docker stop my-nginx
    docker rm my-nginx
   

To get a hold of how Docker containers are created and run inside a VM, I set up Docker inside a VM:

1. Create a VM using Vagrant and configure it using Vagrantfile.

2. Run the VM using vagrant up, log in to it using SSH and switch to the root user.

3. Basic Commands

    systemctl status docker
    docker run hello-world
   
    docker images
    docker ps
    docker ps -a
   

4. Run a container

5. Building an image

    mkdir images
    cd images/
    vim Dockerfile
   

    FROM ubuntu:latest AS BUILD_IMAGE
    RUN apt update && apt install wget unzip -y
    RUN wget https://www.tooplate.com/zip-templates/2128_tween_agency.zip
    RUN unzip 2128_tween_agency.zip && cd 2128_tween_agency && tar -czf tween.tgz * && mv tween.tgz /root/tween.tgz
   
    FROM ubuntu:latest
    LABEL "project"="Marketing"
    ENV DEBIAN_FRONTEND=noninteractive
   
    RUN apt update && apt install apache2 git wget -y
    COPY --from=BUILD_IMAGE /root/tween.tgz /var/www/html/
    RUN cd /var/www/html/ && tar xzf tween.tgz
    CMD ["/usr/sbin/apache2ctl", "-D", "FOREGROUND"]
    VOLUME /var/log/apache2
    WORKDIR /var/www/html/
    EXPOSE 80
   

    docker build -t tesimg .
    docker images
    # Run container from the Image
    docker run -P -d tesimg
    docker ps
   
    ip addr show
    docker ps
   

6. Go to the browser and enter IP_Addr:HostPort

7. Cleaning up containers and images. This sample Dockerfile I pulled from the internet to test the creation of a Docker container.

Learning Microservices Architecture

I also learned about Microservices - what Microservices architecture is, how it is different from the previously used Monolithic architecture. The ideology of Microservices is breaking down a monolith into several smaller, self-contained services, each responsible for a specific business functionality. This introduces isolation, loose coupling and flexibility in choosing technology.

Communication Methods:

• Synchronous (APIs)

• Asynchronous (Message brokers like RabbitMQ)

• Service Mesh

I also explored:

• Monorepo vs Polyrepo code strategies

Although I stayed on a theoretical level for now, I plan to go deeper with projects soon.

Getting Started with AWS

Since cloud was the next big milestone, I turned to AWS Fundamentals. Thankfully, I had some theoretical exposure from a course I took last semester, which helped me understand things quickly.

Important AWS Services for DevOps:

➡️ Compute: EC2, Lambda, Beanstalk

➡️ Storage: S3, EBS

➡️ Identity: IAM, KMS

➡️ Monitoring: CloudWatch, CloudTrail, X-Ray

➡️ Networking: VPC, ELB, Route53

➡️ Containers: ECS, EKS, ECR

➡️ CI/CD: CodeCommit, CodeBuild, CodeDeploy, CodePipeline

Deep Dive into EC2 Instances

I created multiple EC2 instances and:

• Played with Security Groups, Key Pairs, and Elastic IPs

• Hosted a static HTML page on an Ubuntu server using Apache2

  

AWS CLI:

Next, I learned about AWS CLI, which lets users interact with AWS services from the terminal. It also helps in automation, scripting, and managing resources via the terminal.

• Installed CLI on my machine

• Created an IAM user and configured it with Access Keys

• Practiced launching instances, creating key pairs, and security groups via CLI

EBS Volumes & Snapshots

Each EC2 instance comes with a block storage volume (EBS). I learned:

• Types of EBS volumes

• Creating, attaching, and configuring them

• Creating partitions, mounting and unmounting them persistently

• Snapshots for backup and restore

Load Balancing with ELB

I created multiple EC2 instances using:

• AMIs and Launch Templates

• Hosted a basic HTML page on each

• Created Target Groups and an Application Load Balancer (ALB)

• Configured listeners and verified load distribution

Monitoring with CloudWatch & SNS Alarms

I used CloudWatch to monitor CPU usage on an EC2 instance and:

• Created SNS Topic and Subscription

• Configured Alarms to notify me via email or SMS

Faced some issues with email alerts, but SMS notifications worked as expected.

Resources I Used

1. Docker Documentation

2. Microservices | Techworld with Nana

3. AWS | Cloud Computing

4. AWS CLI | Command References

Challenges I Faced

1️⃣ Microservices Mini Project Not Working

• After learning the basics of microservices, I tried building a small demo project using a sample docker-compose.yml file I found online. My goal was to spin up a few lightweight containers as independent services inside a VM. However, the setup consistently failed to build and run. Even after debugging the Dockerfile, checking for dependency issues, and validating port configurations, I couldn’t get the containers running inside the VM. I eventually paused the project and plan to revisit it later with a more hands-on guide.

2️⃣ Security Group Misconfiguration for SSH

• While working with EC2 instances, I created a new instance and configured the inbound rules via the security group to allow SSH access. However, every time I tried to log in using my key pair, I received a "Permission denied" error. I temporarily opened the rule to allow SSH from all IPs (0.0.0.0/0), and it worked. But that’s not a secure long-term solution. I terminated the instance, recreated it with the exact same rule settings and, surprisingly, this time, SSH worked perfectly. Still unsure what caused the initial misbehavior.

3️⃣ CloudWatch Alarm Emails Not Delivering

• I wanted to test CPU utilization monitoring and email alerts using AWS CloudWatch. After configuring everything, the alarm triggered correctly, but I wasn’t receiving emails. The SNS subscription for my email kept showing as "Pending Confirmation" despite confirming multiple times. After researching, I suspected my email address might be on AWS SES's suppression list. As a workaround, I created a new subscription using the SMS protocol and tested it using my mobile number - which worked flawlessly. Still need to confirm what happened to my email with AWS support, or try a different email next time.

What's Next?

Before exams hit, I plan to:

• Learn EFS, Auto Scaling Groups, and S3

• Revise previously covered concepts

Let’s Connect!

🔗 My LinkedIn

🔗 My GitHub

If you have any helpful resources or better ways to solve the challenges I faced, or just want to chat about DevOps, drop a comment!

Have a wonderful day!