DEV Community: Ngozi

Automating S3 Cross-Region Replication (CRR) with Pulumi

Ngozi — Mon, 21 Jul 2025 11:15:43 +0000

Managing data redundancy and disaster recovery is critical in cloud environments. I will show you how to set up S3 Cross-Region Replication (CRR) using Pulumi — a modern Infrastructure as Code tool that lets you use familiar programming languages like Python to provision cloud resources.

What is S3 Cross-Region Replication (CRR)?
S3 CRR automatically replicates objects from one S3 bucket in a specific AWS region to another bucket in a different region. This ensures:

High availability
Improved disaster recovery
Regional compliance requirements

Steps to Deploy S3 CRR with Pulumi

Setup Pulumi and AWS CLI

Ensure AWS CLI is configured with appropriate IAM permissions.
Install Pulumi:

curl -fsSL https://get.pulumi.com | sh

Define Infrastructure with Pulumi (Python)
The core of the project includes:

Source S3 Bucket (e.g., us-east-1)
Destination S3 Bucket (e.g., us-west-2)
Replication Role & Policy
Replication Configuration Pulumi uses aws.s3.Bucket and related resources to build this.

Deploy Infrastructure
In your terminal, navigate to your project directory and run:

pulumi up

This command:

Creates both S3 buckets
Sets up replication configuration
Deploys necessary IAM roles

Test the Replication

Upload objects to your source bucket via AWS Console or CLI.

Pulumi-enabled CRR will automatically replicate the objects to your destination bucket.

Destroy Infrastructure
To remove all deployed resources:

pulumi destroy

Final Thoughts
By using Pulumi to automate S3 CRR:

You simplify repetitive infrastructure tasks.
Manage multi-region replication efficiently.

Pulumi’s ability to manage AWS resources through familiar programming makes it a powerful tool for DevOps Engineers seeking flexibility.

All project files are available here: GitHub Repository

Let’s connect on LinkedIn!

Automating IAM Cleanup: How I Built an Inactive Users Detection System on AWS Using Lambda, Terraform & SNS

Ngozi — Mon, 23 Jun 2025 16:04:14 +0000

IAM users often get created and forgotten. And forgotten IAM users are a security risk.
In this project, I automated the detection of inactive IAM users and sent alerts using AWS Lambda, EventBridge, SNS, and S3 — all provisioned with Terraform. Here’s how I did it.

Tools Used:

Terraform: Infrastructure provisioning
Lambda (Python): Logic for identifying inactive users
IAM: User credentials check
S3: Archival of inactive user reports
SNS: Notification delivery
EventBridge: Scheduled execution (CRON: every Monday at 12pm)

Step 1 — Terraform Setup
I started by writing Terraform files to create all required AWS resources: an S3 bucket, an SNS topic, a Lambda function, and an EventBridge rule to trigger the function on a schedule.

Step 2 — Writing the Lambda Function (Python)
The core logic was written in Python using boto3. It:

Lists all IAM users
Checks PasswordLastUsed
Flags users inactive for over 90 days
Saves the list in S3
Sends it as an email notification via SNS

Step 3 — Scheduling with EventBridge
I used a CRON expression to schedule the function to run weekly on Mondays at 12pm.

Step 4 — Notifications and Output

A file containing the list of inactive users is automatically uploaded to S3
An email alert is sent with the same content via SNS

Here’s the Repo on GitHub

Let’s connect on LinkedIn!

Deploying a Dockerized Browser Game with Elastic Beanstalk

Ngozi — Sun, 15 Jun 2025 18:04:08 +0000

Introduction
I built a simple, colorful browser game using HTML/CSS/JavaScript, containerized it with Docker, and deployed it using AWS Elastic Beanstalk — a service that simplifies deployment for containerized applications.

This post covers the full process — from writing the game to seeing it live on a public URL.

Step 1: Building the Game
I created a browser game called Color Click. The goal is simple: click as many randomly appearing colorful dots as you can. It’s fast, fun, and great for beginners in frontend or game logic.

Technologies used:

HTML, CSS, JavaScript (Frontend)
Nginx (as the static file server)
Docker (to containerize the app)

Step 2: Version Control with GitHub
I initialized a Git repo, committed all files (Dockerfile, HTML, CSS, JS), and pushed the code to GitHub.

Step 3: Deploy to AWS Elastic Beanstalk
Elastic Beanstalk allows you to run Docker containers easily without managing infrastructure manually. Here’s what I did:

Zipped the project files (including Dockerfile)
Created a new Elastic Beanstalk app via the AWS Console
Chose the Docker platform
Set up:

Service role
EC2 instance profile
Key pair (for SSH)
Public IP assignment
Default VPC with public subnet

Step 4: Access the Game via the Web
After deployment, Elastic Beanstalk assigned a public domain. I simply opened the URL and saw the game running — served via Nginx inside my Docker container on an EC2 instance.

Here’s my GitHub Repo

Let’s Connect on LinkedIn!

Deploying a Python Microservices App on AWS with EKS, Docker, Helm, and RabbitMQ

Ngozi — Fri, 13 Jun 2025 14:09:57 +0000

In this project, I deployed a Python-based microservices application on AWS using a Kubernetes cluster (EKS), Docker for containerization, and Helm for resource management. The end goal of the application is to convert uploaded video files into MP3 audio format, delivering the output back to the user via a notification system.

The app consists of multiple services such as authentication, file conversion, gateway, and notification — each built and deployed as independent microservices. The project also incorporates MongoDB, PostgreSQL, and RabbitMQ to support key application features like data storage, queue processing, and service communication.

1. Setting up the Prerequisites

Before getting started, I ensured that the following were installed and configured on my local environment:

AWS CLI & IAM credentials
kubectl
Python
Docker
Helm

2. Creating the Kubernetes Cluster (EKS)

I created an EKS cluster and node group. Once active, I confirmed the nodes (EC2 instances) were up and running.

3. Connecting EKS Cluster to CLI

The cluster was then connected to the CLI using aws eks update-kubeconfig, allowing further operations using kubectl.

4. Deploying Databases and Message Queue

The project uses the following backend services:

MongoDB for the auth service
PostgreSQL for token storage
RabbitMQ for messaging between services

All were deployed using Helm charts.

5. Building and Pushing Microservice Images

Each service — auth, converter, gateway, and notification—was containerized using Docker. Images were pushed to Docker Hub.

docker build -t your-image-name . docker push your-image-name

6. Deploying Microservices with Helm

After building the images, I created Helm charts for each microservice and deployed them to the EKS cluster.

7. Verifying Functionality

Received a token from PostgreSQL

Accessed the email notification

Successfully downloaded and played the converted MP3 file

This project demonstrates how to deploy a full-fledged Python microservices app with scalable architecture using AWS EKS, Docker, and Helm. It covers essential DevOps workflows and can be a great template for production-grade deployments.

Here’s the Repo on GitHub.

Let’s connect on LinkedIn!