From Terraform to Teamwork: My Experience Building AWS Infrastructure for an 8-Microservice DevOps Project 🚀

As part of the DevOps Micro-Internship (DMI), I had the opportunity to work on a real-world team project based on the PetClinic application. The project followed a microservices architecture consisting of 8 services and was designed to simulate how modern DevOps teams build, deploy, and manage cloud-native applications.

In this project, I worked as a Terraform & AWS Infrastructure Engineer, responsible for provisioning and managing cloud infrastructure on AWS. This experience gave me practical exposure to Infrastructure as Code (IaC), Kubernetes, cloud networking, DNS management, CI/CD workflows, and team collaboration.

Project Overview

The goal of the project was to deploy a scalable and production-style PetClinic application using modern DevOps practices.

Our team worked with:

• AWS Cloud

• Terraform

• Amazon EKS (Kubernetes)

• Amazon RDS

• Amazon ECR

• Route53

• AWS IAM

• AWS Secrets Manager

• GitHub Actions

• Prometheus & Grafana

The project followed a collaborative team structure where different members handled infrastructure, Kubernetes deployment, monitoring, CI/CD, testing, and containerization.

My Role in the Project

My primary responsibility was building and managing the AWS infrastructure using Terraform.

Some of my key responsibilities included:

• Provisioning AWS resources using Terraform

• Working with VPC, IAM, EKS, RDS, ECR, Route53, and Secrets Manager

• Managing infrastructure changes through GitHub Pull Requests

• Participating in Terraform validation and troubleshooting

• Configuring Route53 DNS integration

• Supporting Kubernetes infrastructure requirements

• Resolving infrastructure-related deployment issues

One of the most rewarding parts of this project was seeing infrastructure come together from code and eventually support the deployment of multiple microservices.

Infrastructure Architecture

The infrastructure architecture followed a cloud-native design:

User
  ↓
Route53
  ↓
Load Balancer
  ↓
Amazon EKS
  ↓
8 Microservices
  ↓
Amazon RDS

Terraform was used to provision and manage all infrastructure resources. By using Infrastructure as Code, we were able to maintain consistency, automate deployments, and collaborate more effectively as a team.

Route53 and DNS Configuration

One of the major tasks I worked on was DNS management and Route53 integration.

We purchased and configured the domain:

petcliniccenter.online

The process involved:

• Creating Route53 hosted zones

• Configuring nameservers

• Updating GoDaddy DNS settings

• Verifying DNS propagation

• Troubleshooting hosted zone configurations

This was my first hands-on experience managing a complete DNS setup in a cloud environment, and it helped me understand how domain routing works in production systems.

Infrastructure Challenges I Solved

Every project comes with challenges, and this one was no different.

1. Route53 DNS Integration

Initially, we faced challenges related to hosted zone configuration and nameserver management. After validating DNS propagation and verifying Route53 configuration, we successfully integrated the domain with AWS infrastructure.

2. Terraform Validation & Security Checks

Our infrastructure changes were validated through Pull Requests and automated security scans.

While working on infrastructure updates, I had to troubleshoot Terraform validation issues and Checkov security scan failures. This helped me understand infrastructure compliance and security best practices.

3. Kubernetes Monitoring Issue

One of the most interesting problems we encountered involved monitoring components.

Prometheus and Grafana Persistent Volume Claims (PVCs) remained stuck in a Pending state.

After investigating the issue, we identified that the AWS EBS CSI Driver was missing from the EKS cluster.

To solve this:

• I implemented Terraform configuration for the AWS EBS CSI Driver

• Configured the required IAM role

• Added the EKS addon configuration

• Validated the Terraform plan through Pull Requests

This enabled dynamic storage provisioning and helped resolve the monitoring deployment issue.

GitHub Workflow and Team Collaboration

The project followed a professional Git workflow.

The process included:

1. Creating feature branches

2. Implementing infrastructure changes

3. Raising Pull Requests

4. Running Terraform validation and security checks

5. Reviewing changes with teammates

6. Merging approved code into the development branch

This workflow helped me understand how real DevOps teams collaborate on infrastructure projects.

Beyond technical skills, I learned how important communication and teamwork are in large projects. Coordinating with teammates, reviewing changes, and discussing solutions were just as important as writing Terraform code.

What Went Well

Several aspects of the project were particularly successful:

• Strong team collaboration

• Infrastructure automation using Terraform

• Successful Route53 integration

• Real-world AWS experience

• Practical exposure to Kubernetes and monitoring

• CI/CD validation through GitHub Actions

Most importantly, the project provided hands-on experience that cannot be gained from tutorials alone.

What I Would Do Differently

If I were to start the project again, I would:

• Create detailed documentation from the beginning

• Add architecture diagrams earlier in the project

• Automate additional infrastructure validations

• Implement monitoring and alerting sooner

• Improve deployment visibility across environments

These improvements would make troubleshooting and onboarding much easier.

Key Takeaways

This project significantly improved my understanding of:

• Terraform and Infrastructure as Code

• AWS cloud services

• Amazon EKS and Kubernetes

• Route53 and DNS management

• Infrastructure security and IAM

• GitHub-based DevOps workflows

• Team collaboration in engineering projects

More importantly, it taught me how cloud infrastructure is planned, deployed, validated, and maintained in real-world environments.

Conclusion

Working as a Terraform & AWS Infrastructure Engineer on the PetClinic DevOps Project was one of the most valuable learning experiences in my DevOps journey.

The project allowed me to move beyond theory and gain hands-on experience with cloud infrastructure, Kubernetes, Terraform, and collaborative software delivery practices.

I not only improved my technical skills but also developed stronger communication, teamwork, and problem-solving abilities while working with an amazing team.

This project was completed as part of the DevOps Micro-Internship (DMI). If you're interested in gaining hands-on experience with DevOps, cloud infrastructure, and real-world team projects, I highly recommend exploring the DMI program and checking out the Cohort 3 registration.

Thank you for reading! 🚀