<?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 Comfort Benton on Medium]]></title>
        <description><![CDATA[Stories by Comfort Benton on Medium]]></description>
        <link>https://medium.com/@mrsceebenton2?source=rss-3ba2f8d65cd1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lMjCG7O3kbGE8Apl8xbc5A.png</url>
            <title>Stories by Comfort Benton on Medium</title>
            <link>https://medium.com/@mrsceebenton2?source=rss-3ba2f8d65cd1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 11:19:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mrsceebenton2/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[In the Beginning … Python Really Tried Me!]]></title>
            <link>https://medium.com/@mrsceebenton2/in-the-beginning-python-really-tried-me-6b066ccfc1a5?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b066ccfc1a5</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Fri, 15 May 2026 01:32:15 GMT</pubDate>
            <atom:updated>2026-05-15T01:32:15.246Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*lNh40y6IXUoZsyBRiNbvAg.png" /></figure><h4>By Comfort Benton | Cloud Engineer</h4><p>This little Python project had no business teaching me this much, and I was here for every bit of it!</p><p>The goal was simple: build a script that generates unique EC2 instance names for approved departments using a shared AWS environment.</p><p>But once I started building it, the project turned into a hands-on lesson in user input, department validation, random characters, loops, nested loops, readable output, and the quiet power of indentation.</p><p>And let me tell you, Python indentation was not playing with me.</p><p><strong>The Assignment</strong></p><p>The project scenario was based on several departments sharing an AWS environment. The goal was to create a Python script that generated unique EC2 instance names, making it easier for team members to identify which department each instance belonged to.</p><p>The script needed to:</p><ol><li>Ask the user how many EC2 instance names they need.</li><li>Ask the user for their department name.</li><li>Generate random letters and numbers to make each name unique.</li><li>Output the same number of unique EC2 names requested by the user.</li></ol><p>The advanced part of the project added another layer. Only certain departments were approved to use the generator: Marketing, Accounting, and FinOps.</p><p>So this was not just about generating random names. The script also needed to decide who was allowed to use it.</p><p><strong>Breaking the Problem Down</strong></p><p>Before trying to write the full program, I had to slow down and think through the flow in plain English.</p><p>The program needed to do something like this:</p><p>allowed_departments = [“marketing”, “accounting”, “finops”]</p><p>That helped me see the project as smaller pieces instead of one big intimidating script.</p><p><strong>Starting With the Department Check</strong></p><p>The first major piece I worked on was the department validation.</p><p>I created a list of approved departments:</p><pre>Ask the user for their department.<br><br>Check if the department is approved.<br><br>If the department is approved:<br>  Ask how many EC2 instance names are needed.<br>  Generate the requested number of names.<br>  Add random letters and numbers to each name.<br>  Print the completed names.<br><br>If the department is not approved:<br>  Print a message explaining they are not approved.</pre><p>Then I asked the user for their department:</p><p>department = input(“Please enter your department name: “)</p><p>One of the requirements was to account for uppercase and lowercase variations. So if someone typed <strong>Marketing</strong>, <strong>MARKETING</strong>, or <strong>marketing</strong>, the program should still understand what they meant.</p><p>That is where <strong>.lower() </strong>came in:</p><p>department = department.lower()</p><p>This was a small line of code, but it made the script much cleaner. Instead of checking every possible capitalization variation, I converted the user’s input to lowercase and compared it to the lowercase department list.</p><p>That felt like a real “work smarter, not harder” moment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*JQ3hmKoW9D8tu13EzaDneQ.png" /><figcaption>Screenshot: Program approving a valid department.</figcaption></figure><p>Example:</p><p>Please enter your department name: marketing<br> <br>The Marketing department is approved to use this generator.</p><p><strong>Making the Output More User-Friendly</strong></p><p>Once the department check worked, I started playing around with how the output looked.</p><p>I wanted the program to respond with the department name included in the message, not just a generic approval message.</p><p>So instead of only saying:</p><p>Your department is approved.</p><p>I wanted it to say something more specific, like:</p><p>The Marketing department is approved to use this generator.</p><p>That is where I used f-strings:</p><p>print(f”\nThe {department.capitalize()} department is approved to use this generator.\n”)</p><p>I also started using <strong>\n</strong> to add spacing in the output.</p><p>Was I a little obsessed with spacing? Yes.</p><p>But I liked that the output looked cleaner and easier to read. Even in a small project, I wanted the user experience to feel intentional.</p><p><strong>When the “Not Approved” Logic Exposed a Problem</strong></p><p>At one point, I realized something important.</p><p>Even when a department was not approved, the program was still allowing that user to move forward and generate EC2 names.</p><p>That meant my approval message was working, but my program flow was not fully protected.</p><p>At first, I thought I could fix it by moving the else block to the bottom.</p><p>That did not solve it.</p><p>The real issue was indentation.</p><p>The name generation code needed to be indented under the approved department if block. That way, only approved departments could access the rest of the program.</p><p>The structure needed to look like this:</p><p>if department in <strong>allowed_departments</strong>:<br><em> # Approved message<br> # Ask how many EC2 names are needed<br> # Generate the EC2 names</em><br> <br> else:<br><em> # Not approved message</em></p><p>That was a big moment for me because it helped me understand that Python indentation is not decoration. It controls the logic.</p><p>If code is indented under the<strong>if</strong>, it belongs to that condition.</p><p>If it is not indented under the <strong>if</strong>, Python does not treat it as part of that condition.</p><p>That one discovery made the project make a lot more sense.</p><p><strong>Asking How Many EC2 Names Are Needed</strong></p><p>Once the department was approved, the next step was asking how many EC2 instance names the user needed.</p><p>I started with a shorter variable name like <strong>count</strong>, but then I realized that <strong>count</strong> did not really explain what was being counted.</p><p>So I changed it to something more readable:</p><p>number_of_instances = int(input(f”How many unique EC2 instance names do you need for the {department.capitalize()} department? “))</p><p>This was another small but important lesson.</p><p>Short variable names are not always better. A longer variable name can make the code easier to understand when you come back to it later.</p><p>The <strong>int()</strong> part was also important because user input starts as text. Since I needed the answer to control a loop, I had to convert it into a whole number.</p><p><strong>Adding Random Characters</strong></p><p>The next part was generating the random section of each EC2 name.</p><p>I used Python’s <strong>random</strong> library and created a string of characters that the program could choose from:</p><p>characters = “ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”</p><p>This gave Python a pool of letters and numbers to randomly pick from.</p><p>Then I used <strong>random.choice()</strong> to choose one character at a time.</p><p>random.choice(characters)</p><p>At first, I had to sit with this line:</p><p>random_part = “”</p><p>It looked like I was assigning nothing to a variable.</p><p>But then it clicked.</p><p>That empty string is the starting point. The program starts with a blank random section, then adds one random character at a time.</p><p>So behind the scenes, it is doing something like this:</p><p>Start with nothing.<br> <br> Add A.<br> Add 7.<br> Add K.<br> Add 9.<br> Add 2.<br> <br> Final random part: A7K92</p><p>That helped me understand why the blank string mattered.</p><p><strong>The Loop Inside the Loop</strong></p><p>This project also introduced me to a loop inside another loop.</p><p>The first loop controls how many EC2 names get created:</p><p>for instance in range(number_of_instances):</p><p>If the user asks for 3 names, that loop runs 3 times.</p><p>Inside that loop, I used another loop to build the random ending:</p><p>for i in range(5):<br> random_part = random_part + random.choice(characters)</p><p>That inner loop runs 5 times, adding one random character each time.</p><p>So the logic is basically:</p><p>For each EC2 name requested:<br> Start with an empty random ending.<br> Pick 5 random characters.<br> Attach those characters to the department and EC2 label.<br> Print the completed EC2 name.</p><p>That helped me understand that the two loops had different jobs.</p><p>The outer loop answered:</p><p>How many names should I generate?</p><p>The inner loop answered:</p><p>How many random characters should each name have?</p><p>That was one of my favorite discoveries in this project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/907/1*vVI9-AV-YBgv3VxfbnTNHA.png" /><figcaption>Screenshot: Program generating multiple EC2 names for an approved department.</figcaption></figure><p>Example:</p><p>Please enter your department name: accounting<br> <br>The Accounting department is approved to use this generator.<br> <br>How many unique EC2 instance names do you need for the Accounting department? 3<br> <br>Please find below requested EC2 name(s):<br> <br>ACCOUNTING-EC2-K7P2A<br>ACCOUNTING-EC2-M9X4Q<br>ACCOUNTING-EC2-B3L8Z</p><p><strong>Handling Unapproved Departments</strong></p><p>For departments that were not approved, I wanted the program to clearly explain what happened.</p><p>So instead of only printing that the department was not approved, I added a second message showing the approved departments:</p><p>else:<br> print(f”\nThe {department.capitalize()} department is NOT APPROVED to use this EC2 name generator.”)<br> <br>print(“\nThe only departments APPROVED to use this EC2 name generator are Marketing, Accounting, and FinOps.\n”)</p><p>That made the output more helpful.</p><p>If someone enters HR, the program does not just reject them. It also tells them which departments are allowed.</p><p>That is a small detail, but I think small details help make a program feel more complete.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1009/1*Qpxz5_OB9MkyZnY9uo2l3A.png" /><figcaption><em>Screenshot: Program denying an unapproved department.</em></figcaption></figure><p>Example:</p><p>Please enter your department name: HR<br> <br>The HR department is NOT APPROVED to use this EC2 name generator.<br> <br>The only departments APPROVED to use this EC2 name generator are Marketing, Accounting, and FinOps.</p><p><strong>What I Learned</strong></p><p>This project looked simple at first, but it gave me practice with several foundational Python concepts.</p><p>I worked with:</p><p>- input()<br>- variables<br>- lists<br>- if/else statements<br>- .lower()<br>- .capitalize()<br>- .upper()<br>- f-strings<br>- int()<br>- loops<br>- nested loops<br>- random.choice()<br>- string building<br>- indentation</p><p>The biggest lesson was that working code is not only about getting the final output.</p><p>It is also about understanding why each line exists.</p><p>I also learned that the way code is organized matters. Indentation decides what belongs inside a condition or loop. Variable names can make code easier or harder to read. Comments can help future-me understand what present-me was thinking.</p><p>And yes, there is still room for improvement.</p><p>For example, my current version uses .capitalize() when displaying the department name. That works well for Marketing and Accounting, but it displays FinOps as Finops. In a more polished version, I would improve the display formatting so FinOps appears correctly.</p><p>I also noticed that the assignment did not specify a limit on how many EC2 names a user could request. For this version, I stayed aligned with the requirement and allowed the user to decide how many names they needed. In a more production-style version, I would probably add input validation or a reasonable limit so someone could not request an extreme number of names at once.</p><p><strong>Final Thoughts</strong></p><p>This project reminded me that beginner projects are not always as small as they look.</p><p>A simple EC2 name generator turned into practice with logic, formatting, loops, random values, and program flow.</p><p>It also gave me a better appreciation for writing code that is not only functional but also readable.</p><p>By the end, my script could validate approved departments, handle uppercase and lowercase input, ask how many EC2 names were needed, generate the requested number of names, add random characters for uniqueness, block unapproved departments, and print clear user-friendly messages.</p><p>Not bad for a project that started out looking “easy.”</p><p>Python really tried me in the beginning, but I walked away understanding more than I expected.</p><p>The final code is available in my GitHub repository here:</p><p><a href="https://github.com/mrscee/ec2-nameforge-python"><strong>EC2 NameForge Python</strong></a></p><p>Still building. Still learning.<br>Still leaning into Comfort in the Cloud. ☁️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b066ccfc1a5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Solid Two-Tier Architecture in AWS Using EC2 and RDS]]></title>
            <link>https://medium.com/@mrsceebenton2/i-built-a-solid-two-tier-architecture-in-aws-using-ec2-and-rds-057d47e5707d?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/057d47e5707d</guid>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[ec2]]></category>
            <category><![CDATA[cloud-architecture]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[mysql]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 03:02:27 GMT</pubDate>
            <atom:updated>2026-04-29T03:02:27.187Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/823/1*xMpagqUPzWj0-qYQxWzgJw.png" /></figure><h4>By Comfort Benton | Cloud Engineer</h4><p>In this project, I focused on building the foundational layer of a two-tier architecture in AWS using EC2 for the web layer and RDS for the database layer, with a clear separation between public and private resources.</p><p>This type of architecture is widely used in real-world environments because it improves both security and scalability. The web server is accessible to users, while the database remains isolated and only accepts traffic from the application layer.</p><p>My approach here was to establish a solid, functional baseline by correctly structuring networking, access control, and communication between services.</p><p>From here, the next step is to extend this architecture by introducing a load balancer to remove direct public access to the EC2 instances and distribute traffic across multiple Availability Zones. This not only strengthens security but also prepares the environment for higher availability and scalability.</p><p>Even at the foundational level, the goal was to build with that direction in mind.</p><p><strong>Moving From Individual Services to Real Architecture</strong></p><p>Working with EC2 and RDS individually is one thing.</p><p>Designing how they communicate securely and reliably is something else entirely.</p><p>This project focused on that transition. Not just launching resources, but making intentional decisions around networking, access, and separation between layers.</p><p><strong>What I Built</strong></p><p>This architecture is made up of two main layers:</p><ul><li>A <strong>web layer (EC2)</strong> that handles user interaction</li><li>A <strong>database layer (RDS)</strong> that stores and retrieves data</li></ul><p>The key was not just standing both up.</p><p>It was making sure:</p><ul><li>The web layer is publicly accessible</li><li>The database layer is private</li><li>Communication between them is controlled and intentional</li></ul><p><strong>Building the Network Foundation</strong></p><p>One of the most important parts of this build was creating the networking foundation.</p><p>I built a custom VPC and separated the environment into public and private subnets across two Availability Zones. That separation gave the architecture structure and made the design much more intentional.</p><p>The EC2 instance was placed in a public subnet so the application could be reached, while the RDS instance was placed in a private subnet so that it remained isolated from direct public access.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*r6joRKQADsqCa4ER-hun6w.png" /><figcaption><em>“The networking foundation behind the two-tier design”</em></figcaption></figure><p>That separation is what gives this architecture its shape.</p><p><strong>Security Was a Big Part of the Design</strong></p><p>Security groups were one of the most important parts of this project.</p><p>Instead of simply opening access, I had to define exactly how communication should happen:</p><ul><li>The <strong>EC2 instance</strong> allows HTTP/HTTPS from the internet and SSH only from my IP address</li><li>The <strong>RDS instance</strong> does not allow public access at all</li><li>The database only accepts traffic from the EC2 security group</li></ul><p>That setup makes it clear that the database is not meant to be reached directly. It only exists to support the application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*JRmA0LZOWQEWGJAL1fAAuA.png" /><figcaption><em>“Access was intentionally controlled between the web and database layers”</em></figcaption></figure><p>This is where the architecture becomes more than just deployed resources. It becomes a designed system.</p><p><strong>The Database Layer Stayed Private by Design</strong></p><p>One of the most important settings during the RDS setup was:</p><p><strong>Public access: No</strong></p><p>That one setting reinforces the purpose of the database tier.</p><p>The database is not there to serve end users. It is there to support the application behind the scenes. Keeping it private reduces exposure and better reflects how database resources are handled in production-style environments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*RViHT5ytTunpIygui6835A.png" /><figcaption><em>“The database layer remained private and isolated from the internet”</em></figcaption></figure><p><strong>Bringing the Application Online</strong></p><p>After the infrastructure was in place, I installed Joomla on the EC2 instance and connected it to the RDS database.</p><p>This was the point where everything had to work together:</p><ul><li>networking</li><li>security groups</li><li>database configuration</li><li>application setup</li></ul><p>Once the Joomla installer successfully connected to the database, it confirmed that the architecture was functioning the way it was intended to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/836/1*haV7lbfwXx0eazntmj4mQA.png" /><figcaption><em>“Application and database connectivity confirmed”</em></figcaption></figure><p>That was the point where the build moved from infrastructure setup into a working application environment.</p><p><strong>The Final Result</strong></p><p>The final site itself is simple, but complete.</p><ul><li>The site is accessible through the EC2 public IP</li><li>The admin panel is functional</li><li>Content can be created and managed</li><li>Data is being handled through the RDS database layer</li></ul><p>That simplicity does not take away from the value of the build. In fact, it reinforces the point. The goal here was not visual complexity. The goal was solid architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*dE7XLMsUkmiZhY_MpDrMcQ.png" /><figcaption>“The Joomla admin portal confirmed the application layer was functional.”</figcaption></figure><p><strong>What This Project Reinforced</strong></p><p>This build reinforced a few key things:</p><ul><li>Architecture matters more than individual services</li><li>Security should be intentional, not assumed</li><li>Public and private boundaries must be clearly defined</li><li>Services should only have the access they actually need</li></ul><p>More than anything, it highlighted the difference between:</p><p><strong>Launching resources vs. designing systems</strong></p><p>That is where the real value of this project lives.</p><p><strong>A Quick Note on Scalability</strong></p><p>Although this project focused on the foundational implementation, I also wanted the design to reflect where it can go next.</p><p>The current setup establishes a clean starting point, but it also leaves room for architectural growth. The next logical step is to introduce a load balancer, remove direct public access to the EC2 instance, and distribute traffic across multiple Availability Zones.</p><p>That progression would improve both security and availability while moving the environment closer to a more scalable production-style design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*k_Igf1mTmPKq6p90ugexOQ.png" /><figcaption><em>“Foundational today, but already designed with scalability in mind”</em></figcaption></figure><p>I wanted to include this view as a reminder that even foundational builds can and should be approached with future-state thinking.</p><p><strong>Closing Thoughts</strong></p><p>This project was about building a strong and functional baseline.</p><p>Using EC2 and RDS in a properly structured two-tier architecture helped reinforce how web and database layers should be separated, secured, and connected.</p><p>It also created a clear path for what comes next: better traffic distribution, tighter access control, and higher availability through more scalable design choices.</p><p>For me, this project represents the kind of intentional architecture thinking that becomes more important as environments grow.</p><p>Still building. Still learning.<br> Still leaning into Comfort in the Cloud. ☁️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=057d47e5707d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From S3 to Secure: Taking My Website to CloudFront (and What AWS Doesn’t Tell You)]]></title>
            <link>https://medium.com/@mrsceebenton2/from-s3-to-secure-taking-my-website-to-cloudfront-and-what-aws-doesnt-tell-you-e5751aa41366?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5751aa41366</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-cloudfront]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws-cloudwatch]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Mon, 20 Apr 2026 00:10:38 GMT</pubDate>
            <atom:updated>2026-04-20T00:10:38.227Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*vdqE3WlwxngYaniv2_tL9Q.png" /></figure><h4>By Comfort Benton | Cloud Engineer</h4><p><strong>🔹 Introduction</strong></p><p>I took my website from S3 to CloudFront… and learned a lot more than I expected along the way.</p><p>What I thought would be a simple setup turned into a real lesson in how AWS actually works behind the scenes.</p><p>If you’re in the initial stages of working through CloudFront, this might save you some time.</p><p><strong>🔹 What I Built</strong></p><p>My goal was straightforward: take an existing static website and make it secure and production-ready.</p><p>Here’s the architecture I ended up with:</p><ul><li>Amazon S3 for static website hosting</li><li>Amazon CloudFront for content delivery and HTTPS</li><li>AWS Certificate Manager (ACM) for SSL</li><li>Cloudflare for DNS</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*Ajb4UT9JaeIkmKW2-7CM8g.png" /></figure><p>Simple on paper… a little more involved in practice.</p><p><strong>🔹 Step 1: S3 Static Website</strong></p><p>I already had my website hosted in S3 with static website hosting enabled. That part was smooth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*ZY-1CMPCbJtkes66jNoZXg.png" /></figure><p>At this point, the site was accessible, but only over HTTP and through the S3 endpoint.</p><p><strong>🔹 Step 2: SSL with AWS Certificate Manager</strong></p><p>To secure the site, I requested a certificate through AWS Certificate Manager in the N. Virginia region.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*X2vN2hqiL3ZFRfoXzG8crQ.png" /></figure><p>Since I use Cloudflare for DNS instead of Route 53 this time, I had to manually validate the domain. AWS gave me CNAME records to add and I added those into Cloudflare. Once those propagated, the certificate moved to <strong>Issued</strong>, and I was ready to move on.</p><p><strong>🔹 Step 3: CloudFront (Where Things Got Interesting)</strong></p><p>This is where things stopped being “click next and done.”</p><p>When I went to create a CloudFront distribution, AWS presented multiple options, including a “Free” plan and a “Pay-as-you-go” option.</p><p>At first, the free option seemed like the obvious choice. But it turns out the “free” flow actually limits your configuration. To properly attach my custom domain, use my SSL certificate and control behavior settings, I had to choose <strong>pay-as-you-go</strong>. Even though it’s not technically free for this setup, the cost is usually very low for a personal site with minimal traffic.</p><p>Since it’s pay-as-you-go, you’re only charged for what you use, which in my case amounts to very little.</p><p><strong>🔹 Origin Setup</strong></p><p>Next, I configured my origin by selecting my S3 bucket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*NbEgQA4BfKJd_aIBD8I1-g.png" /></figure><p>One key detail here:</p><ul><li>Use the <strong>S3 bucket endpoint</strong>, not the website endpoint</li></ul><p><strong>🔹 The Missing Settings (The Big “Wait… Where Is It?” Moment)</strong></p><p>After going through the setup, I realized something was missing.</p><p>There was no place to:</p><ul><li>add my domain</li><li>attach my SSL certificate</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*LnorUAgjwAYtiB6X-eqmzQ.png" /></figure><p>This was confusing at first.</p><p>What I learned is:<br> 👉 AWS doesn’t surface some of the most important settings during the initial setup flow.</p><p><strong>🔹 The Fix: Create First, Then Edit</strong></p><p>The solution was simple once I understood it:</p><ol><li>Create the distribution</li><li>Go back into settings</li><li>Edit the configuration</li></ol><p>That’s where everything finally showed up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*WqTuCC0-BmX4_5Lk5joPZg.png" /></figure><p>Here I was able to:</p><ul><li>Add my domain (comfortinthecloud.com and www)</li><li>Attach my ACM certificate</li><li>Set index.html as the default root object</li></ul><p>Once saved, CloudFront redeployed with the correct configuration.</p><p><strong>🔹 Step 4: Cloudflare DNS (Connecting Everything)</strong></p><p>With CloudFront fully configured, I updated my DNS in Cloudflare.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*akHbfkKTSEk1QubCiRSVqQ.png" /></figure><p>I created CNAME records for:</p><ul><li>root domain (@)</li><li>www</li></ul><p>Both pointing to my CloudFront distribution.</p><p>Important detail:<br> 👉 I kept them as <strong>DNS only (grey cloud)</strong> during setup to avoid SSL issues.</p><p><strong>🔹 End Result</strong></p><p>After a few minutes of propagation, everything came together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*WEH1vJCTOWi2GeO7HsHvdQ.png" /></figure><p>My site is now:</p><ul><li>Served through CloudFront</li><li>Secured with HTTPS</li><li>Accessible via my custom domain</li></ul><p><strong>☁️ Seeing What I Built, Not Just Hoping It Works</strong></p><p>Up until this point, everything I had done in AWS was about building.</p><p>S3 bucket, CloudFront distribution, SSL certificate. Everything was in place, and technically, my site was live.</p><p>But I realized something.</p><p>I had no visibility into what was actually happening behind the scenes.</p><p><strong>📊 Step 5: Enter CloudWatch</strong></p><p>This is where things shifted for me.</p><p>Instead of assuming everything was working, I wanted to actually see it.</p><p>So I built a simple CloudWatch dashboard. Nothing overcomplicated, just enough to answer three questions:</p><ul><li>Is my site being used?</li><li>Is it performing well?</li><li>Is anything breaking?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*7KvIhWgg6FbFl6FgB2SLOQ.png" /></figure><p><strong>🔍 What I Chose to Monitor</strong></p><p>I split my dashboard into two focused views.</p><p><strong>Website Traffic (CloudFront)</strong></p><p>This shows how users are interacting with my site and how much content is being delivered.</p><ul><li>Requests</li><li>Bytes downloaded</li></ul><p><strong>Error Rates (CloudFront)</strong></p><p>This shows whether anything is going wrong when users try to access the site.</p><ul><li>4xx errors (client-side issues)</li><li>5xx errors (server-side issues)</li></ul><p><strong>🚨 Adding Alerts<br> </strong>To take monitoring a step further, I created a CloudWatch alarm tied to my CloudFront traffic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*mdlhgf2c6FfTgOiqj-UuBg.png" /></figure><p>Since this is a low-traffic site, I set a very low threshold so I could test the alert in real time.</p><p>After refreshing my site a few times, the alarm triggered and I received an email notification.</p><p>This confirmed that the full monitoring pipeline was working end to end.</p><p><strong>🧠 What This Taught Me</strong></p><p>CloudWatch wasn’t just another AWS service to configure.</p><p>It was the moment I stopped just building resources and started understanding how my system behaves.</p><p>Instead of saying:</p><p>“My site is up!”</p><p>I can now say:</p><p>“My site is receiving traffic, delivering content, and not throwing errors.”</p><p>That’s a completely different level of confidence.</p><p><strong>🔹 Lessons Learned</strong></p><p>This project ended up being more valuable than I expected.</p><p>Here are a few takeaways:</p><ul><li>CloudFront setup isn’t as straightforward as it looks</li><li>The “free” plan can limit key configuration options</li><li>ACM DNS validation requires manual work outside Route 53</li><li>Cloudflare proxy settings can interfere with SSL if not handled carefully</li><li>Sometimes the correct approach is to <strong>create first, then edit after</strong></li></ul><p><strong>🔹 Final Thoughts</strong></p><p>This wasn’t just about getting a website online.</p><p>It helped me move beyond following steps and into actually understanding how these services connect.</p><p>And that’s where things really start to click.</p><p>I’m still building. Always learning.<br>Still leaning into Comfort in the cloud. ☁️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5751aa41366" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Highly Available Web Architecture]]></title>
            <link>https://medium.com/@mrsceebenton2/building-a-highly-available-web-architecture-4c2997c7d5ae?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c2997c7d5ae</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-engineering]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Mon, 13 Apr 2026 01:17:16 GMT</pubDate>
            <atom:updated>2026-04-13T14:45:57.756Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OY-SLDfvoKyUjtEpctG5tQ.png" /></figure><p><strong>with ALB and Auto Scaling</strong></p><p>By Comfort Benton | Cloud Engineer</p><p><strong>Architecture Overview</strong></p><p>This project focuses on building a simple but intentional cloud architecture that demonstrates high availability, controlled access, and scalable compute within AWS. This project reflects how core AWS services come together to form a resilient and controlled entry point for web traffic. Rather than working with services in isolation, the goal was to connect core components in a way that reflects how real-world environments are designed. Traffic enters through a single controlled entry point, is distributed across multiple availability zones, and reaches compute resources that are both protected and scalable.</p><p>Throughout this build, I focused not just on getting the environment to function, but on understanding why each layer exists. From networking to security to scaling, each decision contributes to a system that is reliable, accessible, and intentionally designed.</p><p><strong>Step 1: VPC and Network Setup</strong></p><p>I began by creating a custom VPC with the CIDR block:</p><p>10.10.0.0/16</p><p>Within this VPC, I created three public subnets:</p><ul><li>10.10.1.0/24 in us-east-1a</li><li>10.10.2.0/24 in us-east-1b</li><li>10.10.3.0/24 in us-east-1c</li></ul><p>Each subnet was configured to automatically assign public IP addresses.</p><p>An Internet Gateway was then attached to the VPC, and a route table was configured to allow outbound traffic to the Internet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*QP2foW-vDMUkWIqFNIpybw.png" /></figure><p><strong>Step 2: Security Design</strong></p><p>Security was an important part of this setup.</p><p>Instead of allowing direct public access to the EC2 instances, I configured two security groups:</p><ul><li><strong>ALB-SG</strong><br> Allows inbound HTTP (port 80) from anywhere</li><li><strong>Web-SG</strong><br> Allows inbound HTTP (port 80) only from the ALB security group</li></ul><p>This ensures that all traffic must pass through the load balancer before reaching the instances.</p><p>This design prevents users from accessing EC2 instances directly.</p><p><strong>Step 3: Launch Template and EC2 Configuration</strong></p><p>Next, I created a launch template for the EC2 instances.</p><p>Each instance was configured with:</p><ul><li>Amazon Linux AMI</li><li>t2.micro instance type</li><li>Web-SG security group</li><li>A user data script to install and start Apache</li></ul><p>The user data script also created a simple web page that displays the instance hostname. This made it easy to confirm that traffic was being distributed across multiple instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*VfOwEhSKmROcTxQiqIFtzA.png" /></figure><p><strong>Step 4: Target Group and Load Balancer</strong></p><p>I created a target group to manage the EC2 instances and perform health checks.</p><p>Then, I created an Application Load Balancer configured as:</p><ul><li>Internet-facing</li><li>Listening on HTTP (port 80)</li><li>Associated with all three public subnets</li><li>Using the ALB-SG security group</li></ul><p>The load balancer was connected to the target group so it could route traffic to healthy instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*LkLmxafBkSz7mRTBmFQNaQ.png" /></figure><p><strong>Step 5: Auto Scaling Group</strong></p><p>The Auto Scaling Group was created using the launch template and configured with:</p><ul><li>Minimum: 2 instances</li><li>Maximum: 5 instances</li><li>Subnets: all three public subnets</li></ul><p>This ensures that at least two instances are always running, while allowing the system to scale when needed.</p><p>The Auto Scaling Group was also attached to the target group so that all instances could receive traffic from the load balancer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*h2PfN3skSDuehJuPYrCkew.png" /></figure><p><strong>Step 6: Validation and Testing</strong></p><p>To validate the setup, I used the DNS name of the Application Load Balancer.</p><p>When accessing the URL in a browser, the Apache test page loaded successfully.</p><p>Refreshing the page multiple times returned responses from different instances, confirming that traffic was being distributed correctly across the Auto Scaling Group.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*yR7LMwR-LLls09VRuz8WIQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*eAlmCK7l1hjWeFw5RFrgkA.png" /></figure><p><strong>Key Takeaways</strong></p><p>This project helped reinforce several important concepts:</p><ul><li>High availability is achieved by distributing resources across multiple availability zones</li><li>Load balancers act as a controlled entry point into the system</li><li>Security groups can be used to restrict access and enforce architecture boundaries</li><li>Auto Scaling Groups help maintain system reliability and flexibility</li></ul><p>One key takeaway for me was understanding the importance of controlling access. Even though the EC2 instances were in public subnets, they were not directly accessible from the internet. All traffic had to pass through the load balancer.</p><p><strong>☁️ A Quick Discovery: When AWS Quietly Load Balances for You</strong></p><p>While reviewing my Application Load Balancer configuration, I noticed something that made me pause for a second.</p><p>I had intentionally built my architecture across three Availability Zones. But in the load balancer details, I saw a label that looked like a fourth Availability Zone:<br> use1-az4</p><p>At first glance, it felt like an extra Availability Zone had somehow been introduced into my setup.</p><p>But after digging a little deeper, I realized this was actually AWS doing something behind the scenes.</p><p>AWS uses two different ways to identify Availability Zones:</p><ul><li>The names we see, like us-east-1a, us-east-1b, and us-east-1c</li><li>Internal identifiers, like use1-az1, use1-az2, and use1-az4</li></ul><p>These internal IDs are consistent across AWS, while the letter-based names are mapped differently for each account. So even though I selected three zones, one of them is internally labeled as use1-az4.</p><p>In other words, nothing new was added. Nothing was misconfigured.</p><p>What I thought was an extra Availability Zone was really just a deeper layer of how AWS organizes and distributes infrastructure behind the scenes.</p><p>It was a subtle reminder that while I’m building for high availability at the surface level, AWS is also balancing things at a deeper level to keep workloads evenly distributed across its global infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*KS5yj7U0QkSfPxTx22oAWw.png" /></figure><p><strong>Final Thoughts</strong></p><p>This project brought together networking, compute, and security in a way that felt practical and realistic.</p><p>Instead of just learning individual services, I was able to see how they work together as a complete system.</p><p>It also reinforced the idea that building in the cloud is not just about getting something to run, but about designing it in a way that is scalable, secure, and resilient.</p><p>Still building. Always learning.<br> Still leaning into Comfort in the cloud. ☁️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c2997c7d5ae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Comfort in the Cloud ☁️
 (and learning to trust the process)]]></title>
            <link>https://medium.com/@mrsceebenton2/building-comfort-in-the-cloud-%EF%B8%8F-and-learning-to-trust-the-process-3166d7b7f158?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/3166d7b7f158</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <category><![CDATA[website-development]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Mon, 30 Mar 2026 18:51:33 GMT</pubDate>
            <atom:updated>2026-03-30T18:51:33.830Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*Wqq_tA80wvLgFZccrxFkug.png" /></figure><h3>By Comfort Benton | Cloud Engineer</h3><p>There’s a difference between learning something and actually building with it.</p><p>Lately, I’ve been working on a project I’m calling “Comfort in the Cloud.” At its core, it’s a simple static website. But for me, it represents something much bigger. It’s a place where I can document my journey, share what I’m learning, and create something that reflects both my technical growth and my personal style.</p><p>I didn’t start with a template. I started with an idea.</p><p>I wanted something that felt clean, modern, and intentional. Something that didn’t just say “I’m learning cloud,” but actually showed it.</p><p>So I built the layout from scratch, working through HTML and CSS, adjusting positioning, testing how things behaved on different screen sizes, and making small refinements until it felt right.</p><p>Along the way, I also spent some time exploring AI tools to experiment with design ideas and speed up small parts of the process. Not as a shortcut, but as another tool in the toolbox while I stayed hands-on with the build itself.</p><p>Some things worked immediately. Others didn’t.</p><p>There were moments where elements didn’t line up, where mobile behavior didn’t match desktop, and where I had to slow down and really understand what was happening instead of just trying to fix it quickly.</p><p>Those moments ended up being the most valuable.</p><p>Once the site was ready, I deployed it using Amazon S3 static website hosting. Seeing it live for the first time was one of those moments where everything clicks. Not because it was perfect, but because it was real.</p><p>From there, I wanted to go a step further.</p><p>I enabled server access logging and monitored real traffic hitting the site. I even set up notifications to validate when new log data was generated. It was a small addition, but it shifted my mindset from just building something to actually observing and understanding how it behaves.</p><p>This project isn’t finished.</p><p>It’s a living project that I’ll continue to build on, adding infrastructure as code, refining the architecture, and expanding what it includes as I grow in this space.</p><p>If you’re interested in the technical details, I’ve documented the process more deeply in my <a href="https://github.com/mrscee/cloud-engineering-journal-2026/blob/main/projects/20260301-CITC-S3-static-site/00.README.md">GitHub</a> repository.</p><p>For now, this is just the beginning.</p><p>And honestly… I’m enjoying the process more than I expected.</p><p>Still building. Still learning. Still leaning into comfort in the cloud. ☁️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3166d7b7f158" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Clicking to Command Line: Deploying EC2 with User Data, AMI, and AWS CLI]]></title>
            <link>https://medium.com/@mrsceebenton2/from-clicking-to-command-line-deploying-ec2-with-user-data-ami-and-aws-cli-9e31d28e24f2?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e31d28e24f2</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-ec2]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Mon, 23 Mar 2026 15:01:53 GMT</pubDate>
            <atom:updated>2026-03-23T15:01:53.842Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dQtW7Y4b21u5Xm7mQYlzcA.png" /></figure><h4>By Comfort Benton | Cloud Engineer</h4><p>I recently worked through an AWS project where I deployed a web server using EC2, automated the setup with user data, created a reusable AMI, and then took it a step further by provisioning everything through the AWS CLI.</p><p>At first, it felt like I was just following steps.</p><p>But somewhere between troubleshooting the CLI setup, understanding what “user data” actually meant, and adapting when AWS rejected my instance type, it started to click.</p><p>This is what working with infrastructure actually looks like. Not just launching resources, but defining and automating how they’re built from the start.</p><p><strong>What I Built</strong></p><ul><li>An EC2 instance that automatically installs Apache using user data</li><li>A reusable AMI to avoid repeating setup</li><li>A CLI-based deployment to simulate real-world workflows</li></ul><p><strong>The Shift That Made It Click</strong></p><p>Before this project, “user data” meant something completely different to me.</p><p>Like many others, I thought of it as information created by and connected to users, and that understanding was correct in its own context.</p><p>But in this setting, user data is:</p><p>A script that runs automatically when an EC2 instance launches.</p><p>That shift didn’t replace what I knew, it expanded it.</p><p>Instead of manually configuring a server, I was defining how it should be built from the start.</p><p><strong>CLI Execution (Provisioning Without the Console)</strong></p><p>Running this command to launch an instance made one thing very clear:</p><p>I don’t need to rely on the console to create infrastructure.</p><p>I can define it and deploy it programmatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/582/1*p9y961vRt63VhZcksf6Gpw.jpeg" /></figure><p><strong>Verification (Does It Actually Work?)</strong></p><p>Seeing the Apache “It works!” page load confirmed that everything came together as expected:</p><ul><li>the instance launched</li><li>the configuration was applied</li><li>the service was running</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/1*w_5C2P0UzIHo54dDa_0itg.jpeg" /></figure><p><strong>AMI Reuse (Build Once, Deploy Many)</strong></p><p>Creating an AMI allowed me to launch another instance with Apache already installed.</p><p>No additional setup. No repeated steps.</p><p>Just launch and verify.</p><p><strong>What This Project Taught Me</strong></p><p>This project helped me understand:</p><ul><li>how automation replaces manual setup</li><li>how consistency is achieved across deployments</li><li>how CLI usage aligns with real-world cloud engineering workflows</li></ul><p><strong>The Real Win</strong></p><p>The biggest takeaway wasn’t just getting the web server to load.</p><p>It was realizing that:</p><p>I can now launch infrastructure without relying on the console.</p><p><strong>What’s Next</strong></p><p>I’m continuing to build and document projects as I grow deeper into cloud engineering.</p><p>For a full technical breakdown, including commands and step-by-step details:</p><p>👉 See the full project on <a href="https://github.com/mrscee/cloud-engineering-journal-2026/blob/main/projects/20260223-ec2-user-data/20260223-ec2-user-data.md">GitHub</a>.</p><p>Still building. Still learning.<br>Still leaning into comfort in the cloud. ☁️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e31d28e24f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux System Health: Performance, Monitoring, and Failure Simulation]]></title>
            <link>https://medium.com/@mrsceebenton2/linux-system-health-performance-monitoring-and-failure-simulation-4d679b683c47?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d679b683c47</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Wed, 25 Feb 2026 01:23:21 GMT</pubDate>
            <atom:updated>2026-03-17T15:14:40.673Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6cqOZXw2uPuOrVW5sI6ozQ.jpeg" /></figure><p>By Comfort Benton | Cloud Engineer</p><p>Cloud engineering isn’t just about launching servers.<br> It’s about understanding how systems behave under pressure, detecting failures early, and keeping infrastructure reliable.</p><p>This project focused on real-world Linux system operations by testing performance, monitoring resources, simulating failures, and troubleshooting connectivity issues. Each scenario mirrors the type of work performed daily by Cloud Engineers, DevOps Engineers, and Site Reliability Engineers.</p><p>👉 For the full technical breakdown, commands, and detailed screenshots, <strong>click here to view the complete project on GitHub:</strong><br><a href="https://github.com/mrscee/cloud-engineering-journal-2026/blob/main/projects/20260214-linux-system-observability/linux-system-observability.md">https://github.com/mrscee/cloud-engineering-journal-2026/blob/main/projects/20260214-linux-system-observability/linux-system-observability.md</a></p><h3>🎯 What This Project Covers</h3><p>This project explores four core pillars of Linux system health:</p><p>This project explores four core pillars of Linux system health:</p><ul><li><strong>Performance benchmarking</strong> → How fast systems respond under load</li><li><strong>Resource monitoring</strong> → Detecting abnormal CPU usage</li><li><strong>Storage reliability</strong> → Understanding filesystem limits</li><li><strong>Network troubleshooting</strong> → Diagnosing connectivity issues</li></ul><p>The goal wasn’t just running commands. It was building engineering instincts:</p><ul><li>observe system behavior</li><li>capture evidence</li><li>simulate failure conditions</li><li>analyze results</li><li>think like an operations engineer</li></ul><h3>🖥️ Environment Setup</h3><p>All testing was performed in a controlled Linux environment.</p><h4><strong>Environment</strong></h4><ul><li>Ubuntu 24.04 LTS (VirtualBox VM)</li><li>Apache, NGINX, and Lighttpd web servers</li><li>Bash automation scripts</li><li>Linux monitoring and networking tools</li></ul><p>During setup, Apache was already using port 80, so NGINX and Lighttpd were reconfigured to run on alternate ports. This allowed fair testing conditions across all servers.</p><p>This mirrors real production environments where services must coexist without resource conflicts.</p><h3>🚀 Project Breakdown</h3><h3>1️⃣ Web Server Stress Test &amp; Performance Comparison</h3><h3>The Problem</h3><p>Choosing a web server based on preference alone can lead to poor performance decisions.<br> I tested Apache, NGINX, and Lighttpd under identical conditions to measure:</p><ul><li>response time</li><li>requests per second</li><li>CPU behavior</li></ul><h3>What I Did</h3><ul><li>installed and configured multiple web servers</li><li>created a shared HTML test page</li><li>built a Bash benchmarking script</li><li>monitored system resources during testing</li><li>compared performance results</li></ul><h3>What I Observed</h3><p>All servers reliably delivered static content with zero failed requests.</p><p>At low load:</p><ul><li>performance differences were minimal</li><li>CPU impact was small</li><li>configuration and monitoring mattered more than raw speed</li></ul><p>This reinforces a key cloud principle:</p><p><strong>Evidence-based decisions beat assumptions.</strong></p><h3>Real-World Connection</h3><p>This mirrors production capacity planning and infrastructure optimization used in cloud environments.</p><h3>2️⃣ Detecting CPU Overuse with Automated Monitoring</h3><h3>The Problem</h3><p>High CPU usage can silently degrade system performance before failures occur.</p><h3>What I Built</h3><p>A lightweight Bash monitoring script that:</p><ul><li>continuously checks CPU usage</li><li>calculates CPU busy percentage</li><li>triggers alerts when usage exceeds a threshold</li><li>validates behavior using simulated load</li></ul><p>I generated artificial CPU load using a background process to test alert behavior.</p><h3>What I Observed</h3><ul><li>CPU usage increased under simulated load</li><li>alerts triggered when thresholds were exceeded</li><li>system returned to normal once load stopped</li></ul><p>This demonstrates proactive monitoring — a core reliability practice.</p><h3>Real-World Connection</h3><p>This mirrors monitoring systems like:</p><ul><li>AWS CloudWatch</li><li>Prometheus</li><li>Datadog</li></ul><p>Early detection prevents downtime.</p><h3>3️⃣ Filesystem Health &amp; Storage Failure Simulation</h3><h3>The Problem</h3><p>Systems can fail from inode exhaustion even when disk space appears available.</p><h3>What I Implemented</h3><ul><li>created a loopback filesystem</li><li>configured limited inode capacity</li><li>enabled filesystem quotas</li><li>simulated storage exhaustion</li><li>observed system behavior</li></ul><h3>What I Observed</h3><p>When inode limits were reached:</p><ul><li>the system returned “No space left on device”</li><li>storage still had available space</li><li>quota limits prevented uncontrolled resource usage</li></ul><p>This highlights how Linux protects system stability through enforced limits.</p><h3>Real-World Connection</h3><p>This mirrors storage management in cloud platforms such as AWS EBS and EFS.</p><h3>4️⃣ Network Troubleshooting &amp; Connectivity Testing</h3><h3>The Problem</h3><p>Connectivity failures can occur at multiple layers and require systematic diagnosis.</p><h3>What I Tested</h3><ul><li>verified baseline network connectivity</li><li>simulated network failure using firewall rules</li><li>tested service availability during disruption</li><li>restored connectivity</li></ul><h3>What I Observed</h3><ul><li>blocking ICMP caused ping failures</li><li>services remained reachable</li><li>removing firewall rules restored connectivity</li></ul><p>This demonstrated layered troubleshooting and incident response workflows.</p><h3>Real-World Connection</h3><p>This reflects real production debugging used during network outages.</p><h3>💡 Key Takeaways</h3><ul><li>Linux systems require continuous monitoring</li><li>performance testing informs infrastructure decisions</li><li>storage limits can cause unexpected failures</li><li>automated alerts improve system reliability</li><li>structured troubleshooting reduces downtime</li></ul><h3>🚀 Reflection:</h3><p>This project strengthens the understanding of system observability and infrastructure reliability.</p><p>Rather than simply running commands, the approach is to evaluate system behavior, monitor performance, simulate failures, and troubleshoot issues using evidence.</p><p>These exercises reflect the operational mindset required in cloud engineering, where performance, monitoring, and reliability directly impact service availability and user experience.</p><h3>📚 Full Technical Walkthrough</h3><p>For full commands, scripts, screenshots, and implementation details:</p><p>👉 <strong>Click here to view the complete project on GitHub</strong><br> <a href="https://github.com/mrscee/cloud-engineering-journal-2026/blob/main/projects/20260214-linux-system-observability/linux-system-observability.md">https://github.com/mrscee/cloud-engineering-journal-2026/blob/main/projects/20260214-linux-system-observability/linux-system-observability.md</a></p><h3>⭐ Comfort in the Cloud Journey</h3><p>This project is part of my ongoing cloud engineering learning journey, documenting real hands-on experience in Linux, AWS, and infrastructure operations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d679b683c47" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enforcing Least Privilege in Linux: Users, Groups, and Permissions in Action]]></title>
            <link>https://medium.com/@mrsceebenton2/enforcing-least-privilege-in-linux-users-groups-and-permissions-in-action-892b285e65e3?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/892b285e65e3</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-engineering]]></category>
            <category><![CDATA[access-control]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 16:08:23 GMT</pubDate>
            <atom:updated>2026-02-10T14:05:15.097Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rucab2aZDywEzyKjXSQ9nw.jpeg" /></figure><h3>By Comfort Benton | Cloud Engineer</h3><p>Least privilege isn’t restrictive. It’s intentional.</p><h3>Synopsis</h3><p>For LU Corp’s multi-user Linux environments, not every user should have access to everything. Development, operations, and analytics teams often share the same system, but access must be tightly controlled to protect data and prevent mistakes.</p><p>In this scenario, Linux users, groups, and permissions were configured to enforce least privilege access, ensuring each user could only view and access the directory associated with their team.</p><p>Placeholder (dummy) files were used solely to simulate and validate access behavior before introducing live data.</p><h3><strong>The Goal</strong></h3><p>The objective was to implement proper access control using core Linux commands:</p><ul><li>Create three team directories</li><li>Create matching Linux groups</li><li>Restrict directory access to group members only</li><li>Create users and assign them to the correct groups</li><li>Verify access by switching users and testing permissions</li></ul><h3><strong>Approach</strong></h3><p>I approached this task by treating directories as protected resources and groups as access boundaries.</p><p>Rather than relying on assumptions, I validated permissions by switching into each user account and attempting to access every directory. This ensured the configuration worked as intended from a real user’s perspective.</p><h3><strong>Implementation</strong></h3><p><strong>Creating Team Directories</strong></p><p>I created three directories to represent separate teams:</p><ul><li>Development</li><li>Operations</li><li>Analytics</li></ul><p>Using a single command improved efficiency and reduced errors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*Y1rznS4OgRRiSupJ01YfuA.png" /></figure><p><strong>Adding Dummy Files</strong></p><p>To simulate real data without using a text editor, I created empty files using the touchcommand inside each directory.</p><p>This confirmed directory visibility and access during validation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*XLIS8XXDWIbOw4gfnfvlEg.png" /></figure><p><strong>Creating Groups</strong></p><p>Each directory was paired with a corresponding Linux group:</p><ul><li>Developers</li><li>Operations</li><li>Data-Analysts</li></ul><p>When a space caused an issue in a group name, I used a hyphen as a practical workaround. This mirrors real-world troubleshooting.</p><p><strong>Assigning Group Ownership</strong></p><p>Ownership of each directory was assigned to its respective group using the change ownership command.</p><p>This ensured access was governed by group membership rather than individual users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*rmgTx0iu4kBRVmVeuEsRXQ.png" /></figure><p><strong>Verifying Permissions with Octal Notation</strong></p><p>I think of octal permissions as compressed binary. Each digit represents three bits for read, write, and execute. Once you see it that way, permission sets are easier to reason about rather than memorize.</p><p>Directory permissions were verified using octal notation. While permissions are displayed symbolically as rwx, each permission triplet maps directly to an octal value, allowingrwxrwx---to be read as 770.</p><ul><li><strong>7</strong> = read + write + execute</li><li><strong>770</strong> = full access for owner and group, no access for others</li></ul><p>This prevented non-group users from even viewing restricted directories.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1011/1*bvXv2ysPh8xY37gyak4lBQ.png" /></figure><p><strong>Creating Users and Assigning Groups</strong></p><p>Three users were created and assigned to their respective groups:</p><ul><li>Jess Waller → Developers</li><li>Blake Dorsey → Operations</li><li>Joey Ewart → Data-Analysts</li></ul><p>Each user was provided with:</p><ul><li>A home directory</li><li>Group membership</li><li>Bash shell access</li></ul><p>Passwords were then configured to allow login.</p><h3><strong>Validation</strong></h3><p>Validation was a critical step.</p><p>Each user account was accessed individually, with user context verified using the whoamiand idcommands. These commands provide authoritative confirmation of identity and group membership independent of shell prompt customization.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/831/1*icHwyX720l292YJYAAW0SQ.png" /></figure><p>While switching users individually is practical for validating a small, representative set of accounts, permission models at scale are typically verified by inspecting directory ownership and permission bits directly using tools such as ls -ld, rather than logging in as every user.</p><p>Each attempt to access all directories confirmed the following:</p><p>· Users received permission denied errors for unauthorized directories</p><p>· Users successfully accessed only their assigned directory</p><p>· Placeholder files were visible and accessible where appropriate</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*aS5iaftKzteNC0RfobpC2A.png" /></figure><p>This confirmed that permissions were enforced correctly. The 770 permissions on each directory behaved exactly as intended.</p><h3><strong>Key Takeaways</strong></h3><ul><li>Linux permissions enforce least privilege by default</li><li>Groups simplify access control at scale</li><li>Octal notation becomes intuitive with practice</li><li>Validation is just as important as configuration</li></ul><p>This layout reinforced how foundational Linux access control is in real-world environments.</p><p>###</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=892b285e65e3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Amazon Linux 2 Still Matters:]]></title>
            <link>https://medium.com/@mrsceebenton2/why-amazon-linux-2-still-matters-dd9bf520ee4e?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd9bf520ee4e</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cloud-engineering]]></category>
            <category><![CDATA[apache]]></category>
            <category><![CDATA[learning-in-public]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Sun, 01 Feb 2026 19:45:57 GMT</pubDate>
            <atom:updated>2026-02-06T04:09:16.636Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Deploying an Apache Web Server on AWS</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1eY88-6cCAe2wkGXQGsTlg.jpeg" /></figure><p>By Comfort Benton | Cloud Engineer</p><p><strong>🟦 OVERVIEW</strong></p><p>As business continues to grow for L.U. Corp, a mid-sized technology company, the need for a reliable and scalable web presence becomes increasingly important. To support this growth, the organization has chosen to deploy an Apache Web Server on AWS, using Amazon Linux 2.</p><p>This decision is intentional. Apache, a free, open-source web server software that delivers website content over the internet, remains one of the most widely used web servers in production environments, particularly in industries where stability, flexibility, and security are critical. Financial institutions, in particular, rely on Apache to deliver web applications that must remain available, performant, and secure under varying levels of traffic.</p><p>By leveraging Apache on a Linux-based platform in AWS, organizations gain a proven solution that supports modular configuration, strong security controls, and long-term maintainability. This project explores the foundational steps required to deploy an Apache web server in a cloud environment, while highlighting why these technologies continue to matter in real-world production systems.</p><p><strong>🟦 APPROACH</strong></p><p>Step 1: Connect to the Amazon Linux 2 EC2 Instance via SSH</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/828/1*DD2qMjaQ5LqEtWqiDjVx6g.jpeg" /></figure><p>Step 2: Update System Packages</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/514/1*nok8mc1U2q8PpzSSsYHiZA.jpeg" /></figure><p>Step 3: Install Apache Web Server</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/513/1*ZrZgFxYUp64D_ir2N5lnSA.jpeg" /></figure><p>Step 4: Start and Enable Apache</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/428/1*EEk2j_zyFP1SBRyoGA60Qg.jpeg" /></figure><p>Step 5: Check Apache Status</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*ZOVYd7yt9Wpt_SM4eivk2w.jpeg" /></figure><p>Step 6: Allow HTTP Traffic in the Security Group</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*wDQDCp41hkn8s6AZOmonQA.jpeg" /></figure><p>Step 7: Verify Web Server in Browser</p><p>After installing and enabling Apache, I verified the web server by navigating to the instance’s public IP address in a browser. The Apache default test page loaded successfully, confirming that the web server was running and publicly accessible over HTTP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/901/1*RYg2GrNNh6HGGf7ZNNpsJw.jpeg" /></figure><p><strong>🟦 NEXT STEPS</strong></p><p>Create a simple index.html to resolve the test page issue and confirm that the server can successfully serve web content. You can use a text editor such as nano or vim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/557/1*P-MukED3H9FUe7WWCmh2pw.jpeg" /></figure><p>Refresh the browser to view the updated web content successfully.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*alHDzOJtBdyDROFa4O5THA.jpeg" /></figure><p><strong>🟦 OUTCOME</strong></p><p>The Apache web server was successfully set up on an Amazon Linux 2 EC2 instance and confirmed to be working through the instance’s public IP address. Seeing the Apache test page load in the browser verified that the server was installed correctly, running, and accessible over the internet.</p><p>After creating a custom index.html file, the default test page was replaced with personalized content. This step confirmed that the server could properly serve web files from its document root and that changes made on the server were reflected in the browser. Overall, this validated that the web server was functioning as expected in a cloud-based Linux environment.</p><p><strong>🟦 TROUBLESHOOTING SCENARIO</strong></p><p>Reviewing Apache Logs</p><p>After deploying the Apache web server, a common real-world scenario is receiving reports that a website is not loading as expected. When this happens, one of the first places to look is the web server logs.</p><p>Apache maintains two primary logs that help with troubleshooting:</p><ul><li><strong>Access logs</strong>, which record incoming requests to the server</li><li><strong>Error logs</strong>, which capture issues or failures encountered while processing those requests</li></ul><p>To simulate this scenario, I reviewed the most recent log entries to confirm that requests were reaching the server and to check for any reported errors. I viewed the latest entries (last 15 lines) from both the access and error logs to quickly assess the server’s status using the standard Linux commands below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/482/1*7GiRRMNbbmlCU2R46K1tmw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/448/1*0NNqKhxIyKam4hj23QaeeA.jpeg" /></figure><p>I then redirected these log outputs into separate files for easier review and record-keeping.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uod87bOtydXUF-J9f7x0uA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*9yAWjLZ1vRhoM_nO1uGt-Q.png" /></figure><p>This approach reflects how logs are often collected and analyzed when diagnosing issues in production environments and reinforces how logs play a critical role in identifying and resolving web server issues, even for simple deployments.</p><p><strong>🟦 KEY TAKEAWAYS</strong></p><p>· Deploying Apache on Amazon Linux 2 reinforced foundational Linux skills such as updating packages, managing services, and editing files.</p><p>· AWS security groups play an essential role in controlling access to cloud resources and must be configured correctly for public-facing services.</p><p>· Amazon Linux 2 is still widely used in production environments, making it valuable to understand, even as newer operating systems are introduced.</p><p>· Apache’s open-source nature makes it a cost-effective solution for hosting web content without additional licensing fees.</p><p>· Reviewing Apache access and error logs is a practical first step when troubleshooting reported website issues.</p><p>· Using a small EC2 instance for this project highlights how cloud resources can be used efficiently while keeping costs low.</p><p><strong>🟦 FINAL THOUGHTS</strong></p><p>What we have here is a practical introduction to deploying a web server in the cloud using widely adopted technologies. While the steps are foundational, they reflect real tasks that are still performed in production environments today.</p><p>Working through this setup helped build confidence with Linux, AWS, and basic web server concepts, while also emphasizing the importance of making intentional technology choices. Understanding how to deploy and verify simple infrastructure is an important first step toward more advanced cloud and DevOps work, especially when balancing reliability, security, and cost.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd9bf520ee4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How L.U. Corp Standardized Remote Access in AWS]]></title>
            <link>https://medium.com/@mrsceebenton2/how-l-u-corp-standardized-remote-access-in-aws-8c0b618a0281?source=rss-3ba2f8d65cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c0b618a0281</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws-ec2]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Comfort Benton]]></dc:creator>
            <pubDate>Sun, 25 Jan 2026 18:21:00 GMT</pubDate>
            <atom:updated>2026-02-06T04:09:40.027Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Use Case: Secure Remote Access via SSH and RDP</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/791/1*dai2ajNnumTBJbYpBd-gQw.jpeg" /></figure><p>By Comfort Benton | Cloud Engineer</p><p>🟦 <strong>CASE OVERVIEW | Secure Remote Access for EC2 Administration</strong></p><p>L.U. Corp, a mid-sized tech company, operates a growing portfolio of applications across Amazon Web Services (AWS), running a mix of Linux and Windows workloads on Amazon EC2. With development and operations teams distributed across regions, the company needed a reliable way for engineers to administer servers, perform maintenance tasks, and troubleshoot issues in real time.</p><p>However, the organization lacked a standardized, secure, and direct remote administration path into its EC2 instances. This gap made even routine operations slower than necessary, increased downtime during incidents, and created unnecessary friction for IT personnel working across time zones.</p><p>🟦 <strong>BUSINESS PROBLEM</strong></p><p>Without direct remote access to the operating system, troubleshooting often required escalation between multiple teams. In some cases, the IT staff relied on indirect or delayed methods to diagnose issues, such as:</p><ul><li>relaying commands through another engineer</li><li>relying solely on application-level monitoring tools</li><li>using slow ticket queues for operational changes, or</li><li>depending on shared documentation instead of real access</li></ul><p>These makeshift approaches are not uncommon in enterprises transitioning to cloud-first environments, but they restrict visibility and reduce operational control. They also introduce ambiguity in ownership during outages, particularly when multiple teams support the same workload.</p><p>Without standardized secure remote access, even simple tasks, like restarting a failed service or inspecting system logs, would take too long to diagnose, which would increase downtime, hurt productivity, and possibly raise security concerns among leadership.</p><p>🟦 <strong>PROPOSED SOLUTION</strong></p><p>To address the bottleneck, L.U. Corp standardized the foundational layer of remote administration by adopting:</p><ul><li>For Linux EC2 instances, use <strong>SSH</strong> for access</li><li>For Windows EC2 instances, use <strong>RDP</strong> for access</li></ul><p>Both protocols provide secure, encrypted channels for remote login and are widely supported across enterprise tooling, credentials, and workflows. This solution also sets the stage for more advanced access models in the future, such as AWS Systems Manager, IAM-managed permissions, or bastion host architectures. Below are the steps I took to set up their solutions.</p><p>🟦 <strong>Implementation for SSH for Linus EC2</strong></p><p><strong>1. Launch Amazon Linux instance type. After naming it what you want, then:</strong></p><p>a. Create a new key pair with type RSA and format .pem (Make note of where the key pair saves i.e. your Downloads folder)<br> b. Click Edit to change the Network settings.<br> c. Create a security group with a name and description<br> d. Choose type ssh (port 22), and<br> e. Choose My IP as Source type for single source admin connection<br> f. Finally, launch your instance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*LE4W5m5AYeFXWLP0eWKurg.jpeg" /><figcaption>Configuring a Linux EC2 instance with SSH access.</figcaption></figure><p><strong>2. Go to your instance page, then:</strong></p><p>a. Select the instance you want to connect to, and<br> b. Click Connect<br> c. In the Connect screen SSH tab, follow the steps to connect to your EC2 (Note: skip chmod command unless you’re a Linux or Mac user)<br> d. Copy the command to paste in ssh client (i.e. PowerShell)<br> e. In the SSH client, navigate to the folder with your pair key and paste the copied command, enter yes to continue, and you in securely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Shd0Ge3fbueXyAMnQ0QOcQ.jpeg" /><figcaption>Connecting to a Linux instance using SSH.</figcaption></figure><p>🟦 <strong>Implementation for RDP for Windows EC2</strong></p><p><strong>1. Launch a Windows Server instance type.</strong></p><p>a. Create a new key pair with type RSA and format .pem (This is used once to decrypt the Administrator password. You can reuse an existing key pair in your account if desired.)<br> b. Click Edit to change the Network settings.<br> c. Create a security group with a name and description<br> d. Choose type rdp (port 3389), and<br> e. Choose My IP as the source type for single source admin connection<br> f. Finally, launch your instance.</p><p><strong>2. Go to your instance page, then:</strong></p><p>a. Select the instance you want to connect to, and<br> b. Click Connect<br> c. In the new connect window, RDP client tab, click “Get password”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*5UuLUY8y16UUVE6NIn7wkQ.jpeg" /><figcaption>Retrieving RDP connection details for Windows EC2.</figcaption></figure><p><strong>3. Obtain the password by decrypting key pair</strong></p><p>a. Upload your key pair<br> b. Click Decrypt password<br> c. On your connection page you will have the connection name, username and password ready to use in your remote desktop client.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*tCSLe4V0aYqAMDOBOKUk8A.jpeg" /><figcaption>Decrypting the Windows admin password.</figcaption></figure><p><strong>4. Connect with RDP client</strong></p><p>a. Open the client<br> b. Use obtained credentials<br> c. When prompted for desktop connection, click Yes, and wait for a few screens to get you to the Windows graphical interface many of us are used to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dfs1WcIelfvPZp6iOoRzKg.jpeg" /><figcaption>Logging into the Windows EC2 instance via RDP.</figcaption></figure><p>🟦 <strong>OUTCOME</strong></p><p>By modernizing remote administration, L.U. Corp moved from slow, indirect troubleshooting to secure, real-time access. Outages resolve faster, engineers stay productive, and operations scale more gracefully as the environment grows.</p><p><strong>Key operational benefits included:</strong></p><ul><li>Faster incident response → Direct OS access removes delays caused by relays, ticket back-and-forth, or slow approval chains.</li><li>Security improvements → Encrypted access paths eliminate reliance on legacy or unencrypted tools.</li><li>Reduced downtime → Shorter recovery windows during outages minimize productivity and financial impact.</li><li>Higher productivity → Developers, support staff, and infrastructure engineers can troubleshoot independently.</li><li>Scalability → SSH and RDP scale naturally as the EC2 fleet grows, without major architectural overhead.</li></ul><p>Together, these improvements increase operational velocity, strengthen security posture, and align teams around a consistent and cloud-appropriate access pattern.</p><p>🟦 <strong>FUTURE ENHANCEMENTS</strong></p><p>While SSH and RDP provide a solid baseline, L.U. Corp could further mature its remote administration strategy through:</p><ul><li>AWS Systems Manager (SSM) for keyless access</li><li>IAM-based authorization for least-privilege control</li><li>Session Manager for full audit logging</li><li>Bastion hosts for private network access</li><li>Zero Trust models for workforce security</li></ul><p>These enhancements would reduce credential sprawl, improve auditability, and standardize access across larger infrastructure footprints.</p><p>🟦 <strong>KEY TAKEAWAYS</strong></p><ul><li>Secure remote access is foundational for distributed cloud operations.</li><li>SSH (Linux) and RDP (Windows) are practical, lightweight, and widely supported.</li><li>Standardization reduces friction during outages and routine maintenance.</li><li>Indirect operational models slow teams down and increase downtime.</li><li>Foundational improvements pave the way for more advanced access patterns.</li></ul><p>🟦 <strong>FINAL THOUGHTS</strong></p><p>Getting remote access right sounds simple, but it’s one of the biggest productivity multipliers for distributed teams working in the cloud. SSH and RDP may not be flashy, but once L.U. Corp standardized them, troubleshooting got faster, outages were less painful, and engineers stopped fighting the tools and started solving problems. And now that the foundation is in place, they’re positioned to explore more advanced access patterns without slowing down the business.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c0b618a0281" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>