<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gbemi Adekunle on Medium]]></title>
        <description><![CDATA[Stories by Gbemi Adekunle on Medium]]></description>
        <link>https://medium.com/@oluwagbemilekeadekunle22?source=rss-149f43173d58------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Gbemi Adekunle on Medium</title>
            <link>https://medium.com/@oluwagbemilekeadekunle22?source=rss-149f43173d58------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:16:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@oluwagbemilekeadekunle22/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building an AWS Observability and Incident Response Workflow with Terraform, Ansible, CloudWatch…]]></title>
            <link>https://medium.com/@oluwagbemilekeadekunle22/building-an-aws-observability-and-incident-response-workflow-with-terraform-ansible-cloudwatch-f00728a4780d?source=rss-149f43173d58------2</link>
            <guid isPermaLink="false">https://medium.com/p/f00728a4780d</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloudwatch]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-system-manager]]></category>
            <category><![CDATA[ansible]]></category>
            <dc:creator><![CDATA[Gbemi Adekunle]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 00:58:59 GMT</pubDate>
            <atom:updated>2026-08-24T00:58:59.158Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building an AWS Observability and Incident Response Workflow with Terraform, Ansible, CloudWatch, and Python</h3><p>Deploying infrastructure is only part of running workloads in AWS. Once a workload is running, another question becomes just as important: How do you know when something goes wrong, and how do you verify that your monitoring system can actually detect it?</p><p>I built this project to create an AWS environment where infrastructure provisioning, configuration management, observability, incident simulation, detection, and recovery could be tested as one complete workflow.</p><p>Rather than simply configuring a CloudWatch alarm and assuming it worked, I intentionally generated high CPU utilization on an EC2 workload and observed how the monitoring system responded.</p><h3>Architecture</h3><p>The environment combines Terraform, Ansible, AWS Systems Manager, Amazon EC2, Amazon CloudWatch, the CloudWatch Agent, and Python.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s3ToAuwIk11_uj6AgvHj6g.png" /><figcaption><em>AWS Observability and Incident Response Architecture</em></figcaption></figure><h3>Testing the Monitoring</h3><p>Creating a CloudWatch alarm was not enough for me. I wanted to see what would happen during an actual threshold breach.</p><p>I configured a CloudWatch alarm to monitor EC2 CPU utilization and trigger when CPU usage exceeded 60 percent.</p><p>I then generated controlled CPU load on the EC2 instance to simulate an incident.</p><p>As CPU utilization increased, CloudWatch detected the threshold breach and changed the alarm from OK to ALARM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7596Qi2evSz9KjWyFBfjAQ.png" /><figcaption>CloudWatch detecting CPU utilization above the configured threshold</figcaption></figure><p>After confirming the incident had been detected, I stopped the CPU workload.</p><p>CPU utilization decreased and CloudWatch automatically returned the alarm from ALARM to OK.</p><p>This allowed me to validate the complete monitoring lifecycle from normal operation to incident detection and recovery.</p><h3>Security and Automation</h3><p>I also wanted the environment to follow practical security and automation principles.</p><p>Terraform handled repeatable infrastructure provisioning, while Ansible handled configuration management. AWS Systems Manager provided remote access to the workload without relying on direct SSH administration.</p><p>IAM roles were used for AWS permissions, credentials were not hard coded into the Terraform configuration, and Terraform state and local variable files were excluded from Git.</p><h3>Cleaning Up</h3><p>Once testing was complete, I used Terraform to destroy the environment.</p><p>Terraform successfully removed 14 AWS resources.</p><p>This was an important final step because temporary cloud infrastructure should not continue running and generating costs after it is no longer needed.</p><h3>Lessons from the Project</h3><p>The biggest lesson from this project was simple.</p><p>Monitoring should not just be configured. It should be tested.</p><p>Having a CloudWatch alarm does not automatically mean it will behave the way you expect during an incident.</p><p>By deliberately creating a controlled CPU incident, I was able to see the entire process work in practice. The workload became unhealthy, CloudWatch detected it, the alarm triggered, the workload recovered, and the alarm returned to normal.</p><p>The project brought together infrastructure provisioning, configuration management, observability, security, incident testing, recovery, and cost control in one workflow.</p><p>Technologies used: AWS EC2, VPC, IAM, Systems Manager, CloudWatch, CloudWatch Agent, Terraform, Ansible, Python, Git, and GitHub.</p><h3>Source Code</h3><p>The complete project is available on GitHub:</p><p><a href="https://github.com/Gbemi04/aws-observability-incident-response">Gbemi04/aws-observability-incident-response: Production-focused AWS observability and automated incident response platform using CloudWatch, Grafana, Prometheus, Terraform, Ansible and Python.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f00728a4780d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automating EC2 Infrastructure Standardization at Scale with Terraform and Python]]></title>
            <link>https://medium.com/@oluwagbemilekeadekunle22/automating-ec2-infrastructure-standardization-at-scale-with-terraform-and-python-aebe671ce076?source=rss-149f43173d58------2</link>
            <guid isPermaLink="false">https://medium.com/p/aebe671ce076</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Gbemi Adekunle]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 02:54:12 GMT</pubDate>
            <atom:updated>2026-08-18T02:54:12.001Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>Managing a few EC2 instances manually is manageable. Doing the same change across a larger environment is where automation becomes important.</p><p>For this project, I needed to standardize 15 Amazon EC2 instances from t3.micro to t3.small. Instead of resizing them individually through the AWS console, I built an automated solution using Terraform, Python, Boto3, IAM, and AWS Systems Manager.</p><p>The goal was simple: make the change repeatable, controlled, and easy to validate.</p><h3>The Approach</h3><p>I divided the solution into two parts. Terraform handled infrastructure provisioning, while Python and Boto3 handled the actual EC2 standardization.</p><p>Rather than hardcoding instance IDs, the Python automation used AWS tags to discover only the instances assigned to the project.</p><h3>Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*9uvT7tpwz_q1Lc7J0hmGog.png" /><figcaption><em>EC2 Infrastructure Standardization architecture showing the Terraform provisioning and Python/Boto3 automation workflow.</em></figcaption></figure><h3>The Automation</h3><p>The Python workflow was intentionally straightforward:</p><p><strong>Discover → Validate → Report → Stop → Resize → Start → Verify → Report</strong></p><p>Each instance was processed individually. The script stopped the instance, changed it from t3.micro to t3.small, restarted it, and verified that it returned to a running state before moving to the next one.</p><h3>Results</h3><p>The automation successfully standardized the EC2 instances from t3.micro to t3.small while keeping the process controlled and repeatable.</p><p>Instead of manually changing each instance through the AWS console, the workflow handled discovery, validation, resizing, verification, and reporting automatically.</p><p>Terraform and Python served different roles within the solution. Terraform defined and provisioned the infrastructure, while Python and Boto3 handled the operational logic required to discover, resize, validate, and report on the EC2 instances. Terraform defines the infrastructure, while Python and Boto3 handle operational changes that need more logic and control.</p><h3>Engineering Considerations</h3><p>This project reinforced the importance of treating infrastructure changes as controlled operations rather than isolated manual tasks.</p><p>Combining Terraform with Python and Boto3 provided a clear separation between infrastructure provisioning and operational automation. Validation, reporting, and rollback were also built into the workflow to reduce risk and maintain visibility throughout the change.</p><h3>Conclusion</h3><p>Standardizing multiple EC2 instances manually would be repetitive, difficult to audit, and prone to human error.</p><p>By combining Terraform, Python, Boto3, IAM, and AWS Systems Manager, the process was converted into a repeatable workflow that could discover targeted instances, validate their state, perform the required changes, verify the results, and support rollback when necessary.</p><p>The result is a practical approach to EC2 infrastructure standardization that can be adapted for larger AWS environments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aebe671ce076" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an Enterprise CI/CD Pipeline for a Full-Stack Application on AWS Using Jenkins, Terraform…]]></title>
            <link>https://medium.com/@oluwagbemilekeadekunle22/building-an-enterprise-ci-cd-pipeline-for-a-full-stack-application-on-aws-using-jenkins-terraform-32c35bd6bf45?source=rss-149f43173d58------2</link>
            <guid isPermaLink="false">https://medium.com/p/32c35bd6bf45</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Gbemi Adekunle]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 03:17:31 GMT</pubDate>
            <atom:updated>2026-08-10T03:17:31.279Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building an Enterprise CI/CD Pipeline for a Full-Stack Application on AWS Using Jenkins, Terraform, Docker, ECS Fargate &amp; CloudWatch</h3><h4>Automating the deployment of a React and Node.js application with Infrastructure as Code, containerization, continuous delivery, and cloud monitoring.</h4><h3>Introduction</h3><p>Modern software teams need reliable deployment pipelines that are secure, repeatable, and easy to maintain. Manual deployments often lead to configuration drift, inconsistent releases, and increased operational risk.</p><p>In this project, I designed and implemented a complete CI/CD platform for a containerized full-stack application running on AWS. The solution combines Jenkins, Terraform, Docker, Amazon ECS Fargate, Amazon ECR, Application Load Balancer, CloudWatch, and SNS to automate application delivery while following Infrastructure as Code and AWS security best practices.</p><p>The goal was not simply to deploy an application, but to build an enterprise-style deployment platform that could be reused for future projects.</p><h3>Business Problem</h3><p>The application had already been developed, but the deployment process remained manual.</p><p>Some of the common challenges included:</p><ul><li>Manual deployments</li><li>Inconsistent environments</li><li>Limited deployment visibility</li><li>Lack of monitoring</li><li>No centralized container registry</li><li>Difficult infrastructure management</li></ul><p>A fully automated deployment pipeline was required to improve reliability, reduce manual effort, and support future application releases.</p><h3>Solution Overview</h3><p>The solution automates the entire deployment process.</p><p>The workflow follows these stages:</p><p>Developer → GitHub → Jenkins → Docker Build → Amazon ECR → Amazon ECS Fargate → Application Load Balancer → End Users</p><p>Infrastructure provisioning and cleanup are fully managed using Terraform, while Amazon CloudWatch monitors the deployed environment and Amazon SNS sends alert notifications when required.</p><p>The following architecture illustrates the complete deployment workflow and how the AWS services interact throughout the CI/CD pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cLcQ346BIpkH_q4hxZPX7Q.png" /><figcaption>Figure 1. Enterprise CI/CD architecture using Jenkins, Docker, Terraform, Amazon ECS Fargate, Amazon ECR, CloudWatch, and SNS.</figcaption></figure><h3>Technology Stack</h3><p><strong>Cloud Platform</strong></p><ul><li>AWS</li></ul><p><strong>Infrastructure as Code</strong></p><ul><li>Terraform</li></ul><p><strong>CI/CD</strong></p><ul><li>Jenkins</li></ul><p><strong>Containers</strong></p><ul><li>Docker</li></ul><p><strong>Container Registry</strong></p><ul><li>Amazon ECR</li></ul><p><strong>Container Orchestration</strong></p><ul><li>Amazon ECS Fargate</li></ul><p><strong>Load Balancing</strong></p><ul><li>Application Load Balancer</li></ul><p><strong>Monitoring</strong></p><ul><li>Amazon CloudWatch</li></ul><p><strong>Notifications</strong></p><ul><li>Amazon SNS</li></ul><p><strong>Networking</strong></p><ul><li>Amazon VPC</li></ul><p><strong>Identity &amp; Access Management</strong></p><ul><li>AWS IAM</li></ul><p><strong>Frontend</strong></p><ul><li>React</li></ul><p><strong>Backend</strong></p><ul><li>Node.js / Express</li></ul><p>This will look much cleaner.</p><h3>Infrastructure Design</h3><p>Terraform was used to provision all AWS resources, making the deployment consistent and repeatable.</p><p>The infrastructure included:</p><ul><li>Amazon VPC</li><li>Public and Private Subnets</li><li>Internet Gateway</li><li>Route Tables</li><li>Security Groups</li><li>Jenkins EC2 Instance</li><li>IAM Roles</li><li>Amazon ECR</li><li>Amazon ECS Cluster</li><li>ECS Services</li><li>Application Load Balancer</li><li>CloudWatch</li><li>SNS</li></ul><p>Using Infrastructure as Code allowed the entire environment to be recreated or destroyed with a single Terraform command.</p><h3>Jenkins CI/CD Pipeline</h3><p>Jenkins automates the complete software delivery process.</p><p>The pipeline performs the following stages:</p><ol><li>Checkout source code</li><li>Verify AWS identity</li><li>Build Docker images</li><li>Push images to Amazon ECR</li><li>Manual deployment approval</li><li>Deploy to Amazon ECS Fargate</li></ol><p>Using a manual approval stage simulates the controlled release process commonly used in production environments.</p><h3>Security Considerations</h3><p>Security was incorporated throughout the project.</p><p>Some of the security practices implemented include:</p><ul><li>IAM Roles instead of long-term AWS access keys</li><li>Principle of least privilege</li><li>Security Groups to restrict network traffic</li><li>Infrastructure managed using Terraform</li><li>Private container registry with Amazon ECR</li><li>Manual production approval before deployment</li></ul><p>These practices reduce risk while maintaining operational flexibility.</p><h3>Monitoring</h3><p>Monitoring is essential for maintaining application health after deployment.</p><p>Amazon CloudWatch was configured to monitor:</p><ul><li>ECS Services</li><li>Application Load Balancer</li><li>Infrastructure health</li><li>CloudWatch Alarms</li></ul><p>Amazon SNS was used to deliver notifications whenever alarms were triggered, helping improve operational visibility.</p><h3>Challenges</h3><p>During the implementation, several challenges had to be addressed:</p><ul><li>Configuring IAM permissions correctly for Jenkins</li><li>Managing Docker images for multiple services</li><li>Deploying separate frontend and backend containers</li><li>Designing Terraform modules for reusable infrastructure</li><li>Keeping sensitive Terraform files out of Git using .gitignore</li></ul><p>Resolving these issues improved both the deployment workflow and the overall security of the solution.</p><h3>Results</h3><p>The project successfully delivered:</p><ul><li>Automated infrastructure provisioning</li><li>Automated application deployment</li><li>Containerized React frontend</li><li>Containerized Node.js backend</li><li>Image storage in Amazon ECR</li><li>Deployment to Amazon ECS Fargate</li><li>Load balancing with Application Load Balancer</li><li>Infrastructure monitoring with CloudWatch</li><li>SNS notifications</li><li>Secure authentication using IAM Roles</li><li>Complete infrastructure cleanup using Terraform</li></ul><h3>Lessons Learned</h3><p>This project reinforced several important DevOps concepts.</p><p>Key takeaways include:</p><ul><li>Infrastructure as Code simplifies cloud management.</li><li>CI/CD pipelines reduce manual deployment effort.</li><li>IAM Roles are more secure than long-term access keys.</li><li>Containerized deployments improve consistency across environments.</li><li>Monitoring is just as important as deployment automation.</li><li>Terraform makes cloud environments reproducible and easier to manage.</li></ul><h3>Conclusion</h3><p>Building this project provided valuable experience designing an enterprise-style CI/CD platform using AWS services and modern DevOps practices. Combining Jenkins, Terraform, Docker, Amazon ECS Fargate, Amazon ECR, CloudWatch, and IAM Roles created a secure, scalable, and automated deployment workflow that reflects how modern cloud applications are delivered in production.</p><p>This project demonstrates how Infrastructure as Code, containerization, CI/CD automation, and cloud monitoring can be combined to build a production-style deployment platform on AWS. The complete source code, Terraform configuration, Jenkins pipeline, and documentation are available on GitHub for further reference.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32c35bd6bf45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an End-to-End CI/CD Pipeline with GitHub Actions, Docker, Terraform, Amazon ECR, and…]]></title>
            <link>https://medium.com/@oluwagbemilekeadekunle22/building-an-end-to-end-ci-cd-pipeline-with-github-actions-docker-terraform-amazon-ecr-and-1b7214b4f8ac?source=rss-149f43173d58------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b7214b4f8ac</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[amazon-ecs]]></category>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Gbemi Adekunle]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 22:12:35 GMT</pubDate>
            <atom:updated>2026-07-05T22:12:35.368Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building an End-to-End CI/CD Pipeline with GitHub Actions, Docker, Terraform, Amazon ECR, and Amazon ECS Fargate.</h3><h4>How I containerized a Flask application, provisioned AWS infrastructure with Terraform, and automated deployment to ECS using GitHub Actions.</h4><h3>Introduction</h3><p>Modern applications are expected to be deployed quickly, consistently, and with minimal manual effort. A well-designed CI/CD pipeline makes this possible by automating the build, testing, and deployment process.</p><p>In this project, I built a complete CI/CD pipeline that automatically deploys a containerized Flask application to Amazon ECS Fargate whenever changes are pushed to the GitHub repository.</p><p>Rather than manually building Docker images, uploading them to AWS, and redeploying containers, GitHub Actions now handles the entire deployment process automatically.</p><h4>Project Overview</h4><p>The project consists of four major stages:</p><ul><li>Containerizing the application using Docker</li><li>Provisioning AWS infrastructure with Terraform</li><li>Building and pushing Docker images to Amazon ECR</li><li>Automatically deploying the latest image to Amazon ECS using GitHub Actions</li></ul><p>The application is exposed to the internet through an Application Load Balancer, making it accessible through a public DNS endpoint.</p><h3>Tech Stack</h3><ul><li>Amazon ECS Fargate</li><li>Amazon ECR</li><li>Application Load Balancer (ALB)</li><li>IAM</li><li>CloudWatch</li><li>VPC</li><li>Security Groups</li><li>Terraform</li><li>Docker</li><li>GitHub Actions</li><li>Python</li><li>Flask</li></ul><h3>Step 1 — Containerizing the Flask Application</h3><p>The application was first packaged into a Docker image.</p><p>The Dockerfile installs the required dependencies, copies the application into the container, exposes port 3000, and starts the Flask server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nHHVav8tgZP3qdVxaHXnog.png" /><figcaption><strong>Building the Docker image locally using the application’s Dockerfile.</strong></figcaption></figure><p><strong>Building the Docker image</strong></p><p>After building the image successfully, I confirmed that it existed locally before testing it.</p><p><strong>Docker image successfully created</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yd5SFvb7G9oqpxTWh-_aVg.png" /><figcaption><strong>Verifying that the Docker image was successfully built and is available locally.</strong></figcaption></figure><p>The container was then started locally to verify that the application worked exactly as expected before moving to AWS.</p><p><strong>Application running locally</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w20qpcki5L9iFbL-_9kTdQ.png" /><figcaption>Testing the containerized Flask application locally on port 3000 before deployment.</figcaption></figure><h3>Step 2 — Provisioning AWS Infrastructure</h3><p>Instead of creating AWS resources manually, the infrastructure was defined using Terraform.</p><p>The deployment provisions:</p><ul><li>Amazon ECS Cluster</li><li>ECS Service</li><li>ECS Task Definition</li><li>Amazon ECR Repository</li><li>Application Load Balancer</li><li>Target Group</li><li>Listener</li><li>VPC</li><li>Public Subnets</li><li>Internet Gateway</li><li>Route Tables</li><li>Security Groups</li><li>IAM Roles</li><li>CloudWatch Log Group</li></ul><p>Using Infrastructure as Code makes the entire environment repeatable, version controlled, and easy to recreate.</p><h3>Step 3 — Automating Deployment with GitHub Actions</h3><p>A GitHub Actions workflow was configured to automate the deployment whenever code is pushed to the main branch.</p><p>The workflow performs the following tasks:</p><ol><li>Checks out the repository</li><li>Configures AWS credentials</li><li>Logs into Amazon ECR</li><li>Builds the Docker image</li><li>Tags the image</li><li>Pushes the image to Amazon ECR</li><li>Forces a new ECS deployment</li></ol><p>This eliminates the need to manually redeploy the application after every code change.</p><p><strong>GitHub Actions workflow completed successfully</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HAa2N6oi53W2wvFJ1bIHiQ.png" /><figcaption>GitHub Actions workflow successfully triggered after pushing code to the main branch</figcaption></figure><p><strong>Deployment job details</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hVoKxYWWrxreozkebyK8pg.png" /><figcaption>All CI/CD pipeline stages completed successfully, including building, pushing, and deploying the Docker image.</figcaption></figure><h4>Step 4 — Docker Image Stored in Amazon ECR</h4><p>Once the workflow completed successfully, the newly built Docker image was automatically pushed to Amazon Elastic Container Registry.</p><p>ECR serves as the central image repository that ECS uses whenever a new deployment is triggered.</p><p><strong>Docker image available in Amazon ECR</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o0dnI7BF5eGZTor8lkev-g.png" /><figcaption><strong>The latest Docker image successfully pushed to Amazon Elastic Container Registry (ECR).</strong></figcaption></figure><h3>Step 5 — Deploying to Amazon ECS Fargate</h3><p>The ECS service pulls the latest image from ECR and launches the container without requiring any EC2 instances.</p><p>Because the service runs on AWS Fargate, AWS manages the underlying infrastructure, allowing the focus to remain on the application itself.</p><p><strong>ECS service running successfully</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rFsGDAP_3F_QcFjYSKqHhw.png" /><figcaption>Amazon ECS service running successfully with the latest application task deployed on AWS Fargate.</figcaption></figure><h3>Step 6 — Verifying the Deployment</h3><p>The final step was verifying that the deployment worked correctly.</p><p>The Application Load Balancer routed incoming traffic to the ECS task, and the Flask application was successfully served through the public ALB DNS endpoint.</p><p><strong>Application successfully deployed</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qHHMWaPnttfLX1DWNOs1XQ.png" /><figcaption>Final verification confirming the application is successfully accessible through the Application Load Balancer (ALB).</figcaption></figure><h3>Key Takeaways</h3><p>Building this project reinforced several important DevOps concepts:</p><ul><li>Containerizing applications with Docker</li><li>Managing cloud infrastructure using Terraform</li><li>Implementing Infrastructure as Code</li><li>Building automated CI/CD pipelines with GitHub Actions</li><li>Using Amazon ECR as a container registry</li><li>Deploying containerized workloads on Amazon ECS Fargate</li><li>Publishing applications through an Application Load Balancer</li><li>Creating repeatable and automated deployment workflows</li></ul><p>This project demonstrates how Docker, Terraform, GitHub Actions, Amazon ECR, and Amazon ECS Fargate work together to create a fully automated, scalable, and production ready CI/CD pipeline on AWS. This project demonstrates how modern DevOps practices can be combined to create a scalable and production-style deployment pipeline on AWS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b7214b4f8ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Production-Ready AWS Auto Scaling Infrastructure with Terraform]]></title>
            <link>https://medium.com/@oluwagbemilekeadekunle22/building-a-production-ready-aws-auto-scaling-infrastructure-with-terraform-cfccbe26764a?source=rss-149f43173d58------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfccbe26764a</guid>
            <dc:creator><![CDATA[Gbemi Adekunle]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 21:48:39 GMT</pubDate>
            <atom:updated>2026-07-01T21:48:39.047Z</atom:updated>
            <content:encoded><![CDATA[<h4>Learn how I provisioned a highly available AWS infrastructure using Terraform, featuring a custom VPC, private EC2 instances, an Application Load Balancer, IAM roles, Systems Manager, and automatic scaling based on CPU utilization.</h4><h3>Introduction</h3><p>As cloud environments grow, manually managing infrastructure quickly becomes inefficient and difficult to maintain. Infrastructure as Code (IaC) solves this challenge by allowing engineers to define cloud resources using code, making deployments repeatable, consistent, and easier to manage.</p><p>In this project, I built a production-style AWS Auto Scaling environment entirely with Terraform. The architecture includes a custom VPC, public and private subnets across multiple Availability Zones, an internet-facing Application Load Balancer, EC2 instances launched through a Launch Template, IAM roles, AWS Systems Manager for secure access without SSH, and an Auto Scaling Group configured to automatically add new instances when CPU utilization increases.</p><h3>Project Architecture</h3><p>This infrastructure consists of:</p><ul><li>Custom VPC</li><li>Two public subnets</li><li>Two private subnets</li><li>Internet Gateway</li><li>Route Tables</li><li>Application Load Balancer</li><li>Target Group</li><li>Launch Template</li><li>Auto Scaling Group</li><li>IAM Role and Instance Profile</li><li>Systems Manager Session Manager</li><li>CloudWatch Target Tracking Scaling Policy</li><li>Apache Web Server</li></ul><h3><strong>Technologies Used</strong></h3><ul><li>Terraform</li><li>AWS EC2</li><li>AWS VPC</li><li>AWS Application Load Balancer</li><li>Auto Scaling Groups</li><li>Launch Templates</li><li>IAM</li><li>AWS Systems Manager</li><li>CloudWatch</li><li>Ubuntu Server</li></ul><h3>Step 1 — Initialize Terraform</h3><p>The project begins by downloading the AWS provider and preparing Terraform to provision the infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rjHb2OCTTmCG6Yor1orBxA.png" /><figcaption>Running terraform init downloads the required AWS provider, initializes the working directory, and creates the Terraform lock file to ensure consistent provider versions across deployments.</figcaption></figure><h3>Step 2 — Build the Network</h3><p>A custom VPC provides complete control over networking. Two public subnets host the Application Load Balancer, while two private subnets are reserved for EC2 instances. Spreading resources across multiple Availability Zones improves fault tolerance and availability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pKK9qdkOo0E9eGUS0cHoCQ.png" /><figcaption>Terraform configuration defining the custom VPC and multiple subnets across two Availability Zones.</figcaption></figure><h3>Step 3 — Configure Security Groups</h3><p>Security groups were configured following the principle of least privilege. The Application Load Balancer accepts HTTP traffic from the internet, while EC2 instances only allow HTTP traffic from the ALB and administrative access through AWS Systems Manager instead of public SSH access.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xwztSh6T-SW3Mdy8QQgzQA.png" /><figcaption>Security groups configured to allow internet traffic to the Application Load Balancer while restricting EC2 access to trusted sources.</figcaption></figure><h3>Step 4 — Create the Launch Template</h3><p>The Launch Template defines how every EC2 instance should be created, including the Ubuntu AMI, instance type, IAM role, security group, and user data script that automatically installs and starts Apache during provisioning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OpvMvjufpBgxPDl--mL0aA.png" /><figcaption>Launch Template configuration defining the EC2 instance settings, IAM role, security groups, and automated Apache installation using user data.</figcaption></figure><h3>Step 5 — Configure Auto Scaling</h3><p>The Auto Scaling Group launches EC2 instances inside the private subnets and registers them with the Application Load Balancer. A Target Tracking Scaling Policy continuously monitors average CPU utilization and automatically increases or decreases capacity when required.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WAVsSuyan5W3QkAou7pdrw.png" /><figcaption>Auto Scaling Group configured with a Launch Template, Target Group, and CPU-based Target Tracking Scaling Policy.</figcaption></figure><h3>Step 6 — Review the Execution Plan</h3><p>Before deploying infrastructure, Terraform generates an execution plan showing every resource that will be created. Reviewing this output helps verify the deployment before any changes are made in AWS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5VOY2W1JIzWOJcHPnYozFQ.png" /><figcaption>Terraform execution plan showing the resources that will be provisioned before deployment.</figcaption></figure><h3>Step 7 — Deploy the Infrastructure</h3><p>Running terraform apply provisions the complete environment, including networking, IAM resources, load balancing, and Auto Scaling. Terraform also outputs the DNS name of the Application Load Balancer after deployment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xdCgO48B2ssrs5AaGDqVkA.png" /><figcaption><em>Terraform successfully deployed the infrastructure and generated the Application Load Balancer DNS endpoint.</em></figcaption></figure><h3>Step 8 — Verify the EC2 Instance</h3><p>After deployment, the Auto Scaling Group successfully launched the initial EC2 instance. The instance passed all system and instance health checks, confirming that it was operating normally.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tXpAF2zqQBDzRoC7P2739g.png" /><figcaption><em>Initial EC2 instance successfully launched by the Auto Scaling Group and passing all health checks.</em></figcaption></figure><h3>Step 9 — Verify the Target Group</h3><p>The Target Group confirmed that the EC2 instance passed the Application Load Balancer’s health checks, making it eligible to receive incoming traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WPniM8r3xk7Iej2ZSG9J3Q.png" /><figcaption>Application Load Balancer Target Group created to route traffic to registered EC2 instances.</figcaption></figure><h3>Step 10 — Verify the Load Balancer</h3><p>The Application Load Balancer was successfully provisioned across two Availability Zones and became active, providing a single entry point for client requests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*94dZCom3xTidI9IkNDED-Q.png" /><figcaption>Internet-facing Application Load Balancer successfully deployed across multiple Availability Zones.</figcaption></figure><h3><strong>Step 11 — Test the Website</strong></h3><p>Opening the Load Balancer’s DNS name displayed the Apache web page hosted on the EC2 instance, confirming that traffic was successfully routed through the load balancer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J1TXz_opzgqwxrjp3zw4wg.png" /><figcaption>Apache web server successfully accessed through the Application Load Balancer DNS name.</figcaption></figure><h3>Step 12 — Connect Securely Using Systems Manager</h3><p>Instead of exposing SSH to the internet, the EC2 instance was managed using AWS Systems Manager Session Manager. This approach improves security by eliminating the need for SSH keys and inbound SSH rules.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZV0pwDod4wvnfPBy_fYyPg.png" /><figcaption>Securely connecting to the EC2 instance using AWS Systems Manager Session Manager without requiring SSH access.</figcaption></figure><h3>Step 13 — Simulate CPU Load</h3><p>The Linux stress utility was installed to intentionally increase CPU utilization. This simulated production traffic and tested whether the Auto Scaling policy would respond automatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AJXMQPtVIh2LoHtg0YT4Zg.png" /><figcaption>Using the Linux stress utility to simulate high CPU utilization and trigger Auto Scaling.</figcaption></figure><h3>Step 14 — Auto Scaling in Action</h3><p>CloudWatch detected sustained CPU utilization above the configured threshold, triggering the Target Tracking Scaling Policy. The Auto Scaling Group automatically increased the desired capacity and launched a second EC2 instance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M679J6jCVo6xRvPD5a_ckA.png" /><figcaption>CloudWatch alarm triggered the Auto Scaling policy, automatically launching an additional EC2 instance.</figcaption></figure><h3>Step 15 — Verify the Second Instance</h3><p>The AWS console confirmed that two EC2 instances were now running in separate Availability Zones, demonstrating successful horizontal scaling.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WEhbYLY2LrTYNnw8blUWIA.png" /><figcaption>Auto Scaling Group successfully increased capacity by launching a second EC2 instance.</figcaption></figure><h3>Step 16 — Confirm Target Group Health</h3><p>Both EC2 instances became healthy within the Target Group, allowing the Application Load Balancer to distribute traffic across multiple servers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S3uFdpmxdn-6dK8P443lRA.png" /><figcaption>Both EC2 instances successfully passed health checks and were registered as healthy targets behind the Application Load Balancer.</figcaption></figure><h3>Step 17 — Clean Up Resources</h3><p>Once testing was complete, terraform destroy removed every AWS resource created during the project. Cleaning up infrastructure prevents unnecessary cloud charges and demonstrates responsible cloud resource management.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T9Yk22f3oDHg_sADbPSBzQ.png" /><figcaption>Terraform cleanly removed all AWS resources, ensuring no unnecessary cloud costs remained after testing.</figcaption></figure><h3>Key Takeaways</h3><p>This project reinforced several important cloud engineering concepts:</p><ul><li>Building repeatable infrastructure with Terraform</li><li>Designing highly available AWS networking</li><li>Deploying EC2 instances with Launch Templates</li><li>Securing workloads using IAM and Systems Manager</li><li>Using Application Load Balancers to distribute traffic</li><li>Automatically scaling infrastructure based on CloudWatch metrics</li><li>Managing infrastructure through Infrastructure as Code</li></ul><h3>Conclusion</h3><p>This project demonstrates my ability to design and automate production-ready AWS infrastructure using Terraform. From networking and security to load balancing, Auto Scaling, IAM, and monitoring, every component was provisioned as code to create a scalable, highly available, and maintainable environment.</p><p>By validating the infrastructure with CPU stress testing and confirming automatic scaling through CloudWatch metrics, I demonstrated an end-to-end cloud automation workflow that reflects industry best practices. This project showcases the practical application of Infrastructure as Code, automation, and cloud architecture principles to build resilient systems capable of adapting to changing workloads.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfccbe26764a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Infrastructure as Code to Deployment: My AWS Migration Project with Terraform, WordPress, and…]]></title>
            <link>https://medium.com/@oluwagbemilekeadekunle22/from-infrastructure-as-code-to-deployment-my-aws-migration-project-with-terraform-wordpress-and-9e03a1e4e939?source=rss-149f43173d58------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e03a1e4e939</guid>
            <dc:creator><![CDATA[Gbemi Adekunle]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 03:55:02 GMT</pubDate>
            <atom:updated>2026-06-30T03:55:02.783Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>From Infrastructure as Code to Deployment: My AWS Migration Project with Terraform, WordPress, and Amazon RDS</strong></p><h3>Introduction</h3><p>In this project, I provisioned AWS infrastructure using Terraform, launched an Ubuntu EC2 instance, configured Apache and PHP, deployed WordPress, connected it to an Amazon RDS MySQL database, and managed the entire environment through code.</p><p>The goal was not only to deploy a working application but also to understand how cloud resources interact while following Infrastructure as Code best practices.</p><h3>Project Objectives</h3><p>The objectives of this project were to:</p><ul><li>Provision AWS infrastructure using Terraform</li><li>Deploy an Ubuntu EC2 instance</li><li>Configure networking and security groups</li><li>Create a private Amazon RDS MySQL database</li><li>Install Apache and PHP</li><li>Deploy WordPress</li><li>Connect WordPress to Amazon RDS</li><li>Store the project in GitHub</li><li>Destroy the infrastructure afterward to avoid unnecessary AWS charges</li></ul><h3>Architecture</h3><p>The architecture of the deployment is shown below.</p><p>Internet<br> │<br>Security Group<br> │<br>Ubuntu EC2 Instance<br>Apache + PHP + WordPress<br> │<br>Amazon RDS MySQL</p><p>This design separates the application server from the database. While the EC2 instance is publicly accessible, the database remains private inside the VPC, improving security.</p><h3>Technologies Used</h3><p>This project used:</p><ul><li>Terraform</li><li>AWS EC2</li><li>Amazon RDS (MySQL)</li><li>AWS VPC</li><li>AWS IAM</li><li>AWS S3</li><li>Ubuntu Linux</li><li>Apache2</li><li>PHP</li><li>WordPress</li><li>Git</li><li>GitHub</li></ul><h3>Provisioning Infrastructure with Terraform</h3><p>Instead of manually creating AWS resources, I used Terraform to define the infrastructure in code.</p><p>Before deployment, I formatted and validated the Terraform configuration to ensure there were no syntax or configuration issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SYYJBKy2Z85PXmd07JKRYQ.png" /><figcaption><em>Terraform successfully validated the Infrastructure as Code configuration before deployment.</em></figcaption></figure><p>Next, I reviewed Terraform’s execution plan.</p><p>This step allowed me to verify exactly which AWS resources would be created before applying any changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EnSUevl38jTw7QDK568tNw.png" /><figcaption><em>Terraform generated an execution plan showing that 17 AWS resources would be created.</em></figcaption></figure><p>Once the plan looked correct, I deployed the infrastructure.</p><p>Terraform automatically provisioned:</p><ul><li>VPC</li><li>Public and private subnets</li><li>Internet Gateway</li><li>Route tables</li><li>Security Groups</li><li>EC2 Instance</li><li>IAM resources</li><li>S3 Bucket</li><li>Amazon RDS MySQL</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I6R-5PdR6t9RQEkKTYBleQ.png" /><figcaption><em>Terraform successfully provisioned all AWS infrastructure.</em></figcaption></figure><h3>Verifying AWS Resources</h3><p>After Terraform completed successfully, I verified that the EC2 instance had been created and was running normally.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FvbtlERROyFaar1WJd-bOQ.png" /><figcaption>The EC2 instance launched successfully and passed both status checks.</figcaption></figure><p>Amazon RDS required several minutes to finish provisioning.</p><p>Once complete, the database became available for application connectivity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QfjTuGvfROzxGuwN2d-ODg.png" /><figcaption>The Amazon RDS MySQL database was successfully deployed inside private subnets.</figcaption></figure><h3>Creating a Private Amazon RDS Database with Terraform</h3><p>One of the most valuable parts of this project was provisioning Amazon RDS entirely through Terraform.</p><p>Instead of manually creating the database, I defined the subnet group, database engine, instance class, networking, and security configuration directly in my Terraform code.</p><p>This approach makes the deployment repeatable, version-controlled, and much easier to maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kiM8VQdxMjD__M8WoCSFzQ.png" /><figcaption>Terraform configuration used to provision a private Amazon RDS MySQL database.</figcaption></figure><h3>Installing Apache, PHP, and WordPress</h3><p>After connecting to the EC2 instance using SSH, I updated Ubuntu and installed Apache, PHP, MySQL client utilities, and all required PHP extensions.</p><p>This prepared the server to host the WordPress application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VtoCXjj5CkDKTNVbckmMMA.png" /><figcaption>Installing Apache, PHP, and supporting packages on the Ubuntu EC2 instance.</figcaption></figure><p>Once the server was configured, navigating to the EC2 public IP launched the WordPress installation wizard.</p><p>This confirmed that Apache and PHP were working correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ys6y7JZNqkiFBSakDPhsZA.png" /><figcaption>WordPress installation wizard successfully loaded through the EC2 public IP.</figcaption></figure><p>After entering the database credentials from Amazon RDS, WordPress completed the installation successfully.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JAphvT3UyhwASlEJ9qhSAA.png" /><figcaption>WordPress successfully connected to Amazon RDS and completed installation.</figcaption></figure><h3>Version Control with GitHub</h3><p>Throughout the project, I used Git for version control and stored the Infrastructure as Code files in GitHub.</p><p>Keeping the Terraform configuration under version control makes future updates easier while providing a complete record of the project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CUPsmMGvLvpgO-j_-75JlQ.png" /><figcaption>Pushing the completed Terraform project to GitHub.</figcaption></figure><h3>Conclusion</h3><p>This project demonstrates how Infrastructure as Code can be used to automate the deployment of a complete cloud environment on AWS. By provisioning infrastructure with Terraform, deploying WordPress on an Ubuntu EC2 instance, and integrating it with a private Amazon RDS MySQL database, I created a repeatable and scalable deployment process that reduces manual configuration and improves consistency.</p><p>Using Terraform alongside AWS services such as VPC, EC2, IAM, S3, and RDS highlights the value of automation, version control, and infrastructure management in modern cloud environments. Maintaining the entire deployment as code also makes it easier to reproduce, modify, and manage infrastructure across different environments.</p><p>This project reflects practical experience with cloud infrastructure provisioning, Linux server administration, application deployment, database integration, and Infrastructure as Code. It serves as a strong foundation for building more advanced cloud solutions involving CI/CD pipelines, containerization, and orchestration technologies.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e03a1e4e939" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>