<?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 Rawson Steve on Medium]]></title>
        <description><![CDATA[Stories by Rawson Steve on Medium]]></description>
        <link>https://medium.com/@steveraw190?source=rss-ee7ac400b226------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dtZwpG1PEysq5-6qlA2QiA.jpeg</url>
            <title>Stories by Rawson Steve on Medium</title>
            <link>https://medium.com/@steveraw190?source=rss-ee7ac400b226------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 14:33:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@steveraw190/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[The Day I Accidentally Deleted My Terraform State And What It Taught Me]]></title>
            <link>https://medium.com/@steveraw190/the-day-i-accidentally-deleted-my-terraform-state-and-what-it-taught-me-b0465afa8c26?source=rss-ee7ac400b226------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0465afa8c26</guid>
            <dc:creator><![CDATA[Rawson Steve]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 19:21:00 GMT</pubDate>
            <atom:updated>2026-07-09T19:32:13.970Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L-Dl84wA9FYexrXOVGSpIw.png" /></figure><p>When you’re learning cloud engineering, tutorials often show the happy path. Everything deploys successfully, every command works, and every resource behaves exactly as expected.</p><p>Real life is different.</p><p>One of the most valuable lessons I learned came from a mistake I made while working on an AWS infrastructure project.</p><h3>The Project</h3><p>I was deploying an Amazon EKS cluster using Terraform. Like many Infrastructure as Code projects, I configured Terraform to use:</p><ul><li>Amazon S3 for remote state storage</li><li>Amazon DynamoDB for state locking</li></ul><p>This setup allows multiple users and deployments to safely manage the same infrastructure while preventing conflicting changes.</p><p>Everything was working well.</p><h3>The Mistake</h3><p>To avoid unnecessary AWS charges, I began cleaning up resources I believed were no longer needed.</p><p>Unfortunately, one of those resources was the S3 bucket containing my Terraform state file.</p><p>The consequences were immediate.</p><p>Terraform could no longer determine the current state of my infrastructure. Backend initialization failed, state locking stopped working correctly, and checksum mismatches appeared because the backend configuration was no longer consistent.</p><p>At that moment, I realized I hadn’t just deleted a bucket — I had removed Terraform’s memory of the infrastructure.</p><h3>Solving the Problem</h3><p>Rather than abandoning the project and starting over, I decided to troubleshoot the issue as if it were a production incident.</p><p>I worked through the problem by:</p><ul><li>Identifying the missing backend resources.</li><li>Reconfiguring the Terraform backend.</li><li>Recreating the required infrastructure for remote state management.</li><li>Resolving state lock issues with DynamoDB.</li><li>Successfully redeploying and managing the infrastructure again.</li></ul><p>The process required patience, research, and a much deeper understanding of how Terraform actually works behind the scenes.</p><h3>What I Learned</h3><p>This experience changed how I think about Infrastructure as Code.</p><h3>1. Terraform State Is Critical</h3><p>The state file isn’t just another configuration file — it is Terraforms source of truth. Without it, infrastructure management becomes extremely difficult.</p><h3>2. Protect Remote State</h3><p>If you’re storing state in S3, enable versioning, apply least-privilege IAM permissions, and avoid deleting backend resources without verifying their purpose.</p><h3>3. Understand Before You Automate</h3><p>It’s easy to memorize Terraform commands. It’s much more valuable to understand why each resource exists and how the pieces fit together.</p><h3>4. Troubleshooting Builds Better Engineers</h3><p>Anyone can follow a tutorial.</p><p>Learning to investigate failures, identify root causes, and recover from mistakes is what develops real engineering skills.</p><h3>Final Thoughts</h3><p>Looking back, deleting that S3 bucket was frustrating — but it became one of the most educational experiences in my cloud engineering journey.</p><p>Today, I approach infrastructure with much greater respect for state management, backups, and cloud governance.</p><p>Every engineer makes mistakes.</p><p>The goal isn’t to avoid every failure; it’s to learn enough from each one that you don’t repeat it.</p><p>Sometimes, your biggest technical breakthrough begins with an unexpected outage.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0465afa8c26" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ From Docker to Kubernetes: Deploying the MuchTodo Application Locally with Kind]]></title>
            <link>https://medium.com/@steveraw190/from-docker-to-kubernetes-deploying-the-muchtodo-application-locally-with-kind-ca703a23b4ee?source=rss-ee7ac400b226------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca703a23b4ee</guid>
            <dc:creator><![CDATA[Rawson Steve]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 12:26:46 GMT</pubDate>
            <atom:updated>2026-04-14T12:26:46.571Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>As part of my hands-on journey into <strong>Cloud Engineering and DevOps</strong>, I built and deployed a microservice-based application called <strong>MuchTodo</strong> using <strong>Docker, Kubernetes, and Kind (Kubernetes in Docker)</strong>.</p><p>This project demonstrates real-world DevOps skills such as:</p><ul><li>Containerization</li><li>Kubernetes orchestration</li><li>Persistent storage with PVCs</li><li>Health and readiness probes</li><li>Debugging image pull and crash issues</li></ul><p>In this post, I’ll walk through the <strong>architecture, tooling, challenges, and lessons learned</strong> while deploying MuchTodo locally on Kubernetes.</p><h3>🧩 Project Overview</h3><p><strong>MuchTodo</strong> is a backend-focused application designed to simulate a production-like environment.</p><h3>Core Components</h3><ul><li><strong>MuchTodo Backend API</strong> (Go + Gin)</li><li>MongoDB (Primary datastore with persistent storage)</li><li>Redis (Optional caching layer)</li><li>Kubernetes (Kind cluster)</li><li>Docker for image builds and local testing</li></ul><h3><strong>🐳 Docker: Containerizing the Backend</strong></h3><p>The backend was containerized using a multi-stage Dockerfile to keep images lightweight and production ready.</p><p>🚀 Part 1 — Containerize the Golang API &amp; MongoDB using Docker Compose</p><p>1. Folder Structure (recommended)</p><pre>muchtodo/<br> ├── api/<br> │    ├── main.go<br> │    ├── go.mod<br> │    ├── Dockerfile<br> ├── docker-compose.yml<br> └── k8s/<br>      ├── deployment.yaml<br>      ├── service.yaml<br>      ├── mongo-deployment.yaml<br>      ├── mongo-service.yaml<br>      └── configmap.yaml</pre><p>2. Dockerfile for Golang API</p><p>Create: api/Dockerfile</p><pre># Build stage<br>FROM golang:1.22-alpine AS builder<br>WORKDIR /app<br>COPY go.mod go.sum ./<br>RUN go mod download<br>COPY . .<br>RUN go build -o server .<br><br># Runtime stage<br>FROM alpine:latest<br>WORKDIR /app<br>COPY --from=builder /app/server .<br>EXPOSE 8080<br>CMD [&quot;./server&quot;]</pre><p>Key best practices applied:</p><p>Minimal base image</p><p>Single compiled binary</p><p>Environment-based configuration</p><p>The image was built locally and loaded into Kind:</p><pre>kind load docker-image muchtodo-backend:latest --name muchtodo</pre><h3>☸️ Kubernetes Deployment with Kind</h3><p>A local Kubernetes cluster was created using:</p><pre>kind create cluster --name muchtodo<br></pre><p>All resources were deployed into a dedicated namespace:</p><pre>kubectl create namespace muchtodo<br>kubectl apply -f kubernetes/ -n muchtodo</pre><h3>🗄️ Persistent Storage (MongoDB)</h3><p>MongoDB requires persistence. I implemented this using a <strong>PersistentVolumeClaim</strong></p><pre>accessModes:<br>  - ReadWriteOnce<br>resources:<br>  requests:<br>    storage: 1Gi</pre><p>This ensured that MongoDB data survived pod restarts</p><h3>❤️ Health &amp; Readiness Probes</h3><p>One of the most important lessons came from <strong>readiness probes</strong>.</p><p>The backend exposed:</p><ul><li>/health → returns <strong>200 OK</strong></li><li>/ready → initially returned <strong>404</strong></li></ul><p>Because Kubernetes was probing /ready, the pod stayed in:</p><pre>READY: 0/1<br>STATUS: Running</pre><h3>🔍 Debugging Insight</h3><p>The application was healthy, but <strong>not “ready”</strong> according to Kubernetes.</p><p>Fix options:</p><ul><li>Implement /ready endpoint in the app</li><li>OR update the readiness probe to /health</li></ul><p>This mirrors <strong>real production incidents</strong> where apps are running but not receiving traffic</p><h3>🛠️ Troubleshooting Challenges</h3><h3>❌ ImagePullBackOff</h3><p>Cause:</p><ul><li>Kubernetes couldn’t find the local Docker image</li></ul><p>Solution:</p><pre>kind load docker-image muchtodo-backend:latest</pre><h3>❌ MongoDB CrashLoopBackOff</h3><p>Cause:</p><ul><li>Missing required environment variables:</li><li>MONGO_INITDB_ROOT_USERNAME</li><li>MONGO_INITDB_ROOT_PASSWORD</li></ul><p>Solution:</p><ul><li>Properly define env vars in the MongoDB deployment</li></ul><h3>📊 Final Pod Status</h3><pre>kubectl get pods -n muchtodo</pre><pre>mongodb-xxxxxx           1/1   Running<br>muchtodo-backend-xxxx    1/1   Running</pre><p>Logs confirmed:</p><ul><li>Successful MongoDB connection</li><li>Server running on port 8080</li><li>Health checks responding correctly</li></ul><h3>🎯 Key Takeaways</h3><p>This project strengthened my understanding of:</p><ul><li>Kubernetes pod lifecycle</li><li>Difference between <strong>liveness</strong> and <strong>readiness</strong></li><li>Persistent storage in Kubernetes</li><li>Real-world debugging (not just “happy paths”)</li><li>Why DevOps is more about <strong>problem-solving</strong> than tools</li></ul><h3>🚀 What’s Next?</h3><p>Planned improvements:</p><ul><li>Ingress with NGINX</li><li>CI/CD pipeline (GitHub Actions)</li><li>Helm chart packaging</li><li>Deployment to a managed cloud Kubernetes service (GKE / AKS / EKS)</li></ul><h3>🧠 Final Thoughts</h3><p>This project simulates <strong>real DevOps scenarios</strong> you won’t learn from theory alone. Breaking things, debugging logs, and understanding Kubernetes behavior is where true learning happens.</p><p>If you’re learning <strong>Docker, Kubernetes, or Cloud Engineering</strong>, I highly recommend building projects like this — locally first, then in the cloud.</p><h3>🔗 Connect</h3><p>If you’re interested in <strong>Cloud Engineering, DevOps, or Kubernetes</strong>, feel free to connect or reach out. Let’s learn and build together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca703a23b4ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Full-Stack Job Application Web App on Google Cloud]]></title>
            <link>https://medium.com/@steveraw190/building-a-full-stack-job-application-web-app-on-google-cloud-b79bcfcb5b57?source=rss-ee7ac400b226------2</link>
            <guid isPermaLink="false">https://medium.com/p/b79bcfcb5b57</guid>
            <dc:creator><![CDATA[Rawson Steve]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 12:03:40 GMT</pubDate>
            <atom:updated>2026-04-14T12:03:40.686Z</atom:updated>
            <content:encoded><![CDATA[<p>When I decided to level up my backend and cloud skills, I didn’t want to build another Todo app. I wanted something real — a system that mirrors how production applications actually work. So I built a full-stack job application platform where candidates can submit their details, resume, cover letter, and portfolio images, with everything stored securely on Google Cloud.</p><p>Here’s how I built it, the walls I hit, and what I’d do differently.</p><h3>The Stack</h3><p>Nothing exotic here — just a solid, production-relevant set of tools:</p><ul><li><strong>Frontend:</strong> HTML, CSS, and vanilla JavaScript</li><li><strong>Backend:</strong> Node.js + Express</li><li><strong>File storage:</strong> Google Cloud Storage</li><li><strong>Database:</strong> PostgreSQL on Cloud SQL</li><li><strong>Supporting libraries:</strong> Multer, UUID, dotenv, Cloud SQL Connector</li></ul><p>I deliberately avoided heavy frameworks on the frontend. If you understand how things work without abstractions, picking up React or Vue later is trivial. The reverse isn’t always true.</p><h3>What I Built</h3><p>The app lets a candidate fill out a job application form, upload their resume and up to five portfolio images, and receive a unique Application ID on a confirmation screen. On the backend, every submission trigger’s two things: files go to a structured folder in GCS (applications/{id}/), and the metadata — name, email, position, file URLs, status — lands in a PostgreSQL table.</p><p>A few details I’m particularly happy with:</p><ul><li><strong>Live image preview</strong> before submission, so candidates can verify their uploads</li><li><strong>Loading state on the submit button</strong> to prevent double submissions</li><li><strong>Clean GCS folder structure</strong> that makes every application self-contained and easy to retrieve</li></ul><h3>The Challenges (The Interesting Part)</h3><h3>1. File uploads and the Uniform Bucket-Level Access wall</h3><p>Multer with memory storage was the natural starting point — files land in memory, get piped to GCS, done. What I didn’t anticipate was this error when trying to make uploaded files publicly accessible:</p><pre>Cannot insert legacy ACL on a bucket that has uniform bucket-level access enabled.</pre><p>GCS buckets with Uniform Bucket-Level Access don’t support per-object ACLs. Passing public: true in the upload config — the approach that works on buckets without this setting — simply fails here.</p><p>The fix was to remove public: true from the upload call entirely, then grant the Storage Object Viewer role to allUsers at the bucket level through IAM. Files become publicly readable by default, and the upload code stays clean.</p><p><strong>Takeaway:</strong> Read the IAM model for whichever cloud storage product you’re using before you write a single line of upload code. It saves a frustrating debugging session later.</p><h3>2. Connecting Node.js to Cloud SQL</h3><p>The Cloud SQL Connector for Node.js (@google-cloud/cloud-sql-connector) handles the secure tunnel to your PostgreSQL instance without requiring you to whitelist IPs or manage SSL certificates manually. It&#39;s the right way to do this, but the documentation assumes a fair amount of prior GCP knowledge.</p><p>The key insight: the connector injects itself as a custom socket factory into the pg client. Your connection string stays mostly standard; you just pass the connector&#39;s output into the pg.Pool config. Once that clicked, the rest was straightforward.</p><h3>3. Firestore vs. PostgreSQL — choosing the right database</h3><p>Early in planning I considered Firestore since I was already in the GCP ecosystem. I’m glad I didn’t use it here. Application data is inherently relational — a submission has an applicant, a position, a status, and multiple file references. That structure maps cleanly to a SQL table. Firestore would have meant either duplicating data or managing references manually, with no joins to fall back on.</p><p>Use the right tool for the data model, not the one that happens to be in the same console.</p><h3>What I Learned</h3><p>A few things stuck with me beyond the technical specifics:</p><p><strong>Logging during development is non-negotiable.</strong> I added verbose logging early and it saved me hours when debugging the GCS upload pipeline. You can’t trace an async file upload failure without it.</p><p><strong>Cloud services have opinions.</strong> GCS, Cloud SQL, and Cloud Run each have a model for how they expect you to use them. Fighting that model is always slower than understanding it first.</p><p><strong>UX details compound.</strong> The live preview, the loading state, the confirmation screen with an Application ID — none of these are hard to build individually. Together, they’re the difference between a form that feels throwaway and one that feels like a real product.</p><h3>What’s Next</h3><p>This is a solid v1, but there’s a clear path to v2:</p><ul><li><strong>Admin dashboard</strong> to view, filter, and update application status</li><li><strong>Email notifications</strong> triggered on submission and status change</li><li><strong>Status workflow:</strong> Pending → Reviewed → Shortlisted</li><li><strong>Authentication</strong> for the admin panel</li><li><strong>Deployment</strong> to Cloud Run for a fully managed, scalable setup</li></ul><h3>The Code</h3><p><strong>The full source is on GitHub</strong>: <a href="https://github.com/Steveraw400/Gcp-webform">Steveraw400/Gcp-webform</a></p><p>If you hit similar issues with GCS uploads or Cloud SQL connections, drop a question in the comments — happy to go deeper on any of it.</p><p><em>#NodeJS #GoogleCloud #PostgreSQL #WebDevelopment #FullStackDevelopment #CloudStorage</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b79bcfcb5b57" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My First AWS Deployment: Learning EC2, Ansible, and Load Balancing the Hard Way]]></title>
            <link>https://medium.com/@steveraw190/my-first-aws-deployment-learning-ec2-ansible-and-load-balancing-the-hard-way-4d077c4572d9?source=rss-ee7ac400b226------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d077c4572d9</guid>
            <dc:creator><![CDATA[Rawson Steve]]></dc:creator>
            <pubDate>Fri, 03 Oct 2025 13:35:37 GMT</pubDate>
            <atom:updated>2025-10-03T14:42:41.417Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Education Officer to Cloud Engineer: My Second Semester Journey at AltSchool Africa</h3><p>When I decided to transition from the civil service as an education officer into cloud technology, I knew the journey wouldn’t be easy. But nothing quite prepared me for the moment I stared at my Ansible playbook, wrestling with indentation errors, thinking “What did I get myself into?”</p><p>This article chronicles my second-semester exam project at AltSchool Africa, my first real hands-on experience with AWS infrastructure. If you’re also new to cloud technology or considering a career transition, I hope my struggles and victories encourage you to keep pushing forward.</p><h3>The Mission: Build a Load-Balanced Web Infrastructure</h3><p>The project requirements seemed straightforward on paper:</p><ol><li>Launch 2 EC2 instances (staying within AWS Free Tier)</li><li>Create an HTML page displaying each instance’s IP address</li><li>Use Ansible to automate NGINX installation and deployment</li><li>Set up an Application Load Balancer (ALB)</li><li>Deploy the same page to S3 as a static website</li><li>Compare both hosting approaches</li></ol><p><strong>Spoiler alert</strong>: It wasn’t as straightforward as it seemed.</p><h3>Part 1: Launching EC2 Instances — The Foundation</h3><p>Setting up my EC2 instances went relatively smoothly. I chose Ubuntu Server 22.04 LTS instances (t3.micro to stay within the Free Tier) and configured the basic settings. However, I made a rookie mistake that I only discovered later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-uMNwF36Nd7yRGnuLXdXGw.png" /></figure><p><strong>Lesson Learned #1: Availability Zones Matter</strong></p><p>Initially, I placed both instances in the same availability zone. It wasn’t until I started thinking about production environments that I realized the importance of distributing instances across different availability zones. In a real-world scenario, if one zone experiences disruption, your application stays online because the other instance is in a different zone. High availability isn’t just a buzzword, it’s essential for production systems.</p><p><strong>The Key Pair Challenge</strong></p><p>My first real hiccup came when trying to SSH into my instances. I couldn’t locate my key pair file on my local machine. After some troubleshooting, I learned to navigate (cd) directly to my project folder where I had saved the .pem file. Once there, I could successfully log into both instances. This small victory felt huge, I was actually connecting to servers running in the cloud!</p><h3>Part 2: Creating the Dynamic HTML Page</h3><p>The goal was simple: create a webpage that displays the IP address of whichever EC2 instance is serving the request. This would later help me verify that my load balancer was actually distributing traffic between both servers.</p><p>I used Ansible to deploy the HTML page (more on that in the next section) and tested it locally first to ensure it would display the instance information correctly. Seeing that IP address appear on the page for the first time was oddly satisfying, it meant the instances could identify themselves.</p><pre>---<br>- name: Installing nginx on our webservers<br>  hosts: webservers<br>  become: yes<br>  tasks:<br>    - name: Install nginx<br>      apt:<br>        name: nginx<br>        state: present<br>        update_cache: yes<br><br>    - name: Start and enable nginx<br>      service:<br>        name: nginx<br>        state: started<br>        enabled: yes<br><br>    - name: Create custom index.html for Instance 1<br>      copy:<br>        dest: /var/www/html/index.html<br>        content: |<br>          &lt;html&gt;<br>          &lt;head&gt;&lt;title&gt;Server 1&lt;/title&gt;&lt;/head&gt;<br>          &lt;body&gt;<br>          &lt;h1&gt;Welcome to Server 1!&lt;/h1&gt;<br>          &lt;p&gt;My machine delievrs better: {{ ansible_host }}&lt;/p&gt;<br>          &lt;p&gt;Delivery at its best&lt;/p&gt;<br>          &lt;/body&gt;<br>          &lt;/html&gt;<br>      when: inventory_hostname == &quot;51.21.255.77&quot;<br><br>    - name: Create custom index.html for Instance 2<br>      copy:<br>        dest: /var/www/html/index.html<br>        content: |<br>          &lt;html&gt;<br>          &lt;head&gt;&lt;title&gt;Server2!&lt;/title&gt;&lt;/head&gt;<br>          &lt;body&gt;<br>          &lt;h1&gt;Welcome to Server 2!&lt;/h1&gt;<br>          &lt;p&gt;This server is running at: {{ ansible_host }}&lt;/p&gt;<br>          &lt;p&gt;Delivery at its finest&lt;/p&gt;<br>          &lt;/body&gt;<br>          &lt;/html&gt;<br>      when: inventory_hostname == &quot;51.20.106.221&quot;</pre><h3>Part 3: Ansible — The “What Did I Get Myself Into?” Moment</h3><p>Here’s where things got interesting. This was my second time using Ansible, but that didn’t make it easy.</p><p><strong>The Indentation Nightmare</strong></p><p>YAML files are unforgiving. One misplaced space, one tab where there should be spaces, and your entire playbook fails. I spent considerable time debugging indentation errors, questioning my life choices, and learning to respect the importance of proper formatting.</p><p>After about 30 minutes of careful editing and testing, I finally got my playbook working. The moment I ran it successfully and watched Ansible:</p><ul><li>Connect to both instances</li><li>Install NGINX</li><li>Configure NGINX to start on boot</li><li>Deploy my HTML page</li></ul><p>…was pure magic. That “Hallelujah, it worked!” feeling is what keeps you going in tech.</p><p>Here’s a glimpse of my Ansible playbook in action:</p><pre>ansible-playbook -i host-inventory playbook.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*3GQhv9bau8TbMYOfbGqLUw.png" /></figure><p>The playbook automated everything, which meant I could destroy and rebuild my entire setup with just one command. That’s the power of Infrastructure as Code.</p><h3>Part 4: The Application Load Balancer — Panic and Relief</h3><p>Creating the Application Load Balancer involved several steps:</p><ol><li><strong>Create a Target Group</strong>: I first created a target group and added both EC2 instances to it.</li><li><strong>Configure Security Groups</strong>: I opened port 22 (SSH) and port 80 (HTTP) to allow traffic from the internet through the load balancer to the instances.</li><li><strong>Create the Load Balancer</strong>: Set up the ALB itself and associated it with my target group.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f7gpI9poCeJAaq2Xbf94nQ.png" /></figure><p><strong>The Unhealthy Instance Crisis</strong></p><p>After setting everything up, I checked my target group and saw the dreaded status: <strong>Unhealthy</strong>. Both instances were failing health checks.</p><p>Panic mode activated.</p><p>Then it hit me, I hadn’t installed NGINX on both servers yet! The load balancer was trying to send health check requests to port 80, but nothing was listening on that port. Once I ran my Ansible playbook and got NGINX running on both instances, they turned healthy, and I could breathe again.</p><p><strong>Testing the Load Balancer</strong></p><p>The moment of truth came when I tested the load balancer’s DNS URL. I refreshed the page multiple times and watched as the IP address changed, first showing one instance, then the other. The load balancer was working! Traffic was being distributed across both servers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*1qWjU3qeb6f5tCPhrd9wVg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*MpIFdoIGA9qfFgMOT6BekQ.png" /></figure><h3>Part 5: S3 Static Website Hosting — The Simpler Alternative</h3><p>After the complexity of EC2, Ansible, and load balancers, deploying to S3 felt refreshingly simple.</p><p>I created an S3 bucket, uploaded my index.html file, and enabled static website hosting. However, I initially couldn&#39;t access the file because S3 buckets are private by default.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ScDf7kuP3KWs7pBZ80DisA.png" /></figure><p><strong>The Solution</strong>: I had to set up a bucket policy to allow public read access to my objects. Once that was in place, my static website was live and accessible via the S3 website endpoint.</p><pre>{<br>    &quot;Version&quot;: &quot;2012-10-17&quot;,<br>    &quot;Statement&quot;: [<br>        {<br>            &quot;Effect&quot;: &quot;Allow&quot;,<br>            &quot;Principal&quot;: &quot;*&quot;,<br>            &quot;Action&quot;: &quot;s3:GetObject&quot;,<br>            &quot;Resource&quot;: &quot;arn:aws:s3:::alt-sch-buckt/*&quot;<br>        }<br>    ]<br>}</pre><h3>The Big Comparison: EC2 + ALB vs S3 Static Hosting</h3><p>This is where the learning really crystallized for me.</p><p><strong>S3 Static Hosting</strong>:</p><ul><li><strong>Best for</strong>: Static websites (HTML, CSS, JavaScript)</li><li><strong>Advantages</strong>: Simple, cost-effective, highly available by design, no server management</li><li><strong>Limitations</strong>: No server-side processing, can’t run dynamic applications</li></ul><p><strong>EC2 + ALB</strong>:</p><ul><li><strong>Best for</strong>: Dynamic applications, server-side processing, complex backends</li><li><strong>Advantages</strong>: Full control, can run any application, can scale with load balancing</li><li><strong>Limitations</strong>: More complex, requires server management, higher cost</li></ul><p><strong>My Biggest Takeaway</strong>: For a simple HTML page, S3 is overkill in terms of complexity — but EC2 + ALB gives you the foundation for real-world applications that need compute power and high availability.</p><h3>Reflections: What This Project Taught Me</h3><h3>1. High Availability Isn’t Optional</h3><p>Using multiple availability zones and a load balancer means your website can stay online 24/7, even if one server fails. This isn’t just about passing an exam , it’s about building resilient systems.</p><h3>2. Automation Is Your Friend</h3><p>Once I got my Ansible playbook working, I could rebuild my entire infrastructure in minutes. Manual configuration doesn’t scale; automation does.</p><h3>3. Troubleshooting Is Part of the Job</h3><p>From unhealthy instances to indentation errors to permission issues, every problem I solved made me a better engineer.</p><h3>4. Documentation Matters</h3><p>Writing this article forced me to reflect on what I learned. If you’re learning cloud technology, document your journey. Your future self (and others) will thank you.</p><h3>What I’d Do Differently Next Time</h3><ol><li><strong>Plan availability zones from the start</strong> instead of as an afterthought</li><li><strong>Set up a proper project directory structure</strong> to avoid key pair location issues</li><li><strong>Test health checks before</strong> assuming the load balancer setup is complete</li><li><strong>Use version control (Git)</strong> for my Ansible playbooks and configuration files</li></ol><h3>Final Thoughts</h3><p>Transitioning from education to cloud engineering isn’t easy, but projects like this prove it’s possible. Every error message is a learning opportunity. Every successful deployment is a confidence boost.</p><p>To my fellow career changers and cloud beginners: embrace the “hard way.” The struggles make the victories sweeter, and the knowledge sticks better when you’ve earned it through troubleshooting and persistence.</p><p>If I can go from panicking over Ansible indentation to successfully deploying a load-balanced infrastructure on AWS, you can too.</p><p><strong>Next Steps</strong>: I’m eager to take this knowledge into a live production environment and continue building more complex cloud solutions.</p><h3>Resources</h3><ul><li><strong>GitHub Repository</strong>: <a href="https://steveraw400.github.io/Altschool_first_product/">My Project Code</a></li><li><strong>AWS Free Tier</strong>: Get started with AWS without breaking the bank</li><li><strong>Ansible Documentation</strong>: Your best friend for automation</li></ul><p><em>What was your first cloud project like? Drop a comment and share your experience — I’d love to hear your story!</em></p><p><strong>#AWS #CloudComputing #Ansible #DevOps #CareerTransition #AltSchoolAfrica #LearningInPublic</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d077c4572d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>