<?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 Jason McKenzie on Medium]]></title>
        <description><![CDATA[Stories by Jason McKenzie on Medium]]></description>
        <link>https://medium.com/@jason.mckenzie?source=rss-47d52c77b2a5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*aB5FujUfwRxkj1PvUzNdmg.jpeg</url>
            <title>Stories by Jason McKenzie on Medium</title>
            <link>https://medium.com/@jason.mckenzie?source=rss-47d52c77b2a5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 03:51:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jason.mckenzie/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[EC2 Random Name Generator — A Simple Python Script for Clear AWS Instance Names]]></title>
            <link>https://medium.com/@jason.mckenzie/ec2-random-name-generator-a-simple-python-script-for-clear-aws-instance-names-a1da2c743182?source=rss-47d52c77b2a5------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1da2c743182</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ec2]]></category>
            <dc:creator><![CDATA[Jason McKenzie]]></dc:creator>
            <pubDate>Sun, 17 Aug 2025 21:34:01 GMT</pubDate>
            <atom:updated>2025-08-17T21:34:01.450Z</atom:updated>
            <content:encoded><![CDATA[<h3>EC2 Random Name Generator — A Simple Python Script for Clear AWS Instance Names</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M120QWck0KrRUu7-" /></figure><p>In shared AWS environments, instance names can get messy. When multiple departments spin up EC2s, ownership becomes unclear.</p><p>This short Python script solves that by printing unique, readable names that include a department prefix plus a small random identifier.</p><h3>The Scenario</h3><p>Several departments share an AWS account. Each EC2 instance should have a unique name that clearly shows which department owns it. You’re tasked with creating a Python script that:</p><ul><li>Asks the user how many names to generate</li><li>Asks the user for their department name</li><li>Generates that number of unique names in the format &lt;Department&gt;-&lt;letters&gt;_&lt;digits&gt; (4 lowercase letters + underscore + 4 digits) [this is somewhat arbitrary, but I felt it made them easier to read)</li><li>Prints the list so users can copy/paste or tag EC2 instances in the console or CLI</li></ul><h3>Sample Input &amp; Output</h3><p>This is what the program should look like when run:</p><p><strong>Input:</strong></p><pre>For how many EC2 instances do you need names?<br>4<br>What is your department name?<br>Octopus</pre><p><strong>Output:</strong></p><pre>Octopus-calm_6448<br>Octopus-tthj_4531<br>Octopus-rkul_4306<br>Octopus-ylnd_1496</pre><p>Based on the example user input, the output should include exactly 4 unique names, each combining the department name, a dash, a 4-character string of random lowercase letters, and underscore and then 4 random digits.</p><h3>How do we get there in Python?</h3><p>The script asks two questions — how many names to make and what the department name is — then converts the first answer to a number.</p><p>It stores that answeres and then runs a for loop that repeats the number of times requested.</p><p>On each pass, it builds a 4-letter lowercase string by randomly picking letters from a–z, and a 4-digit string by randomly picking digits 0–9; these are joined as letters_digits (for example, calm_6448).</p><p>The department name, a hyphen, and this identifier are concatenated to form a final instance name like Octopus-calm_6448, which is printed.</p><h3>The Code</h3><pre># This script generates easily readable unique names for EC2 instances <br># for a department per user request<br># example input: 4<br># example output: <br>#   Octopus-calm_6448<br>#   Octopus-tthj_4531<br>#   Octopus-rkul_4306<br>#   Octopus-ylnd_1496<br>import random<br>import string<br><br># Ask the user to input how many EC2 instances they want names for <br># and output the same amount of unique names<br><br>number_of_instances = int(input(&quot;For how many EC2 instances do you need names?\n&quot;))<br><br># Allow the user to input the name of their department that is used in the unique name<br>department_name = input(&quot;What is your department name?&quot;)<br><br># Generate unique identifiers for the total number required, composed of 4 random letters and 4 digits<br>for i in range(number_of_instances):<br>    letters = &#39;&#39;.join(random.choice(string.ascii_lowercase) for _ in range(4))<br>    digits = &#39;&#39;.join(random.choice(string.digits) for _ in range(4))<br>    instance_identifier = letters + &quot;_&quot; + digits<br>    instance_name = department_name + &quot;-&quot; + str(instance_identifier)<br>    print(instance_name)</pre><p>Easy peasy!</p><p>Since this is the first pure Python scripting scenario in our series, I’ll go ahead and include instructions for how to publish it to Github with both GitHub Desktop as well as through the CLI. They’re both pretty easy, so it’s down to your preference, or in a work situation, whatever your team requirements are.</p><h3>Publishing with GitHub Desktop</h3><p>If you’re using <strong>GitHub Desktop</strong>, follow these steps to upload your script:</p><ol><li>Open GitHub Desktop and click <strong>File → New Repository</strong></li><li>Name the repo something like ec2-name-generator</li><li>Set the <strong>local path</strong> where your Python file will live</li><li>Leave <strong>README</strong>, <strong>.gitignore</strong>, and license blank for now</li><li>Click <strong>Create Repository</strong></li></ol><p>Next:</p><ol><li>Open the folder GitHub Desktop created</li><li>Save your script as ec2_name_generator.py in that folder</li><li>Go back to GitHub Desktop — you should see the file listed as a new change</li><li>At the bottom, write a commit message like Initial script and click <strong>Commit to main</strong></li><li>Click <strong>Publish repository</strong> (top right) to push it to GitHub.com</li></ol><p>That’s it, your script is now public and shareable.</p><h3>GitHub CLI Method</h3><p>If you prefer using the terminal instead of GitHub Desktop:</p><pre>git init<br>git add ec2_name_generator.py<br>git commit -m &quot;Initial EC2 name generator script&quot;<br>git branch -M main<br>git remote add origin https://github.com/yourusername/ec2-name-generator.git<br>git push -u origin main</pre><p>This more or less mirrors the same steps we did in the desktop client, and once it becomes habit its much faster.</p><h3>Possible Next Steps</h3><ul><li>Add validation so only specific departments (e.g. Marketing, Accounting, FinOps) can use the script</li><li>Turn the code into a function for easier testing</li><li>Use the generated names in Terraform or CloudFormation tags</li></ul><p>Editorial note: You may have notice that the style of this post is a departure from my earlier series. Moving forward, we are going to be addressing a more technical audience, so fewer beginner-level explanations will be included. That said, if you have any questions or anything is confusing, please leave a comment and I’ll do my best to respond as I can!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1da2c743182" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Wave Hands Like Clouds: Episode 4 — Secure and Efficient Infrastructure Management]]></title>
            <link>https://medium.com/@jason.mckenzie/wave-hands-like-clouds-episode-4-secure-and-efficient-infrastructure-management-316e1339b1bc?source=rss-47d52c77b2a5------2</link>
            <guid isPermaLink="false">https://medium.com/p/316e1339b1bc</guid>
            <category><![CDATA[shell]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <dc:creator><![CDATA[Jason McKenzie]]></dc:creator>
            <pubDate>Mon, 26 May 2025 00:52:10 GMT</pubDate>
            <atom:updated>2025-05-26T00:58:34.971Z</atom:updated>
            <content:encoded><![CDATA[<h3>Wave Hands Like Clouds: Episode 4 — Secure and Efficient Infrastructure Management</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4-ocWX0vlG5ST6mBU7-pQ.png" /></figure><p>In our last episode, <a href="https://medium.com/@jason.mckenzie/wave-hands-like-clouds-episode-3-deploying-a-public-facing-apache-web-server-on-ec2-6ef5d5800c4e">Deploying a Public-Facing Apache Web Server on EC2</a>, we explored how to stand up a public-facing web server from scratch. This time, we’re shifting from the outward-facing to the inward-facing — where access, visibility, and internal structure determine how secure and resilient your infrastructure really is.</p><p><em>Estimated reading time: 9 minutes</em></p><p>Transcendental Bank is growing fast. That means new departments, new users, and new risks. As we scale our teams — Development, Operations, and Analytics — we need to ensure that every contributor has access to exactly what they need… and nothing more.</p><p>What begins as a simple file access policy quickly becomes a full exercise in user roles, group-based permissions, profile privacy, and administrative automation. We create groups to reflect functional teams, so we can grant access to shared resources without managing individual users one by one. This not only reduces admin overhead, but also ensures consistent, scalable access control as the organization grows.</p><p><strong>Managing users and permissions may seem basic, but it’s critical groundwork for any resilient, well-governed environment.</strong></p><h4>In this guide, we’ll walk through:</h4><ul><li>Creating team-based directories and Linux user groups</li><li>Enforcing strict access controls for files and user profiles</li><li>Verifying user isolation and permission boundaries</li><li>Automating everything with a single Bash script</li><li>Exploring where this intersects with scalable cloud IAM</li></ul><h3>🌦️ Phase 1: Creating Role-Based Access Controls</h3><p>Every secure system starts with a sensible structure. Our goal here is to build clear boundaries between teams: both for privacy and operational integrity.</p><p><strong>For this project, we’ll be using Ubuntu inside a Docker container, which gives us access to full Linux user and group management commands in a clean, disposable environment.</strong></p><h4>Step 1: Create Your Project Directory and Subfolders</h4><p>We’ll begin by creating a working directory in the root directory.</p><pre>cd /       # Navigate to the root directory<br>pwd         # Confirm your location is /</pre><p>Now create the project directory and subfolders:</p><pre>mkdir Transcendental<br>cd Transcendental<br>mkdir Development Operations Analytics</pre><h4>Step 2: Add Some Dummy Files</h4><p>Use brace expansion to quickly generate placeholder files:</p><pre>touch Development/file{1,2}.txt # just reuse the command and edit it so<br>touch Operations/file{1,2}.txt  # you don&#39;t have to keep retyping it<br>touch Analytics/file{1,2}.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*efp95flwwQr_LVOwCffnsA.gif" /><figcaption>Time to mk the dirnuts</figcaption></figure><p>Now let’s verify that all our directories and files are in the right place. You can use built-in tools like ls -R or find, but for a clearer, visual directory structure, we&#39;ll use tree. If it’s not already installed:</p><pre>apt update &amp;&amp; apt install -y tree</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*21jJKT5Wkt4PZkUwwCVF-g.png" /><figcaption>Planting the tree</figcaption></figure><p>Now that tree is installed, and we are in our working directory (/Transcendental), we can simpy run it:</p><pre>tree</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/493/1*ggy2fuWrTSUAEiRF4_TTHg.png" /><figcaption>Terminal output showing Development, Operations, and Analytics folders with dummy files inside.</figcaption></figure><p>Everything looks good, so now we can start adding and modifying our groups.</p><h4>Step 4: Create the User Groups</h4><pre>groupadd Developers &amp;&amp; groupadd Operations &amp;&amp; groupadd DataAnalysts</pre><p>You could create each group individually, but here we just use the Logical AND (ie. the “&amp;&amp;”) to chain the commands on one line and only run the next command if the previous one succeeds.</p><h4>Step 5: Assign Group Ownership</h4><pre>chown :Developers Development<br>chown :Operations Operations<br>chown :DataAnalysts Analytics</pre><p>Oops, I misspelled it “DataAnalytsts”, but it’s an easy fix with groupmod. The-n specifies the new name; the second argument is the old one.</p><pre>groupmod -n DataAnalysts DataAnalytsts</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*dPlqA1Afb1iQ_vN8ORhcIg.png" /><figcaption>groupmod</figcaption></figure><p>Now let’s configure our perms.</p><h4>Step 6: Set Directory Permissions</h4><p>Each user group should have exclusive access to its own directory — no cross-access, no visibility into other teams’ files.</p><p>First, set group ownership so each directory belongs to the right team:</p><pre>chown root:Developers Development<br>chown root:Operations Operations<br>chown root:DataAnalysts Analytics</pre><p>Then restrict access to each team’s directory:</p><pre>chmod 770 Development<br>chmod 770 Operations<br>chmod 770 Analytics</pre><p>This ensures:</p><ul><li>Only root and the assigned group can read, write, or enter the directory</li><li>All other users will be completely denied access</li></ul><p>Finally, allow users to enter and list the /Transcendental parent directory so they can find their own folder:</p><pre>chown root:root .<br>chmod 755 .</pre><p>This setup allows users to browse /Transcendental, see the directory names, and enter only the one that matches their group. All other directories will return &quot;Permission denied.&quot;</p><h4>Step 7: Create Users and Add to Groups</h4><p>To verify that each user can access only their assigned directory, we need to create them with the correct <strong>primary group</strong>. We’ll also assign passwords for testing, though in real environments this would typically be managed with key-based or federated access.</p><pre>useradd -m -g Developers -c &quot;Jess Waller&quot; jwaller<br>echo &quot;jwaller:ChangeMe123&quot; | chpasswd<br><br>useradd -m -g Operations -c &quot;Blake Dorsey&quot; bdorsey<br>echo &quot;bdorsey:ChangeMe123&quot; | chpasswd<br><br>useradd -m -g DataAnalysts -c &quot;Joey Ewart&quot; jewart<br>echo &quot;jewart:ChangeMe123&quot; | chpasswd</pre><p>This ensures that each user belongs only to their team group, matching the permissions set on the directories.</p><h4>Step 8: Verify Access as Each User</h4><p>Switch into each account and test our changes:</p><pre>su - jwaller<br>cd /Transcendental<br>ls                        # Should list all 3 directories<br>cd Development            # Should succeed<br>cd ../Operations          # Should fail<br>cd ../Analytics           # Should fail<br>exit</pre><pre>su - bdorsey<br>cd /Transcendental<br>cd Operations             # Should succeed<br>cd ../Development         # Should fail<br>cd ../Analytics           # Should fail<br>exit</pre><pre>su - jewart<br>cd /Transcendental<br>cd Analytics              # Should succeed<br>cd ../Operations          # Should fail<br>cd ../Development         # Should fail<br>exit</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*0MOo0knI8F09YpYjlFAlXA.png" /><figcaption>Expected successes and failures</figcaption></figure><h4><strong>Meditation on Phase 1</strong></h4><p>Access control is about more than permissions; it’s about deliberate design. You’re designing a system where collaboration is encouraged, but chaos is kept at bay. These early steps become the structure that everything else rests on.</p><h3>🌊 <strong>Phase 2: Enforcing Privacy at the User Level</strong></h3><p>Beyond team boundaries, personal data needs privacy. This phase ensures that users can’t snoop on each other’s home directories — a basic but essential compliance guardrail.</p><h4>Step 1: Lock Down Home Directories</h4><p>Each user’s home should only be accessible to themselves:</p><pre>chmod 700 /home/jwaller<br>chmod 700 /home/bdorsey<br>chmod 700 /home/jewart</pre><p>700 means only the user (owner) can read, write, and execute; no access for anyone else. Now let’s check they look right:</p><pre>ls -ld /home/*</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/1*p5NfZjnt0CeMxkiWMZzsDw.png" /><figcaption>All good in the hoods</figcaption></figure><h4>Step 2: Confirm the Lockdown</h4><p>Now that we’ve locked down each home directory to 700, it&#39;s time to verify that user privacy is actually enforced.</p><p>You can test this by switching to one user and trying to access another user’s home directory. For example:</p><pre>su - bdorsey<br>ls /home/jwaller</pre><p>If everything is working correctly, you’ll see the below, because Blake shouldn’t be able to list Joey’s home directory:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*EAnK9UrO6EuoRyeb6xj7eQ.png" /></figure><p>Repeat this check by trying to access the other users’ directories from any of the accounts.</p><p>What you’re confirming here is that:</p><ul><li>Each user <strong>can access their own home directory</strong></li><li>They <strong>cannot view, list, or read files</strong> in anyone else’s home</li></ul><p>This is a basic privacy safeguard — especially important in regulated environments where user separation must be strictly enforced.</p><h4><strong>Meditation on Phase 2</strong></h4><p>For security to work, it has to be the default, not an option or luxury. These constraints on user directories are part of the trust fabric between humans and machines. Respecting those boundaries by default avoids accidents you don’t want to have to investigate later.</p><h3>🌀 <strong>Phase 3: Automating It All with a Bash Script</strong></h3><p>Manual setup is fine once. But infrastructure isn’t static — people leave, teams shift, machines get redeployed. This final phase turns your process into a repeatable artifact.</p><h3>Creating the Script with vim</h3><p>To automate everything you’ve done manually, we’ll create a Bash script using the built-in text editor vim. If you’re new to Linux, vim is a terminal-based text editor — minimal, powerful, and a rite of passage for many developers. It comes pre-installed in most environments and is always there when you need it.</p><p>But fair warning: many developers and sysadmins have opened vim, and only later when they wanted to save their work and exit, realized they had no idea how to get out. Instead they just panicked, and added their name to the “Can’t exit vim” list.</p><p>Unlike typical editors, vim has <strong>multiple modes</strong>, and that’s where a lot of people get tripped up. The two main ones are:</p><ul><li><strong>Normal mode</strong> — where you navigate, delete, or copy text</li><li><strong>Insert mode</strong> — where you actually type</li></ul><p>This separation was designed for speed and efficiency: you can zip around and manipulate text without reaching for the mouse. But it also means if you start typing before switching to insert mode, vim will beep at you like a judgmental robot.</p><p>Here’s how to avoid that fate once you’re done editing:</p><ul><li>Press i to enter insert mode (so you can type or paste)</li><li>Press Esc to exit insert mode and return to Normal mode</li><li>Type :wq and press Enter to <strong>w</strong>rite and <strong>q</strong>uit</li></ul><p>Now, let’s actually use vim to write something. From your terminal, run:</p><pre>vim setup_transcendental.sh</pre><p>This opens a blank file in vim.</p><p>If you’re getting vim: command not found, which is common in minimal environments like Docker containers, just install it with:</p><pre>apt update &amp;&amp; apt install -y vim</pre><p>Once it’s installed, rerun the vim command above and proceed:</p><h4>Paste the script</h4><p>Press i to enter <strong>insert mode</strong>, then paste the full script below.</p><pre>#!/bin/bash<br><br># Create directories<br>mkdir -p /Transcendental/{Development,Operations,Analytics}<br><br># Add dummy files<br>touch /Transcendental/Development/file{1,2}.txt<br>touch /Transcendental/Operations/file{1,2}.txt<br>touch /Transcendental/Analytics/file{1,2}.txt<br><br># Create groups<br>groupadd Developers<br>groupadd Operations<br>groupadd DataAnalysts<br><br># Set group ownership<br>chown root:Developers /Transcendental/Development<br>chown root:Operations /Transcendental/Operations<br>chown root:DataAnalysts /Transcendental/Analytics<br><br># Set permissions<br>chmod 770 /Transcendental/Development<br>chmod 770 /Transcendental/Operations<br>chmod 770 /Transcendental/Analytics<br><br># Allow users to list parent directory<br>chown root:root /Transcendental<br>chmod 755 /Transcendental<br><br># Create users<br>useradd -m -g Developers -c &quot;Jess Waller&quot; jwaller<br>echo &quot;jwaller:ChangeMe123&quot; | chpasswd<br>chmod 700 /home/jwaller<br>useradd -m -g Operations -c &quot;Blake Dorsey&quot; bdorsey<br>echo &quot;bdorsey:ChangeMe123&quot; | chpasswd<br>chmod 700 /home/bdorsey<br>useradd -m -g DataAnalysts -c &quot;Joey Ewart&quot; jewart<br>echo &quot;jewart:ChangeMe123&quot; | chpasswd<br>chmod 700 /home/jewart<br>echo &quot;User and directory setup complete.&quot;</pre><h3>Save and exit vim</h3><p>Once the script is pasted in:</p><ol><li>Press Esc to exit insert mode</li><li><strong>Type </strong><strong>:wq and press </strong><strong>Enter to write and quit</strong></li></ol><p>Now you’re back at the terminal, and being able to successfully quit out of VIM will give you eternal bragging rights among nerds everywhere.</p><h3>Make it executable and run it — with caveats</h3><pre>chmod +x setup_transcendental.sh<br>sudo ./setup_transcendental.sh</pre><p>This runs the script with root privileges, creating all users, groups, files, and permissions exactly as defined.</p><h3>What Happens If You Run the Script Right Now?</h3><p>This script is designed for initial setup, but since we have already manually created and modified the groups etc, we could end up with some duplicates or shell errors if we ran it exactly as is right now. It’s mostly safe to run more than once: commands like mkdir -p and touch won’t cause problems if the files or directories already exist — they’ll just silently confirm or update them.</p><p>However, commands like groupadd and useradd <strong>will throw errors</strong> if the group or user already exists, and the script will stop at that point. Also, chpasswd will <strong>reset passwords</strong> for any existing users without warning.</p><p>If you wanted to make the script safely re-runnable — a property known as <strong>idempotency</strong> — you’d wrap the sensitive commands in checks (like if user doesn’t exist, then create). That’s useful in production scripts, but not strictly necessary here unless you&#39;re planning to re-run it right now without first cleaning up the directories etc. That’s beyond the scope of this post, so don’t worry about it now, just be aware if you wanted to actually test the script as is.</p><p><strong>Meditation on Phase 3</strong></p><p>Scripts provide a way to codify clear, reproducible intent, which make operations more efficient, as well as easier to troubleshoot and audit. Every automation is a statement of intent, a signal to future you (or your teammates) that this process matters enough to encode and preserve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q6jC4IKor4whjC2cwr0ZeA.png" /><figcaption>Wax (on, off)</figcaption></figure><h3>Final Thoughts</h3><p>Access control might seem mundane. But in modern organizations, it’s like the mortar holding your entire edifice together. When it’s done right, no one even notices, which is exactly the point. And by using scripts and Infastructure as Code, we enable efficiencies and audit trails that create significant quality of life for ourselves as well as our end users.</p><h3>Further Learning</h3><ul><li>U<a href="https://www.redhat.com/sysadmin/linux-file-permissions">nderstanding Linux File Permissions (Red Hat)</a></li><li><a href="https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html">AWS IAM Identity Center</a> — Role-based access at cloud scale</li><li><a href="https://docs.aws.amazon.com/systems-manager/index.html">AWS Systems Manager Documentation</a> — Remote access, patching, and user control</li><li><a href="https://sharats.me/posts/shell-script-best-practices/">Shell Scripting Best Practices, After a Decade of Scripting Things</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=316e1339b1bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Wave Hands Like Clouds: Episode 3— Deploying a Public-Facing Apache Web Server on EC2]]></title>
            <link>https://medium.com/@jason.mckenzie/wave-hands-like-clouds-episode-3-deploying-a-public-facing-apache-web-server-on-ec2-6ef5d5800c4e?source=rss-47d52c77b2a5------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ef5d5800c4e</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[apache]]></category>
            <category><![CDATA[system-administration]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Jason McKenzie]]></dc:creator>
            <pubDate>Mon, 19 May 2025 02:35:00 GMT</pubDate>
            <atom:updated>2025-05-26T00:57:41.352Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4-ocWX0vlG5ST6mBU7-pQ.png" /><figcaption>Chop Wood, Apache Server</figcaption></figure><p>In our last episode, we explored secure remote administration, which is to say, how to give systems access without leaving the doors wide open. If you missed it, you can catch up here: <a href="https://medium.com/@jason.mckenzie/wave-hands-like-clouds-episode-2-secure-remote-administration-in-aws-39176179938c"><strong>Episode 2 — Secure Remote Administration in AWS</strong></a>.</p><p>This week we’re shifting focus to something just about everyone takes for granted these days: <strong>the humble web server.</strong></p><p><em>Estimated reading time: 11 minutes</em></p><p>This project tackles a deceptively simple question: <strong>How do we deploy a reliable, scalable, and secure web server from scratch in AWS?</strong></p><p>Our client Transcendental Bank needs to provide customers with fast, secure access to their accounts online. And behind that mission sits the foundational infrastructure: an Apache HTTP server running on Amazon Linux 2. These choices form the basis of an open-source, battle-tested stack that is trusted by over half the internet.</p><p><strong>First released in 1995, Apache became the backbone of the early web and is the “A” in the classic LAMP stack (Linux, Apache, MySQL, PHP), powering millions of dynamic websites. While newer contenders like nginx, Caddy, and LiteSpeed have gained popularity for specific performance or ease-of-use advantages, Apache remains a flexible, robust choice — especially for teams who value transparency, extensive documentation, and deep configurability.</strong></p><p>So with a reliable choice for our stack, let’s begin. Here is the process we will follow:</p><ul><li><strong>Launch</strong> a secure Amazon Linux 2 EC2 instance in AWS</li><li><strong>Connect</strong> to the instance via SSH using a properly secured private key</li><li><strong>Install and configure</strong> the Apache HTTP Server</li><li><strong>Verify</strong> the server is publicly accessible via its IP</li><li><strong>Replace</strong> the default Apache page with a custom HTML message</li><li><strong>Inspect and redirect</strong> Apache logs to identify potential issues</li></ul><p>🌦️ <strong>Phase 1: Deploying Apache on Amazon Linux 2</strong></p><p>We start at ground zero: launching an EC2 instance and turning it into a functioning Apache web server. At a glance, this looks routine, but we’re setting the foundation for all future availability, routing, and security. At this step:</p><ul><li>A misconfigured security group could expose the server to the public internet.</li><li>A missing package update might leave it vulnerable to known exploits.</li><li>Forget to enable the web service on reboot? The site goes dark after every restart.</li><li>Even small oversights at this layer can lead to downtime, breaches, or a false sense of stability — all of which erode trust fast in customer-facing environments.</li></ul><p>But if we follow best practices and stay aware of our actions, we should be fine.</p><h4>Step 1: Launch the EC2 Instance</h4><p>From the AWS Console:</p><ul><li>Navigate to <strong>EC2</strong></li><li><strong>From the EC2 dashboard</strong>, click <strong>Launch Instance</strong>.</li><li><strong>Name and tags</strong>: Enter a name like transcend-apache-admin.</li><li><strong>Application and OS Images</strong>: Select <strong>Amazon Linux 2023 AMI</strong>.</li><li><strong>Instance Type:</strong> <strong>t2.micro</strong> (Free Tier eligible)</li><li><strong>Key pair (login): </strong>Click<strong> Create new key pair</strong> and follow the prompts, naming it something you will remember as associated with this project.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*GfrUCNBw5DrXmmK6JdH_bw.gif" /><figcaption>Quickly defining an EC2 instance and key pair</figcaption></figure><p><strong>We explained key pairs</strong> in the our last project, but while both options work here, <strong>best practice is to create a new key pair</strong> for each distinct environment or project. This ensures:</p><ul><li>You can clearly track which key is associated with which instance</li><li>You avoid accidentally reusing a key tied to unrelated systems</li><li>You demonstrate full ownership of the SSH setup, which is critical for secure operations</li></ul><p>After creation, be sure to <strong>download the </strong><strong>.pem file immediately</strong> —<strong> AWS will not let you access it again later.</strong></p><p><strong>Continuing on:</strong></p><ul><li><strong>Scroll down to Network Settings and c</strong>lick <strong>Edit.</strong></li><li>Under <strong>Firewall (security groups)</strong>, choose <strong>Create security group</strong>.</li><li>Set the <strong>Security group name</strong> ala transcend-apache-admin-sg.</li><li>Under <strong>Inbound security group rules</strong>, click <strong>Add security group rule</strong>:</li><li>Under</li><li><strong>SSH (port 22)</strong> from <strong>My IP</strong></li><li><strong>HTTP (port 80)</strong> from <strong>0.0.0.0/0</strong></li></ul><p>Launch the instance and wait for the “running” status.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*CgMqRqTumlgHhIU2N0kBag.gif" /><figcaption>Creating the Security Group and launching the EC2 instance</figcaption></figure><h4>Step 2: Connect via SSH</h4><p>You might recall from our last episode, that “SSH provides an encrypted tunnel between the administrator and the server, allowing sensitive commands and system changes to flow safely across public networks.” To establish this tunnel, you’ll again need the <strong>Public IPv4 address</strong> of the instance, which you can find back on the EC2 dashboard. Copy that and in your terminal, in a minute we’re going to run SSH to that address, specifying your .pem file for authentication.</p><pre>ssh -i /path/to/your-key.pem ec2-user@&lt;your-ec2-public-ip&gt;</pre><p>However before we do, we again have to make sure your key permissions are secure. Using the command line, navigate to the directory where your .pem file is located, then list the files to check the permissions:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*2MfmF_nUr1i_vtVLG_xqGw.png" /><figcaption>LSD FTW</figcaption></figure><p>Looks like our .pem file is set to 644, meaning anyone can read it. But you might recall, SSH requires that your private key file isn’t accessible to anyone else on your system. If it is, SSH refuses to use it. To fix this, we use chmod 400 — which sets the file’s permissions to <strong>read-only for the owner</strong>, and <strong>no access for anyone else</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*tzwLBBrbPEVhvEOOA_FKWQ.png" /><figcaption>Chmodding the pem</figcaption></figure><p>Checking perms again, we can see that the .pem is now changed from 644 to 400.</p><p>To demystify this process a little bit, chmod (short for <strong>change mode</strong>) controls who can <strong>read</strong>, <strong>write</strong>, or <strong>execute</strong> a file. It uses a three-digit octal format, where each digit represents a user group. Here, <strong>octal</strong> refers to <strong>base-8 numbering</strong>, where each digit (ie the 4, 0 and 0 of 400) represents a combination of read (which has a value of 4), write (2), and execute (1) permissions summed together, like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*fOMPTh-8_HReTJhC.jpg" /><figcaption>How UNIX permissions work</figcaption></figure><ol><li><strong>First digit</strong> = owner</li><li><strong>Second digit</strong> = group</li><li><strong>Third digit</strong> = others (everyone else)</li></ol><p>Each digit is a sum of:</p><ul><li>4 = read (r)</li><li>2 = write (w)</li><li>1 = execute (x)</li></ul><p>Some common UNIX permissions:</p><ul><li>400 = r-- --- ---<br> <em>Owner can read. No one else can do anything with it at all.</em> Common for sensitive credentials, authentication keys or personal files where no one else should even see the contents.</li><li>644 = rw- r-- r--<br> <em>Owner can read/write. Everyone else can read.</em> Ideal for public-facing content like HTML pages, or configuration files that users or services can reference but shouldn’t be changed.</li><li>755 = rwx r-x r-x<br> <em>Owner can read/write/execute. Others can read and execute.</em> Useful for scripts, binaries, applications or web directories where shared execution is required, but write access is restricted.</li><li>777 = rwx rwx rwx<br> <em>Everyone can read, write, and execute.</em> Suitable for open scratch directories or testing scenarios, but almost never appropriate in production due to security risk. Use with extreme caution, this grants full access to all users, and can provide a pivot point for bad actors depending on what the file is.</li></ul><p>By setting your private key to 400, you&#39;re telling your system: <em>Only I can read this, and no one else can touch it.</em> SSH needs that level of exclusivity to protect your credentials.</p><p>Now we can return to our SSH command and connect in:</p><pre>ssh -i /path/to/your-key.pem ec2-user@&lt;your-ec2-public-ip&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/966/1*9txdIcb8nheO7wXcjTLSdQ.png" /><figcaption>We’re in</figcaption></figure><h4>Step 3: Update Packages</h4><p>Now that we’re securely in our EC2 instance, we need to install Apache. However before we do, we want to follow best practice and <strong>update the system packages</strong> to ensure we’re working with the most secure and up-to-date environment.</p><pre>sudo yum update -y<br>sudo reboot</pre><p>After rebooting, the instance will temporarily disconnect. Once it’s back online, we <strong>reconnect via SSH</strong> the same way we did earlier using our .pem file and the Public IPv4 address.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fY1LF23IKxJCGQPDbUN80g.png" /><figcaption>Update, reboot and SSH back in</figcaption></figure><h4>Step 4: Install Apache</h4><p>Now we start getting to the good part… let’s get Apache installed and running. Our package manager, Yum, simply refers to Apache as “httpd”, that’s how ubiquitous Apache is as a web server.</p><pre>sudo yum install -y httpd<br>sudo systemctl start httpd<br>sudo systemctl enable httpd</pre><p>Check that it’s running:</p><pre>sudo systemctl status httpd</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TTkJ7Yl4wi9IO2krHtAlRQ.png" /><figcaption>Installing and checking Apache is running</figcaption></figure><h4>Step 5: Verify in the Browser</h4><p>Now that we have the Apache service up and running on our EC2 instance, let’s check that it’s actually serving pages from our browser. Plug your EC2’s public IP into your browser address bar…</p><pre>http://&lt;your-ec2-public-ip&gt;</pre><p>… And you should see the default Apache test page:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*tCLeM1KiOdkOi-dkRvqZ-g.png" /><figcaption>At least it doesn’t say Hello World</figcaption></figure><p><strong>Meditation on Phase 1</strong><br> A web server is more than software — it’s the heart of the World Wide Web. If that test page loads, you’ve created a visible, verifiable connection between infrastructure and human experience. Your machine speaks to the world.</p><p>Now we let’s have a little fun.</p><p>🌊 <strong>Phase 2: Customizing the Web Page</strong></p><p>Let’s replace the placeholder with a message of our own.</p><h4>Step 1: Create Your Custom HTML Page</h4><p>We’ll create a simple HTML page, and we can just use the CLI to write one line to do it:</p><pre>echo &quot;&lt;h1&gt;Welcome to Transcendental Bank - Black Team&lt;/h1&gt;&quot; | sudo tee /var/www/html/index.html</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rf9DwfRjfFdccn-kqr6YRg.png" /></figure><h4>Step 2: Confirm in Browser</h4><p>Now we can check it in our browser, just reload our page and we should see:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*aeTKVRAcMwjOInQW4AWI9Q.png" /><figcaption>Browser Check</figcaption></figure><p><strong>Meditation on Phase 2</strong><br>Small changes like editing index.html can feel insignificant, but they mark the moment a generic system becomes something personal. Doing it from the command line, instead of from an IDE, reinforces the efficiency and direct control available to those who know.</p><p>Even in highly automated environments, these hands-on steps help us stay close to the core of what we’re building and why it matters.</p><p>🌀 <strong>Phase 3: Troubleshooting with Apache Logs</strong></p><p>Let’s say something about our page breaks. The server is up, but the site’s not loading, or users are getting errors. It’s time to look under the hood. The first place to check is our logs, which hold a detailed record of what the server is seeing and doing.</p><p>In Apache, the logs usually live in /var/log/httpd/.</p><h4>Step 1: View the Last 15 Entries</h4><p>Since logs can often be massive files that would take forever to read through entirely, we often want to parse them different ways as we investigate. A common approach is to start by looking at the last bunch of logs that were created. We can do that with tail.</p><p>Specifically, using tail -n 15 lets us quickly view the last 15 entries in a log file, which is often enough to spot recent errors or verify activity without sifting through thousands of lines.</p><pre>sudo tail -n 15 /var/log/httpd/access_log<br>sudo tail -n 15 /var/log/httpd/error_log</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*rlE_myTLQ7c9m5qMU_XAZQ.png" /></figure><h4>Step 2: Save Logs with Timestamps</h4><p>But just knowing the sequence of events is often only part of the picture. If we need to compare the behaviors we’re seeing with other systems or events, knowing exactly WHEN something happened can help us see the causal connections between systems. We can use timestamps in our log names to create a lightweight audit trail, making it easier to track down when something went wrong, compare behavior across time, or hand off findings during peer reviews or support.</p><p>Redirecting log output into files like AccessLogs_2025-05-18.txt creates a snapshot of server activity at a specific moment in time, useful for later analysis or sharing with others.</p><p>The first line below creates a shell variable named DATE and assigns it the current date in YYYY-MM-DD format (e.g., 2025-05-18). We then use it to automatically include the date in the filenames for our log snapshots, like AccessLogs_2025-05-18.txt, so they&#39;re easy to track and organize.</p><pre>DATE=$(date +%F)<br>sudo tail -n 15 /var/log/httpd/access_log &gt; ~/AccessLogs_$DATE.txt<br>sudo tail -n 15 /var/log/httpd/error_log &gt; ~/ErrorLogs_$DATE.txt</pre><p>Now we confirm it’s working:</p><pre>ls ~/*.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*D4sYas9AkxXqAkDxzuhs8w.png" /></figure><p>We see that our log files now automatically get timestamped.</p><p><strong>Meditation on Phase 3</strong><br> Logs are the echo of experience. They tell us what happened, when, and why — but only if we know how to listen. A robust system isn’t one that never fails; it’s one that lets you <em>understand</em> failure quickly and act decisively.</p><p>This phase — quiet, observational, almost forensic — rounds out the practice of server deployment with a critical discipline: <em>operational awareness</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q6jC4IKor4whjC2cwr0ZeA.png" /></figure><h3>Final Thoughts</h3><p>From the outside, hosting a website might seem like flipping a switch. But as we’ve seen, every visible page is the result of a careful series of invisible decisions:</p><ul><li>What to expose (and what not to)</li><li>What to automate (and what to understand manually)</li><li>What to show the world — and how to keep it running</li></ul><p>Deploying an Apache server on Amazon Linux 2 is one of the most fundamental cloud exercises. But beneath its surface lies a profound lesson: <strong>infrastructure work is often quiet, repetitive, and overlooked — and that’s exactly why doing it mindfully matters.</strong></p><p>As the classic Zen saying goes:<br><strong>Before enlightenment, chop wood, carry water. After enlightenment, chop wood, carry water.</strong></p><h3>Addendum: Hardening and Archiving (Optional)</h3><p>Some thoughts how how to extend this project:</p><ul><li><strong>Log Archiving</strong>: Move Apache logs to S3 using the AWS CLI or configure log rotation with logrotate.</li></ul><p><strong>Security Enhancements</strong>:</p><ul><li>Use HTTPS with Certbot and Let’s Encrypt</li><li>Set custom permissions on /var/www/html</li><li>Configure Apache modules like mod_security or mod_ssl</li></ul><h3>Further Learning</h3><ul><li><a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon EC2 Key Pairs and Linux Instances (AWS Docs)</a><br> Understand how SSH key pairs work and how to manage them properly in EC2.</li><li><a href="https://docs.aws.amazon.com/linux/al2/">Amazon Linux 2 User Guide</a><br> The official documentation for Amazon Linux 2 — great for exploring system defaults and package management.</li><li><a href="https://httpd.apache.org/docs/current/">Introduction to the Apache HTTP Server</a><br> Core docs for Apache — includes directives, configuration structure, and module references.</li><li>Understanding Linux File Permissions (Red Hat)<br> A solid explanation of how chmod, chown, and file modes work under the hood.</li><li>Using tail, grep, and awk to Understand Logs (Linuxize)<br> Helpful primer on log inspection and streamlining your tail output.</li><li><a href="https://docs.aws.amazon.com/whitepapers/latest/logging-best-practices/logging-best-practices.html">AWS Best Practices for Logging</a><br> Broader strategies for using and managing logs effectively in cloud environments.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ef5d5800c4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Wave Hands Like Clouds: Episode 2 — Secure Remote Administration in AWS]]></title>
            <link>https://medium.com/@jason.mckenzie/wave-hands-like-clouds-episode-2-secure-remote-administration-in-aws-39176179938c?source=rss-47d52c77b2a5------2</link>
            <guid isPermaLink="false">https://medium.com/p/39176179938c</guid>
            <category><![CDATA[zero-trust]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[remote-access]]></category>
            <category><![CDATA[cloud-security]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Jason McKenzie]]></dc:creator>
            <pubDate>Fri, 02 May 2025 17:17:38 GMT</pubDate>
            <atom:updated>2025-05-05T20:48:07.192Z</atom:updated>
            <content:encoded><![CDATA[<h3>Wave Hands Like Clouds: Episode 2 — Secure Remote Administration in AWS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4-ocWX0vlG5ST6mBU7-pQ.png" /><figcaption>A Journey into the Zen and Art of Cloud Engineering</figcaption></figure><p>If you’re joining from Project 1, welcome back. If this is your first time here, <em>Wave Hands Like Clouds</em> is a series that explores cloud engineering as a craft — not just what we build, but how and why we build it. Each project aims to sharpen both technical skills and engineering intuition, blending practical steps with reflections on design, quality, and resilience. If you missed Project 1, you can check it out here: <a href="https://medium.com/@jason.mckenzie/welcome-to-wave-hands-like-clouds-a-journey-into-the-zen-and-art-of-cloud-engineering-45f67a97b8e4">Creating a Fast and Secure Static Website with AWS S3, CloudFront, and Global Acceleration</a>.</p><p>Now in Project 2, <strong>we turn our focus to securing remote access and administration for the infrastructure behind the scenes.</strong></p><p><em>Estimated reading time: 14 minutes</em></p><h3>Secure Remote Administration in AWS</h3><h3>Project 2 — Scenario Overview</h3><p>Transcendent Inc., a mid-sized tech company, leverages AWS Elastic Compute Cloud (EC2) to host both its Linux and Windows applications. With a growing number of EC2 instances running simultaneously, their dedicated IT team — distributed across multiple regions — handles the administration and maintenance of these systems.</p><p>But without a reliable, secure, and direct remote administration method in place, Transcendent’s IT operations were starting to feel the strain.<br> Challenges began stacking up:</p><ul><li>Longer response times when troubleshooting servers</li><li>Difficulty maintaining systems efficiently across time zones</li><li>Increased risk of security breaches from ad-hoc, inconsistent access methods</li></ul><p>Each missed connection or delayed fix didn’t just affect IT, it rippled outward into lost productivity, prolonged downtime, and elevated business risk.</p><p>Transcendent needed a better way to securely, reliably, and efficiently manage its infrastructure — one that could scale with them as they grew.</p><h3>Client Requirement</h3><p>The request was clear: implement a remote administration model for EC2 instances that strengthened security without slowing the IT team down.</p><p>Specifically, Transcendent needed:</p><ul><li>Direct, encrypted remote access to both Linux and Windows servers</li><li>Minimal exposure to the public internet</li><li>Streamlined administration that could support a globally distributed workforce</li><li>A remote access approach that would scale securely as new servers, new regions, and new team members were added.</li></ul><h3>Solution Overview</h3><p>We designed a three-stage approach:</p><ul><li>First, secure Linux server access using SSH (Secure Shell), a trusted, encrypted protocol for remote command-line administration.</li><li>Second, enable secure graphical access to Windows servers using RDP (Remote Desktop Protocol), configured carefully to minimize risk.</li><li>Third, introduce AWS Systems Manager Session Manager to eliminate open inbound ports entirely — enabling fully encrypted, role-based access without relying on network exposure.</li></ul><p>Each phase improved operational efficiency by reducing downtime and speeding troubleshooting, while also strengthening Transcendent’s security posture. By the final stage, we had set the groundwork for a modern Zero Trust model: one where access is granted based on identity and authorization, not network location. More about Zero Trust later.</p><h3>🌦️ Phase 1: Secure SSH Access to Linux EC2 Instances</h3><p>We began by securing remote command-line access to Transcendent’s Linux servers using SSH (Secure Shell).</p><p>SSH provides an encrypted tunnel between the administrator and the server, allowing sensitive commands and system changes to flow safely across public networks. But as with any powerful tool, if it’s left poorly secured — with open access to the world or mishandled credentials — it can quickly become a serious liability.</p><p>Our first goal is simple: <strong>Enable SSH access for trusted administrators, while tightly restricting exposure to everyone else. </strong>This would allow the IT team to troubleshoot and maintain Linux servers from anywhere they needed, without leaving broad attack surfaces open. We’ll start with creating a key pair.</p><h3>Key Pairs and Why They Matter</h3><p>Before connecting via SSH, AWS requires the use of a key pair: a cryptographic security mechanism that replaces traditional passwords.</p><p>When you create a key pair in AWS:</p><ul><li>You get a <strong>private key</strong> (a .pem file) that you must download and store securely.</li><li>AWS retains the <strong>public key</strong>, embedding it into the EC2 instance at launch.</li></ul><p>Think of your private key like the kind of wax seals people used to use on letters in the 1700s. You would cover the fold of the letter in wax and press it with your seal to prove that the letter came from you. If the letter arrived with the wax broken, the recipient would know the message had been compromised. But you didn’t need to send the seal itself, only the imprint on the wax. In the case of key pairs, the seal is the private key, and the imprint is the public key. AWS knows what your imprint should look like, and if the server verifies that you have a valid public key, it lets you in. No need to send your private key and risk someone else intercepting it.</p><p>So key pairs provide a simple, powerful form of identity verification, <strong>but</strong> it also means that losing your private key can lock you out permanently, and leaking it can invite unauthorized access. Best practice is to back up your private key securely, typically in an encrypted password manager or with services like AWS Secrets Manager.</p><p>Good key management is the invisible wall between your infrastructure and the outside world.</p><h3>Setting Up Secure SSH Access</h3><h3>Step 1: Create a Key Pair</h3><p>From the AWS Console:</p><ul><li>Navigate to <strong>EC2 &gt; Key Pairs</strong>.</li><li>Click <strong>Create Key Pair</strong>.</li><li>Name it clearly, such as transcendent-ec2-key.</li><li>Choose <strong>RSA</strong> as the key type. (it’s probably already selected by default)</li><li>Select <strong>.pem</strong> as the file format (for Linux/macOS).</li><li>Download the .pem file and store it safely.<br><strong> (You will not be able to retrieve it later.)</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*DDhNd-cWXcKzWcCek-ZMlA.gif" /><figcaption>Creating a Key Pair</figcaption></figure><h3>Step 2: Launch a Linux EC2 Instance</h3><p>With the key pair ready, we launched a Linux EC2 instance.</p><ul><li><strong>From the EC2 dashboard</strong>, click <strong>Launch Instance</strong>.</li><li><strong>Name and tags</strong>: Enter a name like demo-linux-admin.</li><li><strong>Application and OS Images</strong>: Select <strong>Amazon Linux 2023 AMI</strong>.</li><li><strong>Instance type</strong>: Choose <strong>t2.micro</strong> (eligible for free tier).</li><li><strong>Key pair (login)</strong>: Select thetranscendent-ec2-key.</li></ul><p><strong>Network settings:</strong></p><ul><li>Click <strong>Edit.</strong></li><li>Under <strong>Firewall (security groups)</strong>, choose <strong>Create security group</strong>.</li><li>Set the <strong>Security group name</strong> to something like demo-linux-admin-sg.</li><li>Under <strong>Inbound security group rules</strong>, click <strong>Add security group rule</strong>:</li><li><strong>Type</strong>: SSH</li><li><strong>Source</strong>: My IP</li><li>Protocol and Port will auto-fill as TCP and 22.</li></ul><p>Proceed with the remaining defaults and click <strong>Launch instance</strong>.</p><p>Restricting SSH access by IP address is crucial. It ensures that even if someone knows the public IP address of your server, they can’t simply attempt to brute-force their way in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*F0RZqYPCEl3Rz8K1MbEk3A.gif" /><figcaption>Launch a Linux EC2 Instance</figcaption></figure><h3>Step 3: Connect to the Instance</h3><p>Now that the instance is running, we need to connect to it using SSH. From the EC2 dashboard, copy the <strong>Public IPv4 address</strong> of the instance. We’ll need it to target the server from our terminal.</p><p>In the terminal, navigate to the directory that contains your .pem file. This way we won’t have to specify the entire pathname to our file.</p><p>Now that we’re in the correct directory, we can check the directory contents to make sure our .pem file is there. It is, so let’s try to SSH in, replacing &lt;your-ec2-public-ip&gt; with the address we copied a moment ago.</p><pre>ssh -i /path/to/transcendent-ec2-key.pem ec2-user@&lt;your-ec2-public-ip&gt;</pre><p>You might see the following if this is the first time you’ve tried</p><pre>The authenticity of host &#39;44.203.65.144 (44.203.65.144)&#39; can&#39;t be established.<br>ED25519 key fingerprint is SHA256:DsEP3lSNblVEijJLkylHCSfkZNPl0JhayAhbSpSdqv0.<br>This key is not known by any other names.<br>Are you sure you want to continue connecting (yes/no/[fingerprint])?</pre><p>If so, input “yes” and hit Enter.</p><pre>Warning: Permanently added &#39;44.203.65.144&#39; (ED25519) to the list of known hosts.<br>@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br>@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @<br>@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br>Permissions 0644 for &#39;transcendent-ec2-key.pem&#39; are too open.<br>It is required that your private key files are NOT accessible by others.<br>This private key will be ignored.<br>Load key &quot;transcendent-ec2-key.pem&quot;: bad permissions<br>ec2-user@44.203.65.144: Permission denied </pre><p>Ok, nope. <strong>Permission denied.</strong></p><p>Why? This is because SSH requires that credentials aren’t inadvertently exposed to other users on your system. To fix it, we have to restrict the file permissions so that only the owner has access to it:</p><pre>chmod 400 /path/to/transcdendent-ec2-key.pem</pre><p>Now we try again:</p><pre>ssh -i /path/to/transcendent-ec2-key.pem ec2-user@&lt;your-ec2-public-ip&gt;</pre><p>And we’re in. We could have also first checked that our change worked by checking the permissions on the file in the directory, but since our goal was to SSH, its success confirms it as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Exo9n4cjnO5MSTt0g-g01g.gif" /><figcaption>SSH into our EC2 on Linux</figcaption></figure><h3>Step 4: Validate the Connection</h3><p>Once connected, we verified our session by running:</p><pre>whoami</pre><p>and get the response…</p><pre>ec2-user</pre><p>Exactly what we expect.</p><p>Typically, legitimate administrators already know what account they logged in with, so they shouldn’t often need to run whoami. Here we are running it consciously as a quick validation check, but attackers frequently use whoami after breaching a system to figure out whether they’ve landed with high or low privileges. Fortunately for us, we’re the good guys, but we’re not root anyway.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*XGXa5wEn4eK9MhJsz-DRog.gif" /><figcaption>Am I root?</figcaption></figure><h3>Meditation on Phase 1</h3><p>So SSH gives administrators powerful control over remote systems — but with that power comes the need for careful boundaries.</p><p>By using strict IP address filtering, properly managed key pairs, and minimal exposure, Transcendent’s Linux servers were no longer quietly broadcasting themselves to the wider internet. Instead, access became something intentional, deliberate, and accountable. This is a critical step toward a more resilient remote administration model.</p><p><strong>With our Linux servers secured, the next step was to apply the same mindset to Windows, balancing ease of administration with tight security around RDP access.</strong></p><h3>🌊 Phase 2: Secure RDP Access to Windows EC2 Instances</h3><p>Windows administration requires a different toolset. Instead of command-line SSH sessions, administrators often need full graphical access — interacting with the desktop environment just as if they were physically present.</p><p>Remote Desktop Protocol (RDP) enables that — but like SSH, it’s a double-edged sword. If RDP access is left open to the public internet, it quickly becomes a prime target for attackers. Our approach followed the same principle as Phase 1: grant trusted administrators what they need, while leaving no extra pathways open.</p><h3><strong>Step 1: Launch a Windows EC2 Instance</strong></h3><p>We followed a similar process as with Linux to create a Windows server with secure RDP access.</p><ul><li><strong>From the EC2 dashboard</strong>, click <strong>Launch Instance</strong>.</li><li><strong>Name and tags</strong>: Enter a name like demo-windows-admin.</li><li><strong>Application and OS Images</strong>: Select <strong>Microsoft Windows Server 2022 Base AMI</strong>.</li><li><strong>Instance type</strong>: Choose <strong>t2.medium</strong> (Windows requires more memory).</li><li><strong>Key pair (login)</strong>: Select the existingtranscendent-ec2-key.</li></ul><p><strong>Network settings:</strong></p><ul><li>Click <strong>Edit</strong> under this section.</li><li>Under <strong>Firewall (security groups)</strong>, choose <strong>Create security group</strong>.</li><li>Set the <strong>Security group name</strong> to something like demo-windows-admin-sg.</li><li>Under <strong>Inbound security group rules</strong>, click <strong>Add security group rule</strong>:</li><li><strong>Type</strong>: RDP</li><li><strong>Source</strong>: My IP</li><li>Protocol and Port will auto-fill as TCP and 3389.</li></ul><p>Proceed with the remaining defaults and click <strong>Launch instance</strong>.</p><p>Leaving RDP open to the world (0.0.0.0/0) is one of the fastest ways to invite trouble. Restricting by IP address dramatically lowers the attack surface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*mOruyMaojoQYr3V_QqV0RQ.gif" /><figcaption>Launch a Windows EC2 instance</figcaption></figure><h3>Step 2: Retrieve the Administrator Password</h3><p>Once the instance status was <strong>running</strong> and <strong>checks passed</strong>, we retrieved the Administrator login credentials:</p><ul><li>Select the instance.</li><li>Click <strong>Actions &gt; Security &gt; Get Windows Password</strong>.</li></ul><p><strong>Upload the transcendent-ec2-key.pem file to decrypt the default password:</strong></p><ul><li>Click <strong>Browse</strong> and select your .pem private key file from your local machine.</li><li>Click <strong>Decrypt Password</strong>.</li><li>The decrypted password will appear in the <strong>Password</strong> field below, along with the instance’s public DNS name and username (<strong>Administrator</strong>).</li><li><strong>Copy the password — you’ll use it to log in via Remote Desktop in the next step.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*LyNDIgmwwYllBwRB4W6E9A.gif" /><figcaption>Copy the decrypted password to use in RDP in the next step</figcaption></figure><p>The Windows Administrator password is generated at launch and encrypted using the public half of the key pair. Unlike Linux, which tends to be more secure because it uses the private key directly for SSH authentication, Windows relies on username and password. AWS works around this by generating a random password, encrypting it with the public key, and requiring your private key to decrypt it.</p><p>So this adds a layer of security to our Windows’ instances, <strong>but password-based access is still generally more vulnerable than key-based authentication</strong>, since passwords can be guessed, reused, or phished, while private keys rely on stronger cryptographic safeguards.</p><h3>Step 3: Connect via Remote Desktop Client</h3><p>With credentials in hand, we used Microsoft’s Remote Desktop client to connect securely to the Windows EC2 instance.</p><p>First, we need to retrieve the <strong>Public DNS name</strong> of your instance from the EC2 dashboard under the <strong>Instances</strong> list. DNS is basically like a phone book for internet addresses. It associates host and domain names with IP addresses, so your computer knows which host on AWS to call.</p><p>The public DNS name is the hostname of your EC2 instance that allows connections from outside of AWS, but your instance will also have a private DNS name that AWS uses for internal communication between resources in the same VPC.</p><p><strong>Get the Public DNS Name</strong><br> Before connecting, retrieve the instance’s <strong>Public DNS (IPv4)</strong>:</p><ul><li>From the <strong>EC2 dashboard</strong>, select your instance.</li><li>In the <strong>Details</strong> tab below, copy the <strong>Public DNS (IPv4)</strong> field.<br> This will be used as the PC Name in the Remote Desktop client.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*X635fk7xbtauymr7UYUxWQ.gif" /><figcaption>Copy the Public DNS to paste in RDP in a moment</figcaption></figure><p><strong>For macOS:</strong></p><ul><li>If you haven’t used RDP before, you can download the <strong>Windows App</strong> (formerly Microsoft Remote Desktop) from the <strong>Mac App Store</strong>.</li><li>Open the app and click <strong>+ Add</strong> &gt; <strong>PC</strong>.</li><li>Enter your instance’s public DNS name (e.g., ec2-xx-xx-xx.compute-1.amazonaws.com) as the <strong>PC Name</strong>.</li><li>Under <strong>User Account</strong>, select <strong>Add User Account</strong>:</li><li><strong>Username</strong>: Administrator</li><li><strong>Password</strong>: (paste the decrypted password from earlier)</li><li>You might want to go to the Display tab and un-check “Start session in full screen” as well, otherwise RDP will takeover your entire display when it starts up.</li><li>Save the configuration and double-click the PC to connect, or click the three horizontal dots in the lower right corner of the PC Desktop box:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/351/1*U_WOO8yaqTeezo6SRxMcig.png" /><figcaption>Manually connect to your remote desktop</figcaption></figure><p>If we have done everything correctly, it will look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*B1f-NH-InAoH85-9___Pdw.gif" /><figcaption>Creating our RDP setup and connecting on Mac OS</figcaption></figure><p><strong>For Windows:</strong></p><p>I don’t have access to a Windows machine at the moment, but the process is a little easier there. Here are the instructions, let me know in the comments if you run into any issues with these!</p><ul><li>Open the <strong>Remote Desktop Connection</strong> application (search “RDP” or “Remote Desktop” in the Start Menu).</li><li>In the <strong>Computer</strong> field, enter the instance’s public DNS name.</li><li>Click <strong>Connect</strong>, then enter:</li><li><strong>Username</strong>: Administrator</li><li><strong>Password</strong>: (paste the decrypted password)</li></ul><p>Once connected, the Windows Server desktop appears just like it did on Mac OS, and is now accessible securely from your trusted IP address.</p><h3>Meditation on Phase 2</h3><p>Tools like RDP are built for speed and convenience. However we should be cautious, because convenience without care invites exposure.</p><p>By limiting RDP access to trusted IP addresses, encrypting credentials with strong keys, and avoiding unnecessary openness, Transcendent’s Windows servers stayed accessible to their administrators — and invisible to everyone else. But a good design doesn’t just give access, it specifically gives access only when, where and how it’s truly needed.</p><p><strong>But now even with SSH and RDP locked down, one question remained: can we go further and remove open access entirely? That question led us to AWS Systems Manager Session Manager.</strong></p><h3>🌀 Phase 3: Implementing Remote Access via Systems Manager (No Open Ports)</h3><p>With both SSH and RDP paths secured, Transcendent’s servers were already far less exposed than they had been before.</p><p>But there was still one unavoidable reality: <strong>Even tightly restricted inbound ports like SSH on 22 or RDP on 3389 are detectable.</strong> Anytime you leave a door open, even to just a few trusted IP addresses, you’re relying on the security of the perimeter.</p><p><strong>To tighten our security a step further, we needed to not just close the doors, but to remove the doors entirely. We can do that with AWS Session Manager.</strong></p><p>AWS Systems Manager Session Manager gave us direct, authenticated access to instances, and it does so without opening any inbound ports, or without requiring public IP addresses at all.</p><p><strong>This is where the concept of Zero Trust mentioned in the Solution Overview starts to come into focus.</strong></p><p><strong>In a Zero Trust model,</strong> access isn’t granted because you’re inside the network perimeter, or coming from a certain IP address. <strong>Access is granted only if you can continuously prove your identity and authorization, every time.</strong> So it doesn’t matter <em>where</em> you are, it matters<em> who</em> you are and that <em>you can prove</em> that’s who you are.</p><p>With Session Manager, Transcendent’s instances would no longer need to accept SSH or RDP traffic at all. Connections would flow through AWS’s encrypted management infrastructure, governed entirely by IAM roles and security policies.</p><h3><strong>Step 1: Launch an SSM-Ready Linux EC2 Instance</strong></h3><p>To prepare an instance for Systems Manager access without using SSH or public exposure:</p><ul><li><strong>From the EC2 dashboard</strong>, click <strong>Launch Instance</strong>.</li><li><strong>Name and tags</strong>: Enter a name like ssm-linux-admin.</li><li><strong>Application and OS Images</strong>: Select <strong>Amazon Linux 2023 AMI</strong>.</li><li><strong>Instance type</strong>: Use <strong>t2.micro</strong> if eligible for free tier.</li><li><strong>Key pair (login)</strong>: Choose <strong>Proceed without a key pair</strong> — we won’t need one.</li></ul><p><strong>Network settings</strong>:</p><ul><li>Click <strong>Edit</strong>.</li><li>Under <strong>Firewall (security groups)</strong>, select <strong>Create security group</strong>.</li><li>Set the <strong>Security group name</strong>, like ssm-admin-sg.</li><li>Add a brief <strong>Description</strong> if required.</li><li>Leave <strong>Inbound rules</strong> empty — there’s no need to open any ports.<br> <em>(If you’re reusing an existing security group, remove any inbound rules like SSH or RDP. Leaving those open would expose your instance unnecessarily, defeating the purpose of using Session Manager to eliminate public access.)</em></li><li>AWS automatically adds an <strong>outbound rule</strong> allowing all traffic. This ensures the instance can reach Systems Manager endpoints over the internet.<br> <em>(If you ever need to restrict or edit outbound access, you can do that later from the Security Groups section.)</em></li></ul><p>Proceed through the rest of the launch wizard and click <strong>Launch instance</strong>.</p><p>With no inbound rules, the instance won’t accept any public connections — a foundational step toward Zero Trust.</p><p>Easy peasy, <strong>no open ports means no public exposure. O</strong>nly authorized users can connect, which we are going to set up next using IAM roles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*xy_OUBCiNpeg2ZeRn-dGbg.gif" /><figcaption>Creating an EC2 Instance ready for SSM</figcaption></figure><h3>Step 2: Create and Attach an IAM Role for SSM Access</h3><p><strong>Step 2a: </strong>To allow the instance to communicate securely with AWS Systems Manager, we created a dedicated IAM Role:</p><ul><li>From the AWS Console, navigate to <strong>IAM &gt; Roles</strong> and click <strong>Create role</strong>.</li><li>Under <strong>Trusted entity type</strong>, select <strong>AWS service</strong>.</li><li>Under <strong>Use case</strong>, choose <strong>EC2</strong> and click <strong>Next</strong>.</li><li>In <strong>Permissions policies</strong>, search for and select <strong>AmazonSSMManagedInstanceCore</strong>.<br> <em>(This grants the necessary permissions for SSM to connect.)</em></li><li>Click <strong>Next</strong>, then give your role a clear name like EC2-SSM-Connect.</li><li>Click <strong>Create role</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*R2e149nEgCYLILrjiyr98w.gif" /><figcaption>Creating our IAM role for SSM</figcaption></figure><p><strong>Step 2b: </strong>After the role is created:</p><ul><li>Navigate to <strong>EC2 &gt; Instances</strong>, select your ssm-linux-admin instance.</li><li>Choose <strong>Actions &gt; Security &gt; Modify IAM Role</strong>.</li><li>Attach the EC2-SSM-Connect role to your instance and <strong>click Update IAM Role</strong> to save it.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*RuAyrWHVp68-QOKt2uoxQg.gif" /><figcaption>Attaching the role to our EC2 instance</figcaption></figure><p>Without this role, Systems Manager won’t be able to initiate sessions. This is a strict opt-in model, reinforcing security at the identity layer.</p><h3>Step 3: Connect via Session Manager</h3><p>Once the IAM role is attached and permissions are active:</p><ul><li>From the <strong>AWS Console</strong>, navigate to <strong>Systems Manager</strong>.</li><li>In the left-hand menu, under <strong>Node Tools</strong>, click <strong>Session Manager</strong>.</li><li>Click the <strong>Start session</strong> button.</li><li>You’ll see a list of instances that are available for Session Manager.<br> Look for your instance (e.g., ssm-linux-admin), select it and click <strong>Start session</strong> next to it.</li><li>If your instance doesn’t show up right away in Session Manager, don’t worry. It can take a minute or two for permissions to propagate across all AWS services after saving in the previous step. Just wait a moment and then refresh the page.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*kJ1oRthLsjRy6UeKnkGC9Q.gif" /><figcaption>Connecting to our EC2 with SSM</figcaption></figure><p>Within a few seconds, we landed in an encrypted browser-based shell session. So no more key files, public IP addresses, or open network ports.</p><p><strong>All authentication was handled through AWS IAM.</strong></p><h3>Step 4: Validate the Connection</h3><p>Inside the session, we ran:</p><pre>whoami</pre><p>This time, the session started as the ssm-user by default - a managed user context that Systems Manager uses to initiate connections securely.</p><p>To work with full administrative privileges as expected, we switched back to the default EC2 user:</p><pre>sudo su ec2-user</pre><p>After switching, a quick check confirmed:</p><pre>whoami</pre><p>Output:</p><pre>ec2-user</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*46bYl2D0ZH2CHhcYb4iq9Q.gif" /><figcaption>Switching to EC2 user</figcaption></figure><p>The instance was fully accessible — securely, privately, and with no inbound exposure.</p><h3>Meditation on Phase 3</h3><p><strong>Traditionally, remote access means leaving a door open and trying to guard it carefully.</strong></p><p>With Session Manager, there’s no door to guard. Access is requested, verified, and granted, but trust is never assumed.</p><p>Moving Transcendent’s servers into a Zero Trust model didn’t require a dramatic overhaul. It simply meant making deliberate choices — closing what didn’t need to be open, and trusting identities and policies rather than trusting networks.</p><p><strong>The result wasn’t just fewer vulnerabilities, it was a cleaner, simpler, and fundamentally stronger architecture.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q6jC4IKor4whjC2cwr0ZeA.png" /><figcaption>Thanks for reading Wave Hands Like Clouds!</figcaption></figure><h3>Final Thoughts</h3><p>In this project, we didn’t just set up remote access — we helped Transcendent rethink how they can manage their infrastructure more easily and securely.</p><p>We started with traditional SSH and RDP, secured as tightly as possible, then moved to a model where no inbound access was needed at all.</p><p>Each phase marked a small but meaningful shift: from trusting network location to trusting identity, from perimeter defenses to role-based control, from ad-hoc access to auditable sessions.</p><p>The benefits went well beyond better security on paper, to establishing faster connections when needed, fewer risks when not, and a simpler, stronger foundation for the team to build on.</p><h3>Looking Ahead</h3><p>In future projects, we’ll keep following the path from manual configuration towards full automation, exploring how to embed best practices like these into Infrastructure as Code (IaC) frameworks like Terraform and AWS CloudFormation.</p><p>Because managing remote access manually is good practice, and managing it predictably, repeatably, and automatically is even better.</p><p>Each step forward refines our discernment, sharpens our instincts, and deepens our craft as cloud engineers.</p><h3>Further Learning</h3><ul><li><a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html">AWS Systems Manager Session Manager Documentation</a></li><li><a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Best Practices for SSH and RDP Access</a></li><li><a href="https://aws.amazon.com/security/zero-trust/">AWS Zero Trust Architectures</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39176179938c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Welcome to Wave Hands Like Clouds— a Journey into the Zen and Art of Cloud Engineering]]></title>
            <link>https://medium.com/@jason.mckenzie/welcome-to-wave-hands-like-clouds-a-journey-into-the-zen-and-art-of-cloud-engineering-45f67a97b8e4?source=rss-47d52c77b2a5------2</link>
            <guid isPermaLink="false">https://medium.com/p/45f67a97b8e4</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[cloud-engineering]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Jason McKenzie]]></dc:creator>
            <pubDate>Sun, 27 Apr 2025 20:04:33 GMT</pubDate>
            <atom:updated>2025-05-05T20:46:45.052Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4-ocWX0vlG5ST6mBU7-pQ.png" /></figure><p>Welcome to the first entry in <em>Wave Hands Like Clouds — a Journey into the Zen and Art of Cloud Engineering — </em>a series diving into the practice of cloud engineering for those who want more than just tutorials.</p><p>If you’re new to cloud or AWS, you’ll find clear guides through projects with easy step-by-steps and videos/screenshots to follow along. If you’re more experienced, you’ll find reflections tucked along the way — observations about <em>the why</em> behind certain decisions, not just <em>how</em>. Each project aims to sharpen both our technical ability and engineering intuition as we explore the meaning of quality in our craft.</p><p><em>Estimated reading time: 11 minutes</em></p><h3>Creating a Fast and Secure Static Website with AWS S3, CloudFront and Global Acceleration</h3><h3>Project 1 — Scenario Overview</h3><p>A bank is moving its public-facing website from costly on-premises infrastructure to AWS. Their traditional hosting model left them vulnerable to rising costs, scaling challenges, and reliability risks — a setup ill-suited for a modern digital banking experience. They needed a scalable, secure, low-maintenance solution that improves customer experience and reduces IT overhead and lowers their operational expenditures.</p><p>Our task? To deliver that transformation cleanly, simply, and in a way that satisfies all of their business as well as technical objectives.</p><p>In this project, we take a three-phased approach to modernizing the bank’s website. First, we host the site on Amazon S3 to create a durable, serverless foundation; then we layer in CloudFront to improve global performance and enforce HTTPS security; and finally, we secure the architecture by restricting direct S3 access, ensuring all traffic flows through CloudFront.</p><h3>🌦️ Phase 1: Static Website Hosting on S3</h3><h3>Client Requirement:</h3><p>Re-host the bank’s static website from their on-premise servers using an Amazon S3 bucket, making it publicly accessible via a website endpoint.</p><h4><strong>Phase 1 Solution Overview:</strong></h4><p><strong>Amazon S3</strong> (Simple Storage Service) is scalable object storage designed for high durability, availability, and minimal management overhead. In this project, we’ll use it to serve the bank’s static website without running traditional web servers.</p><p>In Phase 1, we’ll create an S3 bucket, upload the website files, enable static website hosting, set the right public access permissions, and test that the site loads through the S3 website endpoint. This will give us a durable, serverless foundation for the bank’s public website.</p><h3>Step 1: Create the S3 Bucket</h3><ul><li>As in the short video below, go to the <strong>AWS Console </strong>and<strong> search for S3.</strong></li><li>Click <strong>Create bucket</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*PP5SG94zVPTz9CaS6d4R7g.gif" /></figure><ul><li><strong>Create your Bucket name.</strong> This name must be globally unique (e.g., levelupbank-site-a098ada0ss9a7s), so add some random alphanumeric characters at the end if you need to.</li><li><strong>Select or Verify your desired Region in the upper right corner</strong>: Best practice is to choose the one closest to your customer base. (e.g., United States (N.Virginia) / us-east-1)</li><li><strong>Important</strong>: Under <strong>Permissions</strong>, <strong>uncheck</strong> “Block all public access.”</li><li><strong>Acknowledge the warning</strong> about public access.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bU1LmYsxj1AerdB5ef7ekw.png" /></figure><ul><li><strong>Scroll</strong> to the bottom and click <strong>Create bucket</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8j1QwuQgBHYMGOMLFKHJAA.png" /></figure><h3>Step 2: Upload the Website Files</h3><ul><li><strong>Click on the bucket name</strong> to open the bucket.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bETZW_cvnK1szhGjRrCcmQ.png" /></figure><ul><li>Click <strong>Upload &gt; Add files</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/1*rnPBCP3rUz0L-Gg1NHAJFg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J2mfp4lZNawqJL1DIDjD1g.png" /></figure><ul><li><strong>Upload the provided</strong> index.html. <em>*(see Resources at end of article for the code example)</em></li><li>Set Permissions if necessary (we don’t need to for this example to work, but in production you should consider this according to your security and compliance requirements).</li><li><strong>Look for the green “Upload Successful”</strong> banner at the top of the page to confirm you have done everything correctly.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J_-pHRWD19lsk0PwXlYHtA.png" /></figure><h3>Step 3: Enable Static Website Hosting</h3><ul><li>Back in your bucket, navigate to <strong>Properties.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*q5RqI0bmF1iccRQd-R96jQ.png" /></figure><ul><li>Scroll down to <strong>Static Website Hosting</strong></li><li>Select<strong> Edit</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eIdO6wgOSUmBmiEsrW63rA.png" /></figure><ul><li><strong>Select Enable.</strong></li><li><strong>Specify your Index document</strong>: index.html</li><li><strong>Click Save.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vT6Nfs-j2Y12C07VwFFiwA.png" /></figure><ul><li><strong>Look for the green “Successfully edited static website hosting” banner</strong> at the top of the page.</li><li><strong>Copy the “Bucket website endpoint” URL</strong> and save it somewhere easy to find so we can verify the site is active later.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o-H4Cvzhz-cPhKpMRuk__g.png" /></figure><h3>Step 4: Set the Bucket Policy for Public Read Access</h3><ul><li>Navigate back to <strong>Permissions</strong> in your bucket.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*DIGIEtjupfx-q5NVE3Lo1g.png" /></figure><ul><li>Scroll down to <strong>Bucket Policy </strong>and click <strong>Edit.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*efg2Ca5Ux9GoZeT6qTUtnA.png" /></figure><ul><li><strong>Paste the policy below </strong>into the open Policy box, and in “<strong>Resource</strong>”, replaceyour-bucket-name with the name of the bucket you created.</li><li>Click <strong>Save Changes.</strong></li></ul><p>Note: There are many ways to get or create bucket policies based on your needs — that might be the subject of a later post!</p><pre>{<br>  &quot;Version&quot;: &quot;2012-10-17&quot;,<br>  &quot;Statement&quot;: [<br>    {<br>      &quot;Sid&quot;: &quot;PublicReadGetObject&quot;,<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:::your-bucket-name/*&quot;<br>    }<br>  ]<br>}</pre><p>Bucket policies are written in standard JSON format, so reviewing this, we can see that it allows public access to read objects from S3 storage. The “<strong>*</strong>” (asterisk) in the “Principal” item indicates that ALL objects in this bucket will be readable.</p><h3>Step 5: Verify Website Access</h3><ul><li>If you didn’t previously, go back to the Properties tab and copy the <strong>Bucket website endpoint.</strong></li><li>Open an I<strong>ncognito window </strong>if you’re using Chrome, otherwise use whatever form of private browsing mode your browser offers. This will ensure you’re testing a fresh version of the site without interference from browser caching, saved sessions, cookies, or previously stored credentials.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BecxD0JYgRhk991gCLIkpA.png" /></figure><ul><li>Paste the URL (bucket endpoint) into your address bar and load the page.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pSquTp_ZrkiSX6u33ATc2A.png" /></figure><h4><strong>You should see the website load successfully. Phase 1 complete!</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uwnje5o9Gq1MJ1qEyoxV3Q.png" /><figcaption>SHOW ME THA MONAAAAAY!!!</figcaption></figure><h3>Quick Meditation on Phase 1</h3><p><strong>By hosting the site in S3,</strong> we’ve made it <strong>durable</strong>, <strong>highly available</strong>, and <strong>globally reachable</strong> — without running servers or maintaining hardware.</p><p>For the business, this means <strong>lower costs</strong>, <strong>minimal downtime</strong>, and <strong>faster go-to-market</strong> for future updates. At the technical level, it’s a foundation that can scale almost infinitely without intervention.</p><p><strong>Now that the site is public and stable, in Phase 2 we’ll focus on making it faster and more secure for users around the world.</strong></p><h3>🌊 Phase 2: Global Performance + HTTPS with CloudFront</h3><h3>Client Requirement:</h3><p>Improve site performance for global visitors, enforce HTTPS-only access, and introduce caching to optimize speed and reliability.</p><h4>Phase 2 Solution Overview:</h4><p>Now that the site is live, we’ll create a CloudFront distribution to cache content globally, enforce HTTPS access, test secure redirection behavior, and verify that CloudFront caching works.</p><p><strong>Amazon CloudFront</strong> is a global content delivery network (CDN) that caches content closer to users and enforces security policies like HTTPS, dramatically improving the site’s speed, reliability, and security for users anywhere in the world.</p><h3>Step 1: Create a CloudFront Distribution</h3><ul><li>Go to <strong>CloudFront &gt; Create Distribution</strong>.</li><li><strong>Origin domain</strong>: Select the S3 Website Endpoint. Make sure to <strong>select Use Website Endpoint</strong> so it doesn’t use the bucket name by default. We select the Website Endpoint here because it supports HTTP access, which we’ll later secure and optimize through CloudFront.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*vaWztXl6onNeKinB1E3iXQ.gif" /></figure><ul><li><strong>Viewer Protocol Policy</strong>: Choose <strong>Redirect HTTP to HTTPS</strong>.</li><li><strong>Caching</strong>: Use the default cache settings.</li><li>In <strong>Web Application Firewall (WAF), </strong>choose<strong> Do not enable security protections.</strong></li><li>Click <strong>Create distribution</strong>.</li></ul><h3>Step 2: Wait for Deployment</h3><ul><li>You should see the distribution status is “Deploying”. It can take 10–15 minutes, so now might be a good time to take a quick break and come back.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0iVxxuVaJeT9AC9HzZkfmQ.png" /></figure><ul><li>Once it is deployed, you will see a timestamp in <strong>Last Modified</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SWdph67kyMYGlelegqZVAQ.png" /></figure><ul><li>Now that it’s confirmed deployed, it’s time to check that it’s working.</li></ul><h3>Step 3: Test HTTPS and Redirection</h3><p>Now that the distribution has deployed, we’ll test two key things:</p><ul><li>That the website loads successfully over <strong>HTTPS</strong></li><li>That any visitors using <strong>HTTP</strong> are automatically <strong>redirected</strong> to the secure HTTPS version.</li></ul><p>To do this, we will:</p><ul><li>Copy the <strong>Distribution Domain Name</strong> (e.g., d123abc.cloudfront.net) which is our CloudFront URL.</li><li>Open the CloudFront URL in a private browser.</li><li>Test both:</li><li>https://your-url.cloudfront.net → should load successfully</li><li>http://your-url.cloudfront.net → should <strong>redirect back to HTTPS</strong></li></ul><h3>Step 4: Make a Small Change to index.html to Test Caching Behavior</h3><p>Next, we’ll make a small edit to the website and confirm that CloudFront is caching the previous version correctly — a key part of ensuring faster global performance.</p><ul><li><strong>Step 4.1: Find or Download Your </strong><strong>index.html</strong></li><li>Locate the original index.html file you uploaded to S3. If you still have it saved locally, great. If not, you can download it directly from the S3 Console by selecting the file and clicking <strong>Download</strong>.</li><li><strong>Step 4.2: Edit the File</strong></li><li>Open the index.html file with any IDE or rich text editor, like VS Code, Notepad++ et al.</li><li>Make a very small change, just enough to clearly spot a difference. For example, find the “&lt;title&gt;” tag that looks like:</li></ul><pre>&lt;title&gt;Welcome to Level Up Bank&lt;/title&gt;</pre><p>and change it to:</p><pre>&lt;title&gt;Welcome to Level Up Bank Version 2 !!!!!!&lt;/title&gt;</pre><ul><li><strong>Important</strong>: Keep the structure of the page intact, just make small text edits.</li><li>Save your changes. (If asked about encoding options, just select default (UTF-8)).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aCQLc5fKLGfhvYE4d304Gg.gif" /></figure><ul><li><strong>Step 4.3: Upload the Updated </strong><strong>index.html to S3</strong></li><li>Go back to your S3 bucket in the AWS console.</li><li>Locate the existing index.html object.</li><li>Select it and Click <strong>Upload &gt; Add Files</strong></li><li>Choose your newly edited file (that has the same name — index.html).</li><li>Confirm the upload.</li><li><em>This replaces the object in S3 without changing the URL.</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*mSbhyMXfkh2C8gUDhzYcYg.gif" /></figure><ul><li><strong>Step 4.4: Test the Changes</strong></li></ul><p>First we will <strong>Test the changes using the S3 Object URL:</strong></p><ul><li>Navigate back to your bucket and click on the index.html.</li><li><strong>Copy the Object URL</strong> — it usually looks like <a href="https://s3.amazonaws.com/your-bucket-name/index.html).">https://s3.amazonaws.com/your-bucket-name/index.html)</a>.</li><li>Back <strong>in your private browser, open the direct S3 Object URL</strong> for index.html.</li><li><strong>You should immediately see your updated changes (in our example, a new page title), confirming the change is now live in S3.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SQM1BSUrbt0Wd7bEVi8pqw.gif" /></figure><p>Now we will <strong>Test via CloudFront URL:</strong></p><ul><li>Open the CloudFront URL (e.g., <a href="https://d123abcxyz.cloudfront.net),/">https://d123abcxyz.cloudfront.net),</a> either by locating the URL again or refreshing the page.</li><li><strong>You should still see the old version of the site, which confirms that CloudFront is correctly caching the previous version to optimize global performance.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3i3yqKTIN65Dm9YMFpW1Rw.gif" /></figure><h4>CloudFront is still loading the old version, exaclty as expected. Phase 2 complete!</h4><h3>Quick Meditation on Phase 2</h3><p><strong>By introducing CloudFront,</strong> we accelerated page loads for users anywhere in the world and enforced <strong>secure, encrypted access</strong> by default.</p><p>For the business, this means <strong>happier customers</strong>, <strong>higher conversion rates</strong>, and <strong>lower bandwidth costs</strong> thanks to intelligent caching.</p><p>Technically, it offloads traffic from the S3 bucket and positions us for global scalability without adding complexity.</p><p>Now that performance and security are in place, <strong>the next step is tightening the security perimeter around our storage layer itself</strong>.</p><h3>🌀 Phase 3: Locking It Down — CloudFront-Only Access</h3><h3>Client Requirement:</h3><p>Ensure the website is only accessible through CloudFront, blocking any direct access to the S3 bucket.</p><h3>Phase 3 Solution Overview:</h3><p>Now that the website is live and accelerated through CloudFront, our final step is to harden the architecture by ensuring that users cannot bypass CloudFront and access the S3 bucket directly.</p><p>We’ll tighten security by removing any public read permissions from the bucket and relying solely on CloudFront to serve the content.</p><h3>Step 1: Remove Any Previous Public Access</h3><ul><li>Go to your S3 bucket in the AWS Console.</li><li>Navigate to <strong>Permissions &gt; Bucket Policy</strong>.</li><li>Delete any existing bucket policies that allow &quot;Principal&quot;: &quot;*&quot; or public reads.</li><li>Save your changes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3zmmoS7I4jvI1lgboaT_Vg.gif" /></figure><ul><li><strong>This ensures that even if someone knows the bucket’s address, they cannot fetch objects directly.</strong></li></ul><h3>Step 2: Block All Public Access at the Bucket Level</h3><ul><li>In the <strong>Permissions</strong> tab, locate <strong>Block Public Access (Bucket Settings)</strong></li><li>Enable <strong>all four block public access settings</strong>.</li><li>Save your changes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aq_BZVAdvlc8FeDrfynlAA.gif" /></figure><ul><li><strong>Blocking public access at the bucket level protects your storage, even if object permissions are accidentally misconfigured.</strong></li></ul><h3>Step 3: Test the Access Controls</h3><p>Now that we’ve removed public permissions and blocked direct bucket access, we need to verify two things:</p><ul><li>That users can no longer access the S3 bucket directly.</li><li>That CloudFront is still serving the site correctly.</li></ul><p>Testing both paths ensures our security changes didn’t accidentally break the customer experience. In production environments, access validation is typically automated with tools or scripts to catch misconfigurations early.</p><p><strong>Test Direct S3 Object URL:</strong></p><ul><li>Open your S3 Object URL (e.g., https://s3.amazonaws.com/your-bucket-name/index.html) in a private/incognito window.</li><li>You should receive an <strong>Access Denied</strong> error, because the S3 bucket no longer allows public reads. This confirms that the S3 bucket is no longer serving public traffic directly.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XaiMZ3LLcmpQRTQ5paVsAw.gif" /></figure><p><strong>Test CloudFront URL:</strong></p><ul><li>Open your CloudFront Distribution URL (e.g., https://d123abcxyz.cloudfront.net) in a private/incognito window.</li><li>The website should load successfully. This confirms that CloudFront remains authorized to fetch and serve content securely from S3.</li></ul><h4>Our access control is working exactly as designed: direct S3 access is blocked, CloudFront serves content securely.</h4><h3>Phase 3 complete, Project 1 complete!</h3><p><strong>Optional Security Enhancement: Disable S3 Static Website Hosting</strong></p><ul><li>Now that CloudFront fully handles user traffic, we can disable S3’s native static website hosting. This prevents accidental direct access through the old S3 website endpoint and ensures all requests flow through CloudFront’s secured, optimized path. Disabling static website hosting removes the public S3 website URL but does not affect CloudFront’s ability to access the bucket privately.</li><li>To do this, go to your bucket’s <strong>Properties</strong> tab, scroll to <strong>Static website hosting</strong>, select <strong>Disable</strong>, and save.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*STFG8N548WUNaXSBpJHjLg.gif" /></figure><p><strong>Why we aren’t enabling WAF (Web Application Firewall):</strong></p><ul><li>With the website fully routed through CloudFront, there are further security enhancements we could add if needed. In production environments it’s a best practice to enable a Web Application Firewall (WAF) in CloudFront to protect against common vulnerabilities and malicious traffic. We aren’t enabling WAF here for simplicity and learning clarity, but it’s a recommended enhancement to harden security even further.</li></ul><h3>Quick Meditation on Phase 3</h3><p><strong>By locking down direct S3 access,</strong> we centralized control over how users reach the site — a key move for <strong>compliance</strong>, <strong>security</strong>, and <strong>cost protection.</strong></p><p>For the business, this strengthens <strong>customer trust</strong> and <strong>regulatory posture</strong>, while making operations cleaner and easier to audit.</p><p>Technically, it <strong>sets the stage for future enhancements</strong> like Web Application Firewall (WAF) or DDoS protection without changing the storage layer.</p><h3>Head in the Clouds, Feet on the Ground</h3><p>Sometimes it can be tempting to rush to the end result — skipping critical validations or assuming configurations will work as intended — but in real-world production environments, quality cloud engineering demands a measured approach.</p><p>By designing with intention at every step, intentionally validating security, access patterns, and performance before moving to the next stage, we build architectures that are not just fast and secure, but limit risks and strengthen the system for real-world pressures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q6jC4IKor4whjC2cwr0ZeA.png" /></figure><h3>Final Thoughts</h3><p>The art of cloud engineering isn’t just about building off-site — it’s about building <em>right</em>.</p><p>Sometimes that means combining simple primitives like S3, CloudFront, and IAM policies in the right way into something resilient, scalable, and secure.</p><p>From a business perspective, this migration <strong>reduced operating costs, improved global user experience, </strong>and<strong> strengthened security</strong> — all <strong>without adding complexity or risk</strong>.</p><p>And last but certainly not least — <em>we didn’t need to do ANY OF THIS manually from the AWS console.</em> We could have done the entire thing with Terraform in an Infrastructure as Code fashion. <strong>Which means we could do it a thousand times, each to exactly the same documented standard, in a fraction of the time.</strong></p><p><strong>Let me know in the comments if you would like a walkthrough of how that would work with Terraform!</strong></p><h3><strong>What’s Next</strong></h3><p>In the next project, we dive into <strong>secure remote administration in AWS</strong> — exploring how to manage EC2 instances with minimal exposure, clear logging, and zero trust principles in mind.</p><p><a href="https://medium.com/@jason.mckenzie/wave-hands-like-clouds-episode-2-secure-remote-administration-in-aws-39176179938c">➡️ Read Episode 2 — Secure Remote Administration in AWS</a></p><h3>Further Learning</h3><ul><li><a href="https://aws.amazon.com/s3/">What is Amazon S3?</a></li><li><a href="https://aws.amazon.com/cloudfront/">What is Amazon CloudFront?</a></li><li><a href="https://aws.amazon.com/waf/">What is AWS WAF?</a></li></ul><p><strong>Resources:</strong></p><p>Example index.html:</p><pre>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>&lt;head&gt;<br> &lt;title&gt;Level Up Bank&lt;/title&gt;<br> &lt;style&gt;<br>  body {<br>   margin: 0;<br>   padding: 0;<br>   font-family: Arial, sans-serif;<br>   background-color: black;<br>            color: white;<br>  }<br>  <br>  .container {<br>   max-width: 1200px;<br>   margin: 0 auto;<br>   padding: 20px;<br>  }<br>  <br>  h1 {<br>   text-align: center;<br>   font-size: 90px;<br>   margin-top: 50px;<br>   margin-bottom: 50px;<br>  }<br>  <br>  p {<br>   font-size: 18px;<br>   line-height: 1.5;<br>   margin-bottom: 20px;<br>  }<br>  <br>  .button {<br>   display: inline-block;<br>   padding: 10px 20px;<br>   background-color: #4CAF50;<br>   color: #FFFFFF;<br>   font-size: 16px;<br>   border-radius: 5px;<br>   text-decoration: none;<br>   margin-right: 10px;<br>   margin-bottom: 20px;<br>  }<br>  <br>  .button:hover {<br>   background-color: #3e8e41;<br>  }<br>  <br>  .feature {<br>   display: flex;<br>   flex-direction: row;<br>   justify-content: space-between;<br>   align-items: center;<br>   margin-bottom: 50px;<br>  }<br>  <br>  .feature img {<br>   max-width: 400px;<br>   max-height: 400px;<br>   margin-right: 50px;<br>  }<br>  <br>  .feature-text {<br>   flex: 1;<br>  }<br>  <br>  .feature h2 {<br>   font-size: 36px;<br>   margin-bottom: 20px;<br>  }<br>  <br>  .feature p {<br>   font-size: 24px;<br>   line-height: 1.5;<br>   margin-bottom: 20px;<br>  }<br>  <br>  .feature button {<br>   margin-top: 20px;<br>  }<br> &lt;/style&gt;<br>&lt;/head&gt;<br>&lt;body&gt;<br> &lt;div class=&quot;container&quot;&gt;<br>  &lt;h1&gt;Level Up Bank&lt;/h1&gt;<br>  &lt;div class=&quot;feature&quot;&gt;<br>   &lt;img src=&quot;https://www.simplilearn.com/ice9/free_resources_article_thumb/Introduction_to_Cyber_Security.jpg&quot; alt=&quot;Image 1&quot;&gt;<br>   &lt;div class=&quot;feature-text&quot;&gt;<br>    &lt;h2&gt;Secure Banking&lt;/h2&gt;<br>    &lt;p&gt;At Level Up Bank, we take security seriously. All of our accounts are protected with multi-factor authentication and 24/7 monitoring. Your money is safe with us.&lt;/p&gt;<br>    &lt;a href=&quot;#&quot; class=&quot;button&quot;&gt;Learn More&lt;/a&gt;<br>   &lt;/div&gt;<br>  &lt;/div&gt;<br>  &lt;div class=&quot;feature&quot;&gt;<br>   &lt;img src=&quot;https://news.okstate.edu/articles/agricultural-sciences-natural-resources/images/cash_app_banner.jpg&quot; alt=&quot;Image 2&quot;&gt;<br>   &lt;div class=&quot;feature-text&quot;&gt;<br>    &lt;h2&gt;Easy Transfers&lt;/h2&gt;<br>    &lt;p&gt;Sending and receiving money has never been easier. With our intuitive interface, you can transfer money to anyone, anywhere, with just a few clicks.&lt;/p&gt;<br>    &lt;a href=&quot;#&quot; class=&quot;button&quot;&gt;Learn More&lt;/a&gt;<br>   &lt;/div&gt;<br>  &lt;/div&gt;<br>  &lt;div class=&quot;feature&quot;&gt;<br>   &lt;img src=&quot;https://www.cloudtalk.io/wp-content/uploads/2021/12/Article-202105-FirstCallResolution-2x.png&quot; alt=&quot;Image 3&quot;&gt;<br>   &lt;div class=&quot;feature-text&quot;&gt;<br>    &lt;h2&gt;24/7 Support&lt;/h2&gt;<br>    &lt;p&gt;Need help with your account? Our customer support team is available 24/7 to assist you with any questions or issues you may have.&lt;/p&gt;<br>    &lt;a href=&quot;#&quot; class=&quot;button&quot;&gt;Learn More&lt;/a&gt;<br>   &lt;/div&gt;<br>  &lt;/div&gt;<br>  &lt;p&gt;Contact us today to open an account or learn more about our services:&lt;/p&gt;<br>   &lt;div class=&quot;contact-info&quot;&gt;<br>    &lt;p&gt;Level Up Bank&lt;/p&gt;<br>    &lt;p&gt;123 Main St&lt;/p&gt;<br>    &lt;p&gt;New York, NY 10001&lt;/p&gt;<br>    &lt;p&gt;Phone: (555) 555-5555&lt;/p&gt;<br>    &lt;p&gt;Email: info@levelupbank.com&lt;/p&gt;<br>   &lt;/div&gt;<br>  &lt;/div&gt;<br> &lt;/div&gt;<br>&lt;/body&gt;<br>&lt;/html&gt;</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45f67a97b8e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>