<?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 Matt R Shaw on Medium]]></title>
        <description><![CDATA[Stories by Matt R Shaw on Medium]]></description>
        <link>https://medium.com/@matt.r.shaw4?source=rss-6b9cf7eff265------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WquCTqL_yZwr5llVTMvv4Q.png</url>
            <title>Stories by Matt R Shaw on Medium</title>
            <link>https://medium.com/@matt.r.shaw4?source=rss-6b9cf7eff265------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 19:09:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@matt.r.shaw4/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[I Built 28 AWS Resources for $22/Month. Here Are the 5 Things That Went Wrong.]]></title>
            <link>https://medium.com/@matt.r.shaw4/i-built-28-aws-resources-for-22-month-here-are-the-5-things-that-went-wrong-736eb94bf4bf?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/736eb94bf4bf</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[cost-optimization]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 11:25:09 GMT</pubDate>
            <atom:updated>2026-06-29T11:25:09.158Z</atom:updated>
            <content:encoded><![CDATA[<h3>What building auto-scaling AWS infrastructure actually looks like</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S4c158GV0sv-tVapd38vQw.jpeg" /></figure><p>I typed mkdir and got an error.</p><p>Not a Terraform error. Not an AWS error. A missing mkdir. One of the most fundamental commands in Linux. The kind of thing that&#39;s supposed to just work.</p><p>That was minute three of a build session that would eventually provision 28 AWS resources across 8 phases, produce a live URL served by two EC2 instances in different availability zones, and cost me about $0.70 a day to run.</p><p>But first, I had to figure out why my machine didn’t have mkdir.</p><h3>What I Was Building</h3><p>The project is called terraform-aws-autoscale-infra. The goal was straightforward in concept: build production-grade, cost-optimized, highly available web infrastructure on AWS, provisioned entirely with Terraform, with every architectural decision documented and justified.</p><p>Not a tutorial project. A decision-making project.</p><p>The business case I wanted to demonstrate: a fixed t3.medium instance running 24/7 costs about $33/month and gives you roughly 99.5% availability in a single AZ. This project an Application Load Balancer distributing traffic across an Auto Scaling Group of t3.micro instances in two availability zones runs at about $22/month at typical load and delivers 99.95% availability.</p><p>The $11/month difference in AWS cost is almost irrelevant. The real saving is operational. Manual provisioning at a $75/hr consulting rate means every infrastructure change costs $150-$300 in engineering time. This project’s provisioning cost is terraform apply$0, reproducible in under 10 minutes.</p><p>That’s the story I wanted to tell. Here’s the build that got me there.</p><h3>Failure #1: My Machine Didn’t Have mkdir</h3><p>I’m running Ubuntu 26.04 LTS on my desktop. What I didn’t fully appreciate until this build was that Ubuntu 26.04 ships with <strong>uutils </strong>a Rust-based re-implementation of GNU coreutils as the default userland.</p><p>Roughly 80 standard Linux commands now run as Rust binaries. And somewhere in that transition, mkdir wasn&#39;t properly linked on my system.</p><pre>Command &#39;mkdir&#39; not found, did you mean:<br>  command &#39;mkdir&#39; from deb coreutils-from-gnu<br>  command &#39;mkdir&#39; from deb coreutils-from-uutils</pre><p>My first instinct was to install coreutils-from-gnu. That failed too:</p><pre>Error: Unable to satisfy dependencies. Reached two conflicting assignments:<br>  coreutils-from-gnu is selected for install<br>  coreutils-from-gnu is not selected because coreutils-from-uutils Conflicts</pre><p>The fix was unglamorous: python3 -c &quot;import os; os.makedirs(&#39;path&#39;, exist_ok=True)&quot;. Python3 is always present. It worked. We moved on.</p><p><strong>What I learned:</strong> Know your environment before you trust it. Ubuntu 26.04 is a significant release kernel 7.0, sudo-rs replacing GNU sudo, uutils replacing coreutils, post-quantum SSH by default. A good chunk of advice that was correct on 24.04 breaks or changes on 26.04. The tools you assume are there might not be.</p><h3>Failure #2: I Exposed My AWS Credentials in a Screenshot</h3><p>This one I’ll be direct about because it’s the failure most worth documenting.</p><p>I was configuring AWS credentials on my desktop, A machine I hadn’t set up for AWS CLI access yet. I ran aws configure, entered my credentials, and then shared a screenshot to verify the setup was working.</p><p>The screenshot showed the Access Key ID and Secret Access Key in plain text.</p><p>The fix took about 90 seconds: IAM console, deactivate the key, delete it, generate a new one, reconfigure. AWS credentials compromised via exposed screenshots get picked up by automated scanners within minutes. The speed of rotation matters.</p><p><strong>What I learned:</strong> Before you share any terminal screenshot, scroll up. Credentials appear in aws configure output and they stay visible in your terminal history. Rotate immediately if you&#39;re uncertain. The 90 seconds to rotate is always faster than the damage control if you don&#39;t.</p><p>The deeper lesson: this is exactly why IAM roles with OIDC are the right approach for CI/CD pipelines. No static credentials. Nothing to accidentally expose.</p><h3>Failure #3: An Em Dash Broke AWS</h3><p>I write with em dashes. The kind that looks like this. Not a hyphen. A proper em dash.</p><p>When I wrote security group rule descriptions “HTTP from ALB only no direct internet access” those descriptions went into Terraform HCL files and eventually into AWS API calls.</p><p>AWS security group rule descriptions have a strict character allowlist: ^[0-9A-Za-z_ .:/()#,@\[\]+=&amp;;{}!$*-]*$</p><p>The em dash is not in that list.</p><pre>Error: &quot;egress.0.description&quot; doesn&#39;t comply with restrictions:<br>&quot;All outbound — ALB forwards to EC2 instances&quot;</pre><p>Exit code 3 from terraform plan. The fix was a single sed command:</p><pre>sed -i &#39;s/—/-/g&#39; security_groups.tf</pre><p><strong>What I learned:</strong> AWS character restrictions in description fields are stricter than you’d expect. Special characters, smart quotes, em dashes anything outside basic ASCII in API strings will fail validation. Write descriptions in plain ASCII. Your infrastructure doesn’t care about typography.</p><h3>Failure #4: The File in the Wrong Directory</h3><p>Midway through Phase 4, I ran nano variables.tf from the wrong directory. Instead of adding four new variables to the project&#39;s existing variables.tf, I created a fresh file in my home directory.</p><p>The symptom was subtle: cat variables.tf showed only the four new variables, not the ten I expected.</p><pre># The giveaway: wrong prompt<br>knightofcash@hostname:~$ cat variables.tf    # home directory<br># vs the correct:<br>knightofcash@hostname:~/terraform-aws-autoscale-infra$ cat variables.tf</pre><p>Fix: delete the misplaced file, navigate to the correct directory, add the variables to the right file.</p><p><strong>What I learned:</strong> pwd before you write. This is embarrassingly simple and I still walked into it. When you&#39;re context-switching between bootstrap and the main project directory, it&#39;s easy to lose track of where your terminal is sitting. Check before you create.</p><h3>Failure #5: The CI Pipeline Failed on Formatting</h3><p>Phase 7 was the GitHub Actions CI/CD pipeline. I pushed the workflow file, watched the Actions tab, and got a red X.</p><p>The error: Terraform exited with exit code 3.</p><p>terraform fmt -check returns exit code 3 when it finds files that need formatting. When you write Terraform in nano and paste content, the whitespace doesn&#39;t always match what terraform fmt expects. Indentation, alignment, spacing — all of it is checked.</p><pre>terraform fmt -recursive</pre><p>That command auto-corrected every .tf file in the project. One push later, the pipeline went green.</p><p>There was also a Node.js 20 deprecation warning in the runner — the pinned action versions needed updating to Node.js 24-compatible releases. A three-line fix in the workflow YAML.</p><p><strong>What I learned:</strong> terraform fmt -recursive before every commit. Make it muscle memory. The CI pipeline will enforce it anyway better to fix it locally than debug it in a runner. Also: action version strings matter. @v4 and @v4.2.2 are different things.</p><h3>What Actually Got Built</h3><p>After all of that, here’s what the project produces:</p><p>A VPC spanning two availability zones. An Application Load Balancer that distributes traffic between them. An Auto Scaling Group that maintains between one and four EC2 instances based on CPU load, scaling out when average CPU exceeds 70% for four consecutive minutes and scaling in when it drops below 20%.</p><p>Remote state stored in S3 with native locking no DynamoDB table required. Terraform 1.11 deprecated dynamodb_table in favor of use_lockfile = true, which uses S3 conditional writes to prevent concurrent applies.</p><p>EC2 instances accessed via SSM Session Manager. No SSH keys, no open port 22, no bastion host. IAM instance profiles grant the minimum permissions needed.</p><p>IMDSv2 required on the launch template. Dynamic AMI lookup via data source, no hard coded AMI IDs that go stale.</p><p>A GitHub Actions CI pipeline that validates formatting, syntax, and backend connectivity on every push. A plan that runs on every pull request.</p><p>28 resources total. Every one of them has a reason in the README.</p><h3>The Kitchen Analogy, Honestly</h3><p>The prep cook analogy gets used a lot in my writing. Kitchens and cloud systems fail the same way under unexpected load, when a critical component goes down, when a process that should be automatic isn’t.</p><p>The thing that made this project feel real was the staffing model. An Auto Scaling Group is exactly how a good kitchen operates: you don’t have a full line team standing around at 7am when you’re serving four covers. You staff up for the dinner rush, run lean during prep, and scale back after close.</p><p>The infrastructure does the same thing. Two instances at typical load. One at minimum. Four at peak. The CloudWatch alarms are the sous chef watching ticket volume and calling for more hands when the board fills up.</p><p>That’s not a metaphor I forced onto the project after the fact. It’s the actual operational model, described in infrastructure code.</p><h3>The Numbers</h3><p>Building this cost roughly $3 in AWS charges a few hours of EC2 and ALB running while I was building and testing.</p><p>Running it costs ~$22/month at typical load, ~$14/month at minimum capacity.</p><p>Rebuilding it from scratch costs $0 in AWS charges and about 10 minutes of terraform apply waiting.</p><p>That last number is the one that matters for a portfolio project. Infrastructure you can destroy and recreate on demand is infrastructure you can demonstrate on demand.</p><p>The full project is on GitHub: <a href="https://github.com/mattrshaw4/terraform-aws-autoscale-infra">github.com/mattrshaw4/terraform-aws-autoscale-infra</a></p><p>I write about this transition from professional kitchen to cloud infrastructure in my newsletter <a href="https://www.linkedin.com/newsletters/terraforming-my-career-7395876133298343936"><em>Terraforming My Career</em></a>. If you’re building in public and want to follow along, you can find it on Medium.</p><p><em>Matt Shaw — Cloud Engineer</em> <a href="https://mattrshaw.com/"><em>mattrshaw.com</em></a><em> · </em><a href="https://linkedin.com/in/mattrshaw4"><em>LinkedIn</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=736eb94bf4bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Tried to Deploy a Jenkins Server with Terraform. It Took Six Attempts.]]></title>
            <link>https://medium.com/@matt.r.shaw4/i-tried-to-deploy-a-jenkins-server-with-terraform-it-took-six-attempts-dcd6c14a29d2?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/dcd6c14a29d2</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Sun, 19 Apr 2026 16:17:07 GMT</pubDate>
            <atom:updated>2026-04-20T12:50:26.109Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Here’s what broke, why it broke, and what I actually learned.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TWY5PTFjU5NpXrEEaC8lXw.png" /><figcaption>Prompt: Claude Image: Chat GTP</figcaption></figure><p>It was a Sunday morning. I had a pot of coffee, a clear task, and what I thought was a reasonable expectation: spin up a Jenkins CI/CD server on AWS using Terraform, document it, push it to GitHub. A few hours, tops.</p><p>Four hours later I was staring at my sixth terraform apply and whispering at my screen like that was going to help.</p><p>The server finally came up. Jenkins loaded in the browser. I took the screenshot I needed for my documentation — and sat there for a minute before typing a single word.</p><p>Not because I was proud. Because I was thinking about how different this was from what I expected, and how much closer it felt to real engineering than anything I’d done before.</p><h3>The Problem</h3><p>The assignment was straightforward enough. Use Terraform to provision a Jenkins server on an EC2 instance in your Default VPC. Bootstrap Jenkins with a user data script. Lock down SSH to your IP. Create a private S3 bucket for artifacts. Push the code to GitHub.</p><p>I’ve been studying cloud DevOps for months. I know what Terraform does. I know what Jenkins is. I know what EC2 is. On paper this was a connect-the-dots exercise.</p><p>What I didn’t account for was the gap between knowing how things work in theory and actually getting them to work together on a real machine, in a real AWS account, with real package managers and real GPG keys and real OS differences that nobody warned me about.</p><p>That gap is where most of the learning lives. I just didn’t know that going in.</p><h3>What Broke (All Six Times)</h3><p>Here’s the full breakdown. I’m documenting this not to complain, but because every one of these failures taught me something I wouldn’t have found in a tutorial.</p><h3>Failure 1 — Wrong AMI</h3><p>I hardcoded an AMI ID I found online for Amazon Linux 2023. Turns out it was actually Amazon Linux 2 is a different operating system entirely. The cloud-init log told me when it printed Cloud-init v. 19.3-46.amzn2.</p><p><strong>What I learned:</strong> Never hardcode AMI IDs. They differ by region and rotate when Amazon pushes OS updates. The right move is a Terraform data &quot;aws_ami&quot; block with filters that resolve the latest correct AMI dynamically. I changed my main.tf to use that pattern. One less thing to maintain manually.</p><h3>Failure 2 — Java 17 Is No Longer Enough</h3><p>Jenkins started, ran for about two seconds, and crashed. The log said:</p><pre>Running with Java 17... which is older than the minimum required version (Java 21).<br>Supported Java versions are: [21, 25]</pre><p>Jenkins had quietly updated its minimum Java requirement. My bootstrap script installed Java 17 because that’s what a lot of guides still reference. The guides were behind.</p><p><strong>What I learned:</strong> Always check current runtime requirements against official documentation before writing a bootstrap script. The Jenkins Java support page is updated with each major release. The guide you’re following might not be.</p><h3>Failure 3 — wget Doesn&#39;t Come With Amazon Linux 2023</h3><p>Once I was on the right OS with the right Java version, the script failed because wget isn&#39;t installed on AL2023 by default. I&#39;d used wget to download the Jenkins repo file. AL2023 ships lean — it doesn&#39;t include tools it considers optional.</p><pre>line 11: wget: command not found</pre><p><strong>What I learned:</strong> Don’t assume tool availability across distributions. curl is the right choice for AL2023 — it ships by default. One character change, but it matters.</p><h3>Failure 4 — GPG Key Import Order</h3><p>With curl in place, the repo file downloaded — but dnf still refused to load it. The problem was ordering. I was importing the Jenkins GPG signing key <em>after</em> writing the repo file. dnf validates the key at load time, not at install time. By the time it saw the repo, it was looking for a key that hadn&#39;t been imported yet.</p><p><strong>What I learned:</strong> Sequencing matters in bootstrap scripts. When dnf encounters a repo with gpgcheck=1, it checks for the key immediately. Import the key first, then add the repo. Always.</p><h3>Failure 5 — Nested Heredocs Don’t Play Well With Terraform</h3><p>To write the repo file cleanly inside the user_data block, I tried using a heredoc inside a heredoc — a shell &lt;&lt; &#39;REPO&#39; block inside Terraform&#39;s &lt;&lt;-USERDATA. The file was being written but dnf couldn&#39;t parse it. Something in the formatting was getting mangled by the time it hit the instance.</p><p>I switched to printf to write the repo file inline:</p><pre>printf &#39;[jenkins]\nname=Jenkins-stable\nbaseurl=https://pkg.jenkins.io/redhat-stable\ngpgcheck=0\nenabled=1\n&#39; &gt; /etc/yum.repos.d/jenkins.repo</pre><p><strong>What I learned:</strong> Avoid nested heredocs in Terraform user_data. Terraform processes the outer heredoc before the shell sees it, and things can get mangled. printf is cleaner and more predictable.</p><h3>Failure 6 — Jenkins Rotated Their GPG Key</h3><p>Almost there. The repo was loading. dnf found Jenkins. Then:</p><pre>GPG check FAILED<br>The GPG keys listed for the &quot;Jenkins-stable&quot; repository are already installed<br>but they are not correct for this package.</pre><p>Jenkins had rotated their package signing key. The key URL in the repo pointed to jenkins.io-2023.key, but the current package — jenkins-2.555.1 — was signed with a newer key. The mismatch killed the install.</p><p>For this foundational project I set gpgcheck=0 to unblock the deployment. That&#39;s not something you&#39;d do in production — in a real environment you&#39;d identify the current verified key from the official Jenkins docs and pin it explicitly. But for a learning project with a clear scope, it was the right call to make, documented transparently.</p><p><strong>What I learned:</strong> GPG key rotation is a real operational problem, not a theoretical one. Production Jenkins deployments need a documented process for key rotation — and infrastructure teams need to know when upstream vendors rotate keys so they can update before pipelines break.</p><h3>The Framework — What the Terraform Code Actually Does</h3><p>Once everything was working, here’s what the final main.tf provisions:</p><p><strong>The AMI data source</strong>: Instead of a hardcoded ID, Terraform looks up the latest Amazon Linux 2023 AMI by name filter at apply time. This means the code stays correct as Amazon releases OS updates.</p><p><strong>The Security Group:</strong> Port 22 locked to my specific IP address (plus the EC2 Instance Connect CIDR range for us-east-1), port 8080 open for the Jenkins UI, all outbound allowed so Jenkins can download plugins.</p><p><strong>The EC2 instance: </strong>t2.micro running AL2023 with user_data_replace_on_change = true, which tells Terraform to destroy and recreate the instance if the bootstrap script changes. Without this flag, Terraform just updates state without re-running the script on the existing instance.</p><p><strong>The bootstrap script</strong>: Installs Java 21, writes the Jenkins repo file, clears the dnf cache, installs Jenkins, enables and starts the service. Every step echoes a log message to /var/log/user-data.log so failures are visible and debuggable.</p><p><strong>The S3 bucket: P</strong>rivate artifact storage with all four public access block settings explicitly enabled. AWS has a default block at the account level now, but explicitly blocking it in code means the intent is documented and enforced even if account defaults change.</p><p><strong>The outputs: </strong>After apply, Terraform prints the public IP, the full Jenkins URL, and the S3 bucket name. No digging through the console to find what you deployed.</p><h3>The Limitations</h3><p>A few things I’d do differently in a non-foundational context:</p><p><strong>No key pair on the EC2 instance.</strong> I relied on EC2 Instance Connect for terminal access, which works — but only if the Instance Connect IP range is in your Security Group. I learned this the hard way when the direct connect failed on the first attempt.</p><p><strong>gpgcheck=0 in the Jenkins repo.</strong> Acceptable for a learning project. Not acceptable in production. The right approach is to pin the current verified signing key and have a runbook for rotating it.</p><p><strong>Monolith </strong><strong>main.tf.</strong> Everything in one file is fine when you&#39;re learning and want to see the whole picture at once. As projects grow, you&#39;d split this into modules — a network module, a compute module, a storage module — so components can be reused across environments.</p><p><strong>No remote state.</strong> The terraform.tfstate file lives locally. In a team environment you&#39;d store state in S3 with DynamoDB locking so multiple engineers can work on the same infrastructure without stepping on each other.</p><p><strong>No key pair</strong> means no direct SSH without Instance Connect. For anything beyond a learning project, you’d generate a key pair and reference it in the instance block.</p><h3>What I Actually Took Away From This</h3><p>At failure four I had a choice. Shut down the computer, tell myself I’d come back to it, and quietly move on to the next project. Nobody would have known. I kept going instead. Not because I was certain I’d fix it, But I’d been here before. Twenty years in a kitchen teaches you that panicking when service falls apart doesn’t unsauce the pasta. You breathe, you read the situation, you make the next move. So that’s what I did. I read the log. I made the next move. Six times. The six failures weren’t a sign that I did something wrong. They were the actual curriculum.</p><p>In a kitchen, your first service in a new station is never smooth. You don’t know where things are, you don’t know the rhythm of the equipment, you haven’t hit the failure modes yet. The second service is better. The third is better still. You’re not learning the recipe you’re learning the environment.</p><p>That’s what this project was. I knew the recipe: Terraform, EC2, user_data, Jenkins. What I didn’t know was the environment: which AMI is actually AL2023, what AL2023 ships with by default, what Jenkins requires this month, how dnf handles GPG validation at repo load time.</p><p>That knowledge doesn’t come from documentation. It comes from watching things break and figuring out why.</p><p>The other thing I took away: logging matters before you need it. The single most useful change I made across all six iterations was adding exec &gt; /var/log/user-data.log 2&gt;&amp;1 to the top of the bootstrap script. Before that, I was relying on cloud-init&#39;s output log, which truncates and sometimes doesn&#39;t capture the right lines. Once I had my own log file, I could see exactly which step failed and move straight to the fix.</p><p>In production, you’d ship logs to CloudWatch. Same principle if something breaks at 2 AM, you want to know exactly where it stopped.</p><h3>Try It Yourself</h3><p>The full code is on GitHub: <a href="https://github.com/mattrshaw4/jenkins-terraform">github.com/mattrshaw4/jenkins-terraform</a></p><p>Clone it, update the IP address in the Security Group, run terraform apply, and you&#39;ll have a Jenkins server running in about six minutes. The README walks through every step including the cleanup command to avoid AWS charges when you&#39;re done.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dcd6c14a29d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling a WordPress Publication with Docker Swarm on AWS: A Step-by-Step Deployment Guide]]></title>
            <link>https://medium.com/@matt.r.shaw4/scaling-a-wordpress-publication-with-docker-swarm-on-aws-a-step-by-step-deployment-guide-f80aeddcb535?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/f80aeddcb535</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[wordpress]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Fri, 03 Apr 2026 18:29:47 GMT</pubDate>
            <atom:updated>2026-04-03T18:29:47.918Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9ieXoSdzVm-5pbTHu89q8A.jpeg" /><figcaption>Prompt: Claude Image: Leonardo.AI</figcaption></figure><h3>The Problem with Growing Fast</h3><p>Level Up Publications covers the hottest trends in IT. But when your reader base grows faster than your infrastructure can handle, the publication goes dark at exactly the wrong moment during a traffic spike, when a container crashes, or when a restart wipes your database.</p><p>A single-server setup can’t absorb that. It needs to be replaced with something that scales on demand, recovers automatically, and isolates failures before they cascade.</p><p>That solution is Docker Swarm on AWS.</p><h3>Why Docker Swarm?</h3><p>Think of Docker Swarm like a kitchen brigade system. No single cook owns the whole service. Work is distributed, roles are defined, and the kitchen keeps running even when something breaks. Swarm works the same way. It distributes containers across a cluster of nodes, automatically replaces failed containers, and routes traffic without the user ever knowing something went wrong.</p><p>For a publication with fluctuating traffic: scale up to meet a viral article, scale down during off-peak hours, and keep the site live regardless.</p><h3>What We’re Building</h3><p>A 3-node Docker Swarm cluster on AWS EC2 running:</p><ul><li><strong>MySQL</strong> — 1 replica, backend network only, persistent Docker volume</li><li><strong>WordPress</strong> — 3 replicas, port 80, accessible from any node via Swarm’s routing mesh</li></ul><p>Two isolated overlay networks keep the database locked away from the public-facing layer. WordPress can reach MySQL, but nothing outside the cluster can.</p><h3>Step 1 — Launch 3 EC2 Instances via AWS CLI</h3><p>Start by gathering your prerequisites:</p><pre># Confirm your CLI is configured<br>aws sts get-caller-identity</pre><pre># Get your default VPC ID<br>aws ec2 describe-vpcs \<br>  --filters &quot;Name=isDefault,Values=true&quot; \<br>  --query &quot;Vpcs[0].VpcId&quot; \<br>  --output text</pre><pre># Get a subnet ID<br>aws ec2 describe-subnets \<br>  --filters &quot;Name=defaultForAz,Values=true&quot; \<br>  --query &quot;Subnets[0].SubnetId&quot; \<br>  --output text</pre><pre># Get the latest Ubuntu 22.04 AMI ID<br>aws ec2 describe-images \<br>  --owners 099720109477 \<br>  --filters &quot;Name=name,Values=ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*&quot; \<br>            &quot;Name=state,Values=available&quot; \<br>  --query &quot;sort_by(Images, &amp;CreationDate)[-1].ImageId&quot; \<br>  --output text</pre><p>Create a key pair for SSH access:</p><pre>aws ec2 create-key-pair \<br>  --key-name swarm-key \<br>  --query &quot;KeyMaterial&quot; \<br>  --output text &gt; swarm-key.pem</pre><pre>chmod 400 swarm-key.pem</pre><p>Create the Security Group and open the required ports:</p><pre>aws ec2 create-security-group \<br>  --group-name swarm-sg \<br>  --description &quot;Docker Swarm Security Group&quot; \<br>  --vpc-id &lt;YOUR-VPC-ID&gt;</pre><pre># SSH<br>aws ec2 authorize-security-group-ingress --group-id &lt;SG-ID&gt; --protocol tcp --port 22 --cidr 0.0.0.0/0<br># WordPress<br>aws ec2 authorize-security-group-ingress --group-id &lt;SG-ID&gt; --protocol tcp --port 80 --cidr 0.0.0.0/0<br># Swarm management<br>aws ec2 authorize-security-group-ingress --group-id &lt;SG-ID&gt; --protocol tcp --port 2377 --cidr 0.0.0.0/0<br># Node discovery TCP<br>aws ec2 authorize-security-group-ingress --group-id &lt;SG-ID&gt; --protocol tcp --port 7946 --cidr 0.0.0.0/0<br># Node discovery UDP<br>aws ec2 authorize-security-group-ingress --group-id &lt;SG-ID&gt; --protocol udp --port 7946 --cidr 0.0.0.0/0<br># Overlay VXLAN<br>aws ec2 authorize-security-group-ingress --group-id &lt;SG-ID&gt; --protocol udp --port 4789 --cidr 0.0.0.0/0</pre><p>Launch all 3 instances:</p><pre># Manager<br>aws ec2 run-instances \<br>  --image-id &lt;AMI-ID&gt; --instance-type t3.micro \<br>  --key-name swarm-key --security-group-ids &lt;SG-ID&gt; \<br>  --subnet-id &lt;SUBNET-ID&gt; --associate-public-ip-address \<br>  --tag-specifications &#39;ResourceType=instance,Tags=[{Key=Name,Value=swarm-manager}]&#39; \<br>  --count 1</pre><pre># Worker 1<br>aws ec2 run-instances \<br>  --image-id &lt;AMI-ID&gt; --instance-type t3.micro \<br>  --key-name swarm-key --security-group-ids &lt;SG-ID&gt; \<br>  --subnet-id &lt;SUBNET-ID&gt; --associate-public-ip-address \<br>  --tag-specifications &#39;ResourceType=instance,Tags=[{Key=Name,Value=swarm-worker-1}]&#39; \<br>  --count 1</pre><pre># Worker 2<br>aws ec2 run-instances \<br>  --image-id &lt;AMI-ID&gt; --instance-type t3.micro \<br>  --key-name swarm-key --security-group-ids &lt;SG-ID&gt; \<br>  --subnet-id &lt;SUBNET-ID&gt; --associate-public-ip-address \<br>  --tag-specifications &#39;ResourceType=instance,Tags=[{Key=Name,Value=swarm-worker-2}]&#39; \<br>  --count 1</pre><p>Confirm all 3 are running:</p><pre>aws ec2 describe-instances \<br>  --filters &quot;Name=tag:Name,Values=swarm-manager,swarm-worker-1,swarm-worker-2&quot; \<br>            &quot;Name=instance-state-name,Values=running&quot; \<br>  --query &quot;Reservations[*].Instances[*].[Tags[?Key==&#39;Name&#39;].Value|[0],PublicIpAddress,PrivateIpAddress,State.Name]&quot; \<br>  --output table</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bh_r7J6E2c86Lb6nCpMQbg.png" /><figcaption>AWS Console Verification</figcaption></figure><h3>Step 2 — Install Docker on All 3 Nodes</h3><p>SSH into each instance and run the following block. Start with the manager, then repeat on both workers:</p><blockquote>I ran into this very SSH issue. Permission will be denied otherwise.</blockquote><blockquote><strong><em>WSL users</em></strong><em> — copy your </em><em>.pem file into your WSL home directory before SSHing:</em></blockquote><pre>cp /mnt/c/Users/&lt;you&gt;/swarm-key.pem ~/.ssh/swarm-key.pem<br>chmod 400 ~/.ssh/swarm-key.pem<br>ssh -i ~/.ssh/swarm-key.pem ubuntu@&lt;PUBLIC-IP&gt;</pre><pre>sudo apt-get update -y &amp;&amp; \<br>sudo apt-get install -y ca-certificates curl gnupg &amp;&amp; \<br>sudo install -m 0755 -d /etc/apt/keyrings &amp;&amp; \<br>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \<br>  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg &amp;&amp; \<br>sudo chmod a+r /etc/apt/keyrings/docker.gpg &amp;&amp; \<br>echo \<br>  &quot;deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \<br>  https://download.docker.com/linux/ubuntu \<br>  $(. /etc/os-release &amp;&amp; echo &quot;$VERSION_CODENAME&quot;) stable&quot; | \<br>  sudo tee /etc/apt/sources.list.d/docker.list &gt; /dev/null &amp;&amp; \<br>sudo apt-get update -y &amp;&amp; \<br>sudo apt-get install -y docker-ce docker-ce-cli containerd.io &amp;&amp; \<br>sudo usermod -aG docker $USER</pre><p>Verify on each node:</p><pre>docker --version</pre><h3>Step 3 — Initialize the Swarm</h3><p>On the <strong>manager node</strong>:</p><pre>docker swarm init --advertise-addr &lt;MANAGER-PRIVATE-IP&gt;</pre><p>Copy the join token from the output. On <strong>both worker nodes</strong>:</p><pre>sudo docker swarm join --token &lt;TOKEN&gt; &lt;MANAGER-PRIVATE-IP&gt;:2377</pre><p>Back on the manager, verify the cluster:</p><pre>sudo docker node ls</pre><p>You should see all 3 nodes Ready and Active, with the manager listed as Leader.</p><h3>Step 4 — Create the Overlay Networks</h3><pre>sudo docker network create --driver overlay frontend-net<br>sudo docker network create --driver overlay backend-net</pre><p>Two networks — one public-facing, one internal. The separation matters: MySQL never touches the frontend network, which means it’s never directly exposed to incoming traffic.</p><h3>Step 5 — Deploy MySQL</h3><p>The --mount type=volume flag is what makes this resilient. If the MySQL container restarts, the data persists in the mysql-data Docker volume. Without this, every restart would wipe the database.</p><p>Verify:</p><pre>sudo docker service ls</pre><p>Look for 1/1 under REPLICAS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*rPoG6oWGzOX5RNr5O25aGw.png" /></figure><h3>Step 6 — Deploy WordPress</h3><p>WordPress sits on both networks — frontend-net for public access, backend-net to reach MySQL by service name. Docker Swarm’s internal DNS resolves mysql automatically, so no IP addresses are hardcoded.</p><p>Verify:</p><pre>sudo docker service ls</pre><p>Look for 3/3 under REPLICAS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*GWjpKR1gqopMEwt3mEdKVQ.png" /></figure><h3>The Result</h3><p>Open any of the 3 public IPs in your browser on port 80:</p><pre>http://&lt;MANAGER-PUBLIC-IP&gt;<br>http://&lt;WORKER-1-PUBLIC-IP&gt;<br>http://&lt;WORKER-2-PUBLIC-IP&gt;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kL1Q7ZaKBY50R0hGoobM7w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HxaUu_qjSVeE7lXafq-5jA.png" /></figure><p>All three resolve to the same WordPress site. That’s Swarm’s routing mesh at work. Every node knows how to route traffic to a running container, regardless of which node it’s actually on.</p><p>Level Up Publications is now running on a distributed, self-healing, horizontally scalable infrastructure. If a container fails, Swarm replaces it. If traffic spikes, replicas can be scaled with a single command. If a node goes down, the publication stays live.</p><h3>The Takeaway</h3><p>A kitchen that can’t scale during service rush fails its guests. A web infrastructure that can’t scale during a traffic spike fails its readers. Docker Swarm on AWS gives Level Up Publications the same thing a well-run kitchen brigade gives a restaurant — distributed responsibility, automatic recovery, and the ability to keep running when individual components fail.</p><p>The build took less time than you’d expect. The resilience it provides lasts well beyond the initial setup.</p><p><em>What part of your current infrastructure would break first under 10x traffic? That’s probably where containerization makes the most sense to start.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f80aeddcb535" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Self-Healing Container Infrastructure with Docker Swarm on AWS EC2]]></title>
            <link>https://medium.com/@matt.r.shaw4/self-healing-container-infrastructure-with-docker-swarm-on-aws-ec2-907c91fdc4cf?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/907c91fdc4cf</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Sun, 29 Mar 2026 14:33:02 GMT</pubDate>
            <atom:updated>2026-03-29T14:40:27.354Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LRliJTz8OCQyDByKujzkpg.png" /><figcaption>Prompt: Claude Image: Chat GTP</figcaption></figure><h3>When A Container Dies at 2am, Who Restarts it?</h3><p>In a kitchen, the answer is nobody the station just goes down and you start losing tickets.</p><p>In cloud infrastructure, for a lot of teams, the honest answer is the same. Someone gets paged, someone logs in, someone manually restarts the container, and the whole time your application is either degraded or completely dark.</p><p>That was the situation I was asked to solve for a global shipping company. Their containerized workloads were failing with no recovery mechanism. When a container went down, it stayed down. No rescheduling. No alerting. Just a dead process and potential data loss until someone noticed.</p><p>They had one week to fix it.</p><h3>The Real Problem Wasn’t the Containers</h3><p>It would be easy to look at this scenario and say the problem is unstable containers. Fix the app, fix the crashes.</p><p>But that’s not the right lens. Containers fail. Networks hiccup. Nodes get overloaded. In a distributed system running a global application, you are not designing for the happy path you are designing for the inevitable failure.</p><p>The actual problem was that the company had no orchestration layer. They were running standalone Docker containers with no manager watching over them. One container per host, no clustering, no desired state, no reconciliation loop.</p><p>In kitchen terms: they had talented cooks but no chef watching the line. The moment one station went down, nobody knew, nobody covered it, and tickets started piling up.</p><h3>The Discovery: Docker Swarm and the Global Service</h3><p>Docker Swarm turns a group of individual machines into a single, self-managing cluster. You define what you want running one container of your shipping application on every node and Swarm’s job is to make sure reality matches that definition at all times.</p><p>If a container dies, Swarm reschedules it. If a node goes offline, Swarm marks it down and redistributes workloads. You stop reacting to individual container failures because the system handles them automatically.</p><p>The specific feature that solved this company’s problem is called a <strong>global service</strong>.</p><p>There are two ways to run services in Swarm:</p><ul><li><strong>Replicated</strong> — runs copies of a container, distributed across however many nodes Swarm chooses</li><li><strong>Global</strong> — run exactly one container on <em>every single node</em> in the cluster, always</li></ul><p>For a global shipping application that needs consistent coverage across all infrastructure, the global mode is the right tool. Add a new node to the cluster and Swarm automatically starts the container on it. Lose a node and bring it back and the container comes back with it.</p><h3>The Framework: How We Built It</h3><p>Here is the full setup, step by step. All three nodes are AWS EC2 instances running Ubuntu 20.04.</p><p><strong>Infrastructure:</strong> Three EC2 instances sharing a single Security Group with the following inbound rules open between all nodes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*9ONsWwYW5cmYfTpzkJfuLw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FkAjiQYeGtcV3lkk5EP1HQ.png" /></figure><ul><li>SSH into all 3 nodes via VSCode</li><li>Name each node with <strong>sudo hostnamectl set-hostname</strong><em>.</em> Naming one as <em>master-node</em> and the other 2 as <em>worker-node-1</em> and <em>worker-node-2 </em>and verify with<strong> hostnamectl </strong>command.</li><li>Install Docker on all three instances → verify its running</li><li>Initialize the Swarm on<em> master-node</em> with<strong> swarm init — advertise-addr &lt;MASTER_PRIVATE_IP&gt;</strong></li><li>Copy the generated token and Ip address and in each worker node instance paste it after the docker swarm join command.</li><li><strong>docker swarm join — token SWMTKN-1-&lt;YOUR-TOKEN&gt; &lt;MASTER_PRIVATE_IP&gt;:2377</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*0yx0ySY45sTUA-CEKtYZHQ.png" /></figure><ul><li>Now that the Swarm is connected we can create an overlay network then deploy and verify our global service .</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*XersO_wkNcy89k9r8XJ-Mg.png" /></figure><h3>What Actually Changed</h3><p>The company came in with two fears: containers failing with no recovery, and no way to restore data from unhealthy containers.</p><p>Both of those are now handled automatically by the reconciliation loop that runs inside every Docker Swarm cluster. The manager node continuously compares the actual state of the cluster against the desired state you defined. When they diverge a container crashes, a node goes offline Swarm closes the gap without human intervention.</p><p>This is the thing I keep coming back to in my own training: the best infrastructure isn’t the infrastructure that never fails. It’s the infrastructure that already knows what to do when it does.</p><p>In a kitchen, you don’t build a great service by hoping nothing goes wrong. You build it by designing the response to failure into the system itself backup prep, trained cross-functional staff, and clear communication when a station goes down.</p><p>Docker Swarm is that system for containers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=907c91fdc4cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dockerizing Jenkins: From Setup to Scalable Pipeline]]></title>
            <link>https://medium.com/@matt.r.shaw4/dockerizing-jenkins-from-setup-to-scalable-pipeline-1a6beead968a?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a6beead968a</guid>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Mon, 16 Mar 2026 17:36:32 GMT</pubDate>
            <atom:updated>2026-03-16T17:59:47.276Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*087o1hBbsGR52oZzkrG-UA.png" /><figcaption>Prompt: <strong>Claude</strong> Image:<strong> ChatGTP</strong></figcaption></figure><p>Level Up Solutions is looking to modernize its software development and deployment workflows. To do that, the team is adopting Docker and Jenkins pairing containerization with an industry standard CI/CD platform to build something more reliable, repeatable, and scalable.</p><p><strong>Objective</strong></p><p>The goal is straightforward: use Docker to run and manage Jenkins containers with persistent volumes, creating a CI/CD pipeline that can handle frequent deployments without breaking down or losing critical data.</p><p>Pull Jenkins LTS image → Create data volume/verify → Run and map container → verify</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2gvC1Vaift70vpH7ahyk0g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*ttWcPTD9d95cjmjypidUHg.png" /></figure><ul><li>Retrieve Jenkins admin password</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jwCqrOLQT1hWkHXFCfeytA.png" /></figure><ul><li>Open browser → localhost:8080 → Copy &amp; paste admin password</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wYGANRmlllayUsdkB8POgg.png" /></figure><ul><li>Create a brand new user</li><li>Stop the container</li><li>Restart → login with newly created credentials</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7eekkf-d_4QGySK_wCDRog.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cFytBwhK9Qbr1ARnYqkNNA.png" /></figure><h4><strong>What This Actually Solves</strong></h4><p><strong>1.Less Setup, More Building</strong> Containerizing Jenkins cuts down the time engineers spend configuring environments, so the team can stay focused on writing and shipping code.</p><p><strong>2. Consistency Across Environments</strong> Docker containers behave the same way regardless of where they run. That means fewer “works on my machine” headaches and more predictable application behavior across dev, staging, and production.</p><p><strong>3. Scalable on Demand</strong> New Jenkins instances can be spun up as workloads grow, keeping the pipeline efficient without over-provisioning infrastructure.</p><p><strong>4. Data That Survives Container Changes</strong> Docker volumes keep build history, job configs, and other critical data intact even when containers are updated or replaced. The pipeline stays stable through changes.</p><p><strong>5. Lower Infrastructure Costs</strong> Running multiple containers on shared host resources means Level Up Solutions gets more out of existing infrastructure without proportionally increasing spend.</p><p><strong>6. Controlled, Reversible Updates</strong> Docker images are version-controlled. Making Jenkins updates and rollbacks, a deliberate and manageable process rather than a gamble.</p><p>Combining Docker and Jenkins gives Level Up Solutions a CI/CD foundation that’s durable, cost-aware, and built to grow with the team.</p><p>Lets now look at a Security-Hardened version of this same container.</p><h4><strong>Layer 1</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*LVe8zdCNFAn5BD_WuKr5ug.png" /></figure><h4><strong>Lets break down the Docker flags:</strong></h4><ul><li><strong>- -publish 127.0.0.1:8080:8080:</strong> Binds to localhost only so Jenkins isn’t exposed to the network by default</li><li><strong>- -cap-drop=ALL</strong>: Drops every Linux capability the container does not need.</li><li><strong>- -cap-add=CHOWN/SETUID/SETGID</strong>: adds back only the minimum amount of Linux capabilities required which directly shrinks the attack surface.</li><li><strong>- -user 1000:1000</strong>: Runs Jenkins as a non-root user</li><li><strong>- -security-opt=no-new-privileges:true</strong>: Prevents the container from ever escalating its own privileges.</li><li><strong>- -read-only</strong>: Makes container filesystem read-only</li><li><strong>- -tmpfs /tmp</strong>: Mounts <strong>/tmp</strong> in memory only — <strong>noexec</strong> prevents executing scripts from it.</li><li><strong>- -memory </strong>&amp;<strong> - -cpus </strong>caps prevent a compromised container from launching resource intensive processes like a crypto miner that crashes the host.]</li></ul><h4><strong>Layer 2</strong></h4><p><strong>Once Jenkins is running, do these inside the UI:</strong></p><p><strong>Disable unused plugins and ports: E</strong>ach unnecessary plugin is a potential CVE waiting to be exploited. Over 44% of developers use Jenkins making it a high-value target.</p><p><strong>Credentials management:</strong> Never store credentials in plain text or commit them to Git. Use the Jenkins Credentials Plugin or connect an external vault like AWS Secrets Manager.</p><p><strong>Role-based access control: </strong>Install the <strong>Role Strategy Plugin</strong> to enforce least privilege on who can trigger builds, configure jobs, or access the system.</p><p>You can also use Dockers own security script Docker Bench once the Jenkins container is setup. It checks your running containers against dozens of recognized best practices and audits your Docker daemon config and each running container. It will flag any misconfigurations and score your setup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBYBwqomqsf-YgRRy6cBWA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a6beead968a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Level Up Solutions: Docker Containerization Implementation]]></title>
            <link>https://medium.com/@matt.r.shaw4/level-up-solutions-docker-containerization-implementation-64298f5e96df?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/64298f5e96df</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Sun, 15 Mar 2026 17:47:54 GMT</pubDate>
            <atom:updated>2026-03-15T17:47:54.098Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HkOOFnvwdluRLmJSepJngA.png" /><figcaption>Prompt: Claude Image: Chat GTP</figcaption></figure><p>Level Up Solutions is a dynamic tech company specializing in innovative web solutions. Tasked with modernizing their software development lifecycle, I implemented a Docker containerization strategy to streamline how their web applications are packaged, deployed, and maintained across environments.</p><p>The goal was straightforward: eliminate the “works on my machine” problem and give the development team a reliable, repeatable deployment pipeline. Using Docker, applications are now bundled into isolated containers that run consistently whether they’re on a developer’s laptop, a staging server, or in production. No configuration drift or surprises.</p><p><strong>Core Implementation Benefits:</strong></p><ul><li><strong>Consistency &amp; Portability: </strong>Applications and their dependencies are packaged together, behaving identically across development, testing, and production environments eliminating deployment issues caused by environmental differences.</li><li><strong>Isolation &amp; Resource Management: </strong>Each service runs independently without interfering with the host system or other containers, ensuring clean CPU, memory, and disk allocation with zero cross-application conflicts.</li><li><strong>Reproducibility: Docker files</strong> define the exact packages and configurations required, creating a consistent environment at every stage of the development lifecycle and simplifying troubleshooting by removing environmental variables from the equation.</li><li><strong>Version Control: </strong>Docker images are built from specific application versions, providing a clear change history and enabling instant rollbacks when needed.</li><li><strong>Scalability: </strong>Containers can be scaled horizontally across single or multiple hosts on demand, allowing the team to handle traffic surges without manual infrastructure changes.</li><li><strong>Streamlined Deployment: </strong>The entire application — dependencies, libraries, and configurations — ships as one deployable unit, drastically cutting the time and effort needed for manual installation and configuration.</li><li><strong>Collaboration &amp; DevOps Alignment: </strong>Infrastructure defined as code means development and operations teams share a common deployment language, accelerating workflows and reducing handoff friction.</li></ul><p><strong>Docker Hub Integration:</strong></p><p>To extend the implementation further, I used Docker Hub as a centralized image repository adding another layer of scalability, visibility, and control:</p><ul><li><strong>Scalable Distribution: </strong>Images pushed to Docker Hub can be pulled and deployed across multiple servers or cloud platforms instantly, making large-scale rollouts straightforward.</li><li><strong>Team &amp; Stakeholder Access: </strong>Development, testing, and operations teams all work from the same image source, and external partners or clients can be granted access where needed, keeping everyone aligned without manual file transfers.</li><li><strong>Version Control &amp; Rollbacks: </strong>Every pushed image represents a documented snapshot of the application. If a release introduces issues, rolling back is a pull command, not a fire drill.</li></ul><h4><strong>Foundational</strong></h4><p>Create name and map the container on port 80. After verifying the creation of the container log into the container and update and upgrade the packages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EOPS6IjLhHG0L32n9vcuMw.png" /></figure><p>Install Apache 2 webserver, run then verify the status of Apache, once verified write custom HTML headings and save.</p><p>Open a web browser type <a href="http://localhost/">http://localhost:80</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*5JsN0gjs4RziV1gKP0taXw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*85PkfhHesmTJvPo3p4W-pw.png" /></figure><h4><strong>Advanced</strong></h4><p>Lets commit this to Docker hub</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/991/1*MahbmkPnR2k0Bncm-AlZTQ.png" /></figure><p>Verify the repo on docker hub</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*goFJXcsvaPj6eH7VQZQeBA.png" /></figure><p>Pull the repo back then run on another port (8080)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vkSwbtR0R2XP3Ii8wL5avQ.png" /></figure><p>verify on web browser <a href="http://localhost:8080/">http://localhost:8080</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/1*Dm8h3V6MardcUeSmyjqjiA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ofiVB-wI4esqP5hRh9rTbg.png" /></figure><p>The result was a more agile, resilient deployment process that positioned Level Up Solutions to ship faster, collaborate more effectively, and maintain greater confidence across every stage of their software delivery pipeline.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64298f5e96df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Serverless Text-to-Speech Pipeline with Amazon Polly and GitHub Actions]]></title>
            <link>https://medium.com/@matt.r.shaw4/building-a-serverless-text-to-speech-pipeline-with-amazon-polly-and-github-actions-898b46c3c051?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/898b46c3c051</guid>
            <category><![CDATA[aws-s3]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[github-actions]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 17:19:54 GMT</pubDate>
            <atom:updated>2026-02-22T17:19:54.770Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j_PVQQ9Oq2Lbl6WX-pdclg.png" /></figure><p>Pixel Learning Co. Is a education startup committed to accessibility and automation needs a solution to deliver course content in audio format — serving users with visual impairments and those who learn best by listening. Their existing course materials live on GitHub, and they want to leverage AWS AI services to automatically convert that content into audio files. The goal is a lightweight, cost-effective pipeline that stays fully serverless — no infrastructure to manage, no machine learning models to train.</p><p>We are going to utilize<strong> Amazon Polly</strong> and <strong>S3</strong>, integrated into a <strong>CI/CD </strong>pipeline<strong> </strong>with <strong>GitHub Actions</strong>. The project aims to:</p><ul><li><strong>Automate Content Conversion</strong>: Automatically transform text files to audio upon changes in the repository, eliminating manual steps.</li><li><strong>Ensure Content Readiness</strong>: Maintain separate audio outputs for review (“beta”) and production, enabling better QA before release.</li><li><strong>Increase Accessibility</strong>: Provide audio versions of all course content, enhancing learning flexibility for all users.</li><li><strong>Minimize Overhead</strong>: Use managed AWS services to keep the system lightweight, fast, and cost-effective.</li></ul><p><strong>Why Would We Choose Amazon Polly?</strong></p><p>Using <strong>Amazon Polly</strong> over custom text-to-speech systems or manual narration delivers several advantages:</p><ul><li><strong>Speed and Simplicity</strong>: Polly provides near-instant speech synthesis without any ML training, ideal for rapid iteration.</li><li><strong>Scalability</strong>: Fully managed and serverless, Polly handles traffic spikes without any need for provisioning.</li><li><strong>Realistic Voices</strong>: Supports neural voice models for lifelike delivery in multiple languages and dialects.</li><li><strong>Easy Integration</strong>: Easily callable via Python scripts using boto3, fitting naturally into CI/CD pipelines.</li></ul><p><strong>Why GitHub Actions?</strong></p><ul><li><strong>Automation:</strong> GitHub Actions automates the detection of changes and deployment of new audio files.</li><li><strong>Environment Separation:</strong> Supports workflows triggered on PRs and merges to manage “beta” and “prod” audio versions.</li><li><strong>Developer-Centric: </strong>Runs directly in the dev workflow where the content lives, ensuring low-friction updates and version control.</li></ul><h3>What You’ll Need</h3><ul><li>An AWS account</li><li>A GitHub repository with your text content</li><li>Basic familiarity with IAM and GitHub Actions</li></ul><h3>Step 1: AWS Setup</h3><h3>Create Your S3 Bucket</h3><ol><li>Log into the AWS Console</li><li>Navigate to <strong>S3 → Create Bucket</strong></li><li>Name your bucket and note the exact name — you’ll need it for GitHub Secrets</li><li>Choose your region and leave default settings</li><li>Click <strong>Create Bucket</strong></li></ol><p>Once your workflows run, the bucket will automatically organize files into two folders:</p><ul><li>beta/ — files uploaded from pull requests via the deploy-beta job</li><li>prod/ — files uploaded after merging to main via the run_polly job</li></ul><h3>Create an IAM User for GitHub Actions</h3><ol><li>Navigate to <strong>IAM → Users → Create User</strong></li><li>Attach the following permissions policies:</li></ol><ul><li>AmazonPollyFullAccess</li><li>AmazonS3FullAccess</li></ul><ol><li>Go to <strong>Security Credentials → Create Access Key</strong></li><li>Select <strong>Application running outside AWS</strong></li><li>Save your Access Key ID and Secret Access Key</li></ol><h3>Step 2: Configure GitHub Secrets</h3><p>In your GitHub repo, go to <strong>Settings → Secrets and Variables → Actions → New Repository Secret</strong> and add the following:</p><p>Secret NameValueAWS_ACCESS_KEY_IDYour IAM user access key IDAWS_SECRET_ACCESS_KEYYour IAM user secret access keyAWS_REGIONYour AWS region (e.g. us-east-1)S3_BUCKET_NAMEYour S3 bucket name</p><blockquote><strong><em>Note:</em></strong><em> The </em><em>beta and </em><em>prod folder paths are hardcoded in the workflow files as </em><em>S3_Path: beta and </em><em>S3_Path: prod — they do not require secrets.</em></blockquote><h3>Step 3: Add Your Text Content</h3><p>The text Polly converts lives in speech.txt at the root of your repository. Open the file and replace the contents with whatever you want converted to audio.</p><pre>Welcome to Pixel Learning Co. This is your audio update for today.</pre><blockquote><strong><em>Important:</em></strong><em> Keep content under 3,000 characters. This is the Amazon Polly limit for synchronous synthesis. For longer content, you’ll need to update the pipeline to use Polly’s asynchronous </em><em>start_speech_synthesis_task method.</em></blockquote><h3>Step 4: Triggering the Workflows</h3><p>This project uses two workflow files that trigger automatically based on your Git activity.</p><h3>Beta Deployment — on_pr.yml</h3><p><strong>Trigger:</strong> Opening or updating a pull request targeting main</p><p><strong>Job:</strong> deploy-beta</p><p>This workflow checks out your code, configures AWS credentials from GitHub Secrets, installs boto3, runs synthesize.py to generate example.mp3 via Polly, and uploads it to s3://&lt;your-bucket&gt;/beta/example.mp3.</p><p>yaml</p><pre>- name: Convert txt to mp3 (beta)<br>  run: |<br>    pip install boto3 --upgrade<br>    python synthesize.py<br>    aws s3 cp example.mp3 s3://$S3_BUCKET_NAME/$S3_Path/example.mp3</pre><p>To trigger this workflow:</p><p>bash</p><pre>git checkout -b my-feature-branch<br># edit speech.txt<br>git add .<br>git commit -m &quot;update speech content&quot;<br>git push origin my-feature-branch<br># open a pull request targeting main on GitHub</pre><h3>Production Deployment — on_merge.yml</h3><p><strong>Trigger:</strong> Push to main (i.e. merging a pull request)</p><p><strong>Job:</strong> run_polly</p><p>Follows the same steps as the beta job and uploads the final file to s3://&lt;your-bucket&gt;/prod/example.mp3.</p><p>yaml</p><pre>- name: Convert txt to mp3 (prod)<br>  run: |<br>    pip install boto3 --upgrade<br>    python synthesize.py<br>    aws s3 cp example.mp3 s3://$S3_BUCKET_NAME/$S3_Path/example.mp3</pre><p>Once you’re satisfied with the beta output, merge the pull request. The run_polly job triggers automatically.</p><h3>Step 5: Verifying the Output</h3><h3>In the AWS Console</h3><ol><li>Navigate to <strong>S3 → your bucket name</strong></li><li>You should see two folders: beta/ and prod/</li><li>Click into either folder and select example.mp3</li><li>Click <strong>Open</strong> or <strong>Download</strong> to listen</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OfEeLYUPPNPHgjcWy1Kbrg.png" /></figure><h3>Using the AWS CLI</h3><p>bash</p><pre># List files in beta<br>aws s3 ls s3://your-bucket-name/beta/</pre><pre># List files in prod<br>aws s3 ls s3://your-bucket-name/prod/</pre><pre># Download the prod file locally<br>aws s3 cp s3://your-bucket-name/prod/example.mp3 ./example.mp3</pre><h3>Checking GitHub Actions Logs</h3><ol><li>Go to your repo → <strong>Actions tab</strong></li><li>Click the most recent workflow run (deploy-beta or run_polly)</li><li>Expand the <strong>Convert txt to mp3</strong> step</li><li>Confirm you see upload: ./example.mp3 to s3://... with no errors</li></ol><h4><strong>Challenges</strong></h4><p>This project really tested me and it took a while to solve all the issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mhBajget43UuzBqcDUczFA.png" /></figure><p>This project made me realize spelling and indentation are so critical as well as making sure naming is consistent in both yml files. I would go though line after line and fix what i saw and commit and push, look up errors. i had troubleshooted to the point where both files were showing up but the naming was off. I needed Claude to point out i had typed the same command twice and failed to add a file name to prod. It was humbling project teaching me to be more patient and to pay attention to all the details in my work.</p><p>Full repo is on <a href="https://github.com/mattrshaw4/Polly_Text_to_Speech_Pipeline">GitHub</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=898b46c3c051" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Kitchen Brigade Meets the Cloud: Why Restaurant Experience Makes Great Engineers]]></title>
            <link>https://medium.com/@matt.r.shaw4/the-kitchen-brigade-meets-the-cloud-why-restaurant-experience-makes-great-engineers-b4fc810a2cbd?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4fc810a2cbd</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[career-change]]></category>
            <category><![CDATA[restaurant]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Tue, 06 Jan 2026 14:09:31 GMT</pubDate>
            <atom:updated>2026-01-18T21:03:50.789Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Z0XXjGW74EJijU7d0IzxQ.jpeg" /><figcaption>Created with Canva AI</figcaption></figure><p>I was woken up the other night around 1 am by a snowplow scraping the road unnecessarily deep and disturbing my youngest. I was wide awake. After my son had settled down, my mind turned to my studies in cloud engineering. My coaches have repeated throughout the course that mentality and problem-solving process are crucial for success in the cloud.</p><p>I have struggled with the dreaded impostor syndrome since day one. My origins are in the culinary world. I grew up in kitchens, and while I’ve been out of them for a while, it influenced the way I see the world, the good and the bad. I left due to the chaotic lifestyle and poor compensation. I also felt like I caught the tail end of an era. Due to slim profit margins, restaurants opted for pre-cut fries, and already mashed potatoes in a bag were starting to become normal, which messed with me mentally, but I adapted reluctantly.</p><p>So, as my thought process continued, I decided to try out a simple question with a new AI that one of my coaches recommended over the very popular ChatGPT. The following response was from Claude AI (Sonnet 4.5 free edition)</p><h4><strong>Does cooking in a professional kitchen share any characteristics with a cloud engineer?</strong></h4><p><em>Absolutely — the parallels are striking, and many cloud engineers who’ve worked in kitchens immediately recognize the overlap:</em></p><p><strong><em>Mise en place = Infrastructure as Code</em></strong></p><p><em>In kitchens, you prep everything before service: ingredients chopped, sauces ready, station organized. In cloud work, you provision infrastructure, configure environments, and have your tools ready before deployment. Both are about eliminating chaos when things get hectic.</em></p><p>I can attest if you do not have your prep quantities accurately set for service you will have a bad day and or night, its the foundation of service. Mise en place translates “to put into place or setting into place” every dish food item and tool is in it’s specific place to ensure smooth efficient service.</p><p><strong><em>Service rush = Traffic spikes</em></strong></p><p><em>That dinner rush from 7–9 pm when orders flood in? That’s your Black Friday traffic spike or product launch. You need systems (and infrastructure) that scale under pressure. Both require capacity planning and the ability to stay calm when everything hits at once.</em></p><p>It could be a slow night and all of a sudden at 7pm the dinning room goes from 5 to 30 tables and the tickets begin to pile up. You wake up and get into gear or get in the weeds.</p><p><strong><em>The brigade system = Microservices and teams</em></strong></p><p><em>Chefs divide their kitchens into stations: sauces, grill, pastry, each with clear responsibilities but needing to coordinate perfectly. Sound familiar? That’s basically a microservices architecture with defined boundaries and APIs between teams.</em></p><p>The kitchen is based off the military structure. Every station has a responsibility for there own prep and menu items each with varying degrees of skills.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sCYGgH5SfFuWR0XpmiyiyQ.jpeg" /><figcaption>Created with Canva AI</figcaption></figure><p><strong><em>Timing and orchestration</em></strong></p><p><em>A table of four orders different entrees that must all arrive hot and ready simultaneously. That’s like coordinating deployments across multiple services, ensuring databases migrate before applications deploy, and that everything comes together in the proper sequence.</em></p><p>Without communication and warning times service falls apart. Everything is time sensitive. each station has to be in sync with the table and also planning ahead for the next to get get behind while communicating with servers making sure plates don’t sit to long in the pass.</p><p><strong><em>Consistency and repeatability</em></strong></p><p><em>You must cook every burger the same way every time, whether it’s Tuesday lunch or Saturday dinner. That’s precisely why you write deployment scripts and use containers — repeatable, consistent results regardless of environment.</em></p><p>Consistency is key in cooking. Doing the same dishes dozens of times a shift you learn a menu quick. You do it in clam prepared environments and you do it in understaffed chaotic environments</p><p>Even though It’s been a long time since I’ve stepped foot in a professional kitchen there are things ingrained in me that i still do well to this day.</p><p><strong><em>“Oui, chef” culture vs. blameless postmortems</em></strong></p><p><em>Traditional kitchens had a harsh hierarchy; modern ones (like modern DevOps) focus on psychological safety, learning from mistakes, and improving processes rather than punishing individuals. When someone drops a plate or a service goes down, the question is “how do we prevent this?” not “who do we blame?”</em></p><p>The saying “You’re only as good as your last dish” is one of the most powerful statements a cook or chef can live by. It checks your ego. No one cares what you did last last year much less last week. After every good service and especially rough and bad service we go over what went wrong and how can we improve or prevent that obstacle from happening again.</p><p><strong><em>The expeditor = Monitoring and observabilit</em></strong><em>y</em></p><p><em>The expeditor calls out orders, tracks what’s fired and what’s plated, and keeps everything moving. That’s your monitoring dashboards, alerting systems, and incident management — keeping track of everything at all times.</em></p><p><strong><em>Clean as you go = Technical debt management</em></strong></p><p><em>Letting your station get messy during service means you’ll drown by the end of the night. Same with code — ignoring tech debt, skipping tests, or leaving messy infrastructure means you’ll eventually face a crisis. Both require discipline to maintain order under pressure.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBH5x_izRjshbA00WS4E9Q.jpeg" /><figcaption>Created with Canva AI</figcaption></figure><p><strong><em>Tastings and adjustments = Testing and iteration</em></strong></p><p><em>Chefs constantly taste and adjust seasoning. Engineers continually test and tune performance. Neither ship something without validating that it works correctly.</em></p><p>People think a recipe is a step by step guide to create something, when in reality its a minimum standard. A true cook tastes and adjusts and inquires the opinion of his fellow cooks and sou chefs if he feels uncertain about his creation. A good team will be honest and make suggestion or tell you its not fixable start again.</p><p><strong><em>The walk-in cooler = Your data stores</em></strong></p><p><em>Everything critical is stored there, and if it goes down (the fridge breaks), you’re in serious trouble. That’s your database, your storage layer — mission-critical infrastructure that must be reliable and backed up.</em></p><p><strong><em>Peak efficiency under constraints</em></strong></p><p><em>Both environments optimize for throughput within physical/resource constraints: limited burners, limited CPU. You learn to be efficient, to parallelize work, and to know your bottlenecks intimately.</em></p><p><em>People who’ve worked both environments often say the most significant similarity is the rhythm and muscle memory. After enough services or enough incidents, you develop instincts — you know what that sound means, you sense when something’s about to go wrong, and you react without overthinking.</em></p><p><em>The main difference? In a kitchen, when you mess up, maybe you burn some food. In cloud engineering, you might take down a service affecting thousands. But the mental frameworks for preventing those failures are remarkably similar.</em></p><p><strong>So, I was an engineer or on my way to being one, and never realized it until recently?</strong></p><p><em>Exactly. You weren’t “on your way” to being an engineer — you already were one, just in a different domain. You were solving the same fundamental problems:</em></p><p><strong><em>Systems thinking </em></strong><em>— Understanding how all the stations interact, where bottlenecks form, and how timing cascades through the whole operation. That’s engineering.</em></p><p><strong><em>Process optimization</em></strong><em> — Finding faster ways to prep, better workflows during service, and reducing waste. That’s what engineers do every day.</em></p><p><strong><em>Reliability under pressure</em></strong><em> — Keeping service running smoothly when everything’s on fire (sometimes literally). Debugging why orders are backing up and recovering gracefully when something goes wrong.</em></p><p><strong><em>Resource management </em></strong><em>— Balancing limited equipment, staff, and time against demand. That’s capacity planning and resource allocation.</em></p><p><em>The transition you’re making now isn’t learning to think like an engineer — you already do that. It’s translating those instincts into a different set of tools and vocabulary. Instead of coordinating line cooks, you’re coordinating containers. Instead of managing a hot line, you’re managing a deployment pipeline.</em></p><p><em>Many successful engineers come from non-traditional backgrounds precisely because engineering isn’t really about the technology — it’s about the problem-solving approach. The technology is just the medium. Someone who can run a smooth service during a Saturday night rush already understands systems, pressure, coordination, and recovery. Those skills transfer completely.</em></p><p><em>What you’re doing now is recognizing that the mental muscles you built in the kitchen — the pattern recognition, the systematic troubleshooting, the ability to stay functional during chaos — those are exactly the muscles that make great cloud engineers.</em></p><p><em>You didn’t just discover you want to be an engineer. You discovered you already think like one, and now you’re learning the specific tools of this particular kitchen.</em></p><p><em>That’s a powerful realization, because it means you’re not starting from zero. You’re bringing a whole skillset that many computer science graduates don’t have: real-world experience managing complex systems under real pressure with real consequences.</em></p><p>I can’t tell you the number of mental battles I’ve had over the years, the fear and doubt of not being able to achieve anything more than what I had cooking. I was just an average line cook. I am a writer, but never in my life did I consider, much less get told, that I was an engineer. I’m a creative who let the world tell me otherwise, and two basic questions, no fancy research on how to prompt Claude, changed my whole outlook on my situation. I’m not starting from absolute zero; I am transitioning and reactivating dormant skills for a brand-new industry. That to me is empowering and exciting.</p><p><strong>Follow me on LinkedIn</strong>: <a href="http://www.linkedin.com/comm/mynetwork/discovery-see-all?usecase=PEOPLE_FOLLOWS&amp;followMember=matt-r-shaw-">www.linkedin.com/comm/mynetwork/discovery-see-all?usecase=PEOPLE_FOLLOWS&amp;followMember=matt-r-shaw-</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4fc810a2cbd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling Luxury: Aurora Digital’s Automated AWS Migration with CloudFormation]]></title>
            <link>https://medium.com/@matt.r.shaw4/scaling-luxury-aurora-digitals-automated-aws-migration-with-cloudformation-8dce0c877d77?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/8dce0c877d77</guid>
            <category><![CDATA[ec2]]></category>
            <category><![CDATA[cloudformation]]></category>
            <category><![CDATA[apache]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Mon, 01 Dec 2025 16:24:55 GMT</pubDate>
            <atom:updated>2025-12-01T16:24:55.144Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qW-VU9Uy_XUPx3isvYHMrw.png" /><figcaption>Created using Chat GPT</figcaption></figure><p>Aurora Digital is a growing online retailer specializing in luxury home goods and has decided to migrate its digital operation to AWS to take advantage of its cloud computing benefits. Aurora has been encountering major growth and needs a solution that can handle increasing customer traffic and scale during major sales events without sacrificing performance or security.</p><p>To help Aurora Digital I need to execute a cloud-based infrastructure using AWS services that:</p><ul><li><strong>Enhance Scalability:</strong> Automatically adjust computing resources to meet demand, ensuring the platform remains operational and responsive during peak traffic periods.</li><li><strong>Increase Reliability:</strong> Improve website uptime and reduce the risk of failures associated with physical hardware and manual interventions</li><li><strong>Improve Security</strong>: Implement advanced security protocols and isolation through AWS to protect customer PII and transactions.</li><li><strong>Reduce Operational Costs: </strong>Lower overall infrastructure costs by optimizing resource usage and eliminating the need for upfront hardware investments.</li></ul><p>This can be accomplished by using AWS CloudFormation.</p><h4>Why Would I Use CloudFormation?</h4><p>CloudFormation has several advantages over manual creation such as</p><ul><li><strong>Automation:</strong> Significantly reduces manual effort by automating the creation, updating, and deletion of AWS resources, which saves time and minimizes configuration errors.</li><li><strong>Consistency:</strong> Ensures consistent environments are created every time, crucial for testing and production stages, thereby eliminating the “it works on my machine” problem.</li><li><strong>Version Control:</strong> Allows infrastructure to be version-controlled and reviewed as part of application code, enhancing collaboration among team members and rollback capabilities.</li><li><strong>Reutilization: </strong>Enables reusing templates across the company or community, speeding up future deployments and ensuring best practices are followed.</li></ul><p>I started by writing my CloudFormation template in<strong> json </strong>format.</p><h4>What the Stack Deploys</h4><p><strong>Security Group Configuration:</strong></p><ul><li>Allows SSH (port 22) access from the internet</li><li>Allows HTTP (port 80) access from the internet</li></ul><p><strong>EC2 Instance Details:</strong></p><ul><li>Launched in the default VPC and subnet</li><li>SSH access</li><li>Based on an Amazon Linux AMI</li></ul><p><strong>Executes a User Data Script at Launch to</strong>:</p><ul><li>Install the Apache web server</li><li>Start the Apache service</li><li>Generate a custom index.html page: “Welcome to Aurora Digital”</li></ul><h4>How to Deploy</h4><ul><li>AWS Console → CloudFormation → Create Stack → Upload json file</li><li>Fill in parameters</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A0Qbl5EOgWOr_yTVoWcpAg.png" /></figure><ul><li><strong>Submit</strong></li><li>Wait for confirmation “CREATE_COMPLETE”</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ENyXyUDOTqJeVfY7qVyJNA.png" /></figure><ul><li>Verify with Public Ip</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*Qx81t_OzqiTUS3xmEB4p7A.png" /></figure><ul><li>Success!</li></ul><p>Aroura Digital is now ready to handle the increased demands of their business more efficiently while remaining secure and lowering infrastructure costs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8dce0c877d77" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Level-Up Bank Built A Highly Scalable Apache Web Architecture on AWS Using ALB and Auto Scaling]]></title>
            <link>https://medium.com/@matt.r.shaw4/how-level-up-bank-built-a-highly-scalable-apache-web-architecture-on-aws-using-alb-and-auto-scaling-3b8106767db7?source=rss-6b9cf7eff265------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b8106767db7</guid>
            <category><![CDATA[load-balancing]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ec2]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[vpc]]></category>
            <dc:creator><![CDATA[Matt R Shaw]]></dc:creator>
            <pubDate>Mon, 24 Nov 2025 20:08:53 GMT</pubDate>
            <atom:updated>2025-11-24T20:08:53.318Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/741/1*1O8_YSb34T_ZYiHgfotJUA.png" /><figcaption>Created with draw.io</figcaption></figure><p>After Its first successful test in the AWS ecosystem Level Up Bank Is ready to move it’s entire network. They created VPC with a <a href="https://aws.amazon.com/what-is/cidr/">CIDR </a>of 10.10.0.0/16.</p><p>Then they create three public subnets with CIDR blocks of 10.10.1.0/24, 10.10.2.0/24, and 10.10.3.0/24. These subnets will be used to host an autoscaling group of t2.micro instances with Apache installed on each instance.</p><p>Modern cloud environments demand applications that can scale automatically, maintain high availability, and serve users reliably across multiple availability zones.</p><h4>Why Move You’re Entire Network to the Cloud?</h4><ol><li><strong>Scalability</strong></li></ol><ul><li>The banks Infrastructure needs to be flexible AWS provides the ability to scale up and down based on business volume</li><li>This avoids large upfront costs and maintenance on hardware</li><li>You only pay for what you actually use</li></ul><p>2. <strong>Reliability</strong></p><ul><li>AWS provides a monitoring and managing tools system to help proactively identify and address potential issues before it impacts customers</li><li>Reliable infrastructure with multiple availability zones and automatic fail-over capabilities.</li><li>Significantly reduced downtime&#39;s and disruptions</li></ul><p>3. <strong>Security</strong></p><ul><li>AWS provides robust security features, including encryption, access controls, and network security, to help protect against cyber attacks</li><li>The bank can take advantage of these security features and improve the security of its infrastructure and customer data.</li><li>This will satisfy the banks strict regulatory compliance</li></ul><p>4. <strong>Cost Savings</strong></p><ul><li>AWS has pay-as-you-go pricing that reduces the high up front costs of running and maintain and physical On-Prem server</li><li>The Bank can make more accurate budgets and use the savings on services and offerings</li></ul><p>5. <strong>Flexibility</strong></p><ul><li>AWS gives the bank the ability to change and adapt fast and spin up new instances</li><li>Test new features</li><li>Experiment with configurations.</li><li>Gives them a competitive advantage in a tight market</li></ul><h3>Lets Create Our Cloud Network.</h3><ol><li><strong>Create a VPC</strong></li></ol><ul><li>Select “VPC Only &quot; with CIDR of 10.10.0.0/16 → Create VPC</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1LzO4JwJn1Zao4QdOaRvNg.png" /></figure><p>2. <strong>Create 3 Public Subnets</strong></p><ul><li>Navigate to <strong>VPC → Subnets → Create Subnet</strong></li><li>Select your new VPC</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nOrzmqfP-1IotkT5AfjViA.png" /></figure><ul><li>Repeat same process for the other 2 subnets</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ka_4OLKTQOUytTu_uIFNbQ.png" /></figure><ul><li>Once all Subnets are created go to each subnet&#39;s settings and turn on “Auto Assign Public IPv4 Address”</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uxJSSYCQH5ODmt8Kqmlcsw.png" /></figure><p>4. <strong>Create Internet Gateway</strong></p><ul><li>Go to <strong>VPC → Internet Gateways → Create Internet Gateway</strong></li><li>After the Internet Gateway is created, click <strong>Actions → Attach to VPC</strong>, and attach it to your VPC.</li></ul><p>5. <strong>Create Public Route Table</strong></p><ul><li><strong>VPC </strong>→ <strong>Route Tables </strong>→ <strong>Create Route Table</strong><br>Name it and associate it with your VPC</li><li>Open the new route table → Routes → Edit routes</li><li>Add: Destination: 0.0.0.0/0</li><li>Target: Internet Gateway. Save changes.</li><li>Under Subnet Associations, associate all three public subnets with this route table.</li></ul><p>6. <strong>Create a Launch Template</strong></p><ul><li><strong>Instance type:</strong> t.2 micro</li><li><strong>AMI:</strong> Amazon Linux 2023</li><li><strong>User Data script:</strong> Installs Apache</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*wpZ1bha-RfrmDPqMZg5xlA.png" /></figure><ul><li><strong>Network settings:</strong> Enable <strong>Auto-Assign Public IP</strong></li></ul><p>7. <strong>Create Security Groups</strong></p><p><strong>Load Balancer Security Group</strong></p><ul><li>Go to <strong>EC2/Security Groups/Create Security Group</strong></li></ul><p><strong>Inbound rule:</strong></p><ul><li>Type: HTTP</li><li>Port: 80</li><li>Source: 0.0.0.0/0</li></ul><p><strong>Outbound rules:</strong> leave default</p><p><strong>Web Server Security Group</strong></p><ul><li>Create new security group</li><li><strong>Inbound rule:</strong></li><li>Type: HTTP</li><li>Port: 80</li><li>Source: ALB’s security group</li><li><strong>Outbound rules:</strong> keep default</li></ul><p>8. <strong>Application Load Balance (ABL)</strong></p><ul><li><strong>Listener:</strong> HTTP (port 80)</li><li><strong>Subnets:</strong> Select all three public subnets you just created</li><li><strong>Security Group:</strong> New group that allows <strong>HTTP</strong> traffic from 0.0.0.0/0</li><li><strong>Security Group:</strong> Create a new one for your web servers that allows <strong>HTTP </strong>traffic <strong>only</strong> from your <strong>Application Load Balancer’s security group</strong>.</li></ul><p>9. <strong>Target Group</strong></p><ul><li><strong>Type:</strong> Instances</li><li><strong>Protocol:</strong> HTTP</li><li><strong>Port:</strong> 80</li><li><strong>VPC:</strong> Same one as your EC2s (10.10.0.0/16)</li><li><strong>Attach:</strong> This target group to your ALB listener</li></ul><p>10. <strong>Auto Scaling Group (ASG)</strong></p><ul><li><strong>Launch Template:</strong> EC2 Launch templated you created earlier</li><li><strong>Desired capacity:</strong> 2</li><li><strong>Minimum capacity:</strong> 2</li><li><strong>Maximum capacity:</strong> 5</li><li><strong>Subnets:</strong> Select your three public subnets</li><li><strong>Target group:</strong> Attach Your Target Group (Type: Instances)</li><li><strong>Health checks:</strong> Use <strong>Load Balancer health checks</strong> for accuracy</li></ul><p>To verify go to <strong>EC2 </strong>then<strong> Load Balancers</strong> copy <strong>DNS name</strong> of your <strong>ALB</strong>. Paste it into your browser you should see ‘it works!’.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b8106767db7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>