<?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 Qas Khandker on Medium]]></title>
        <description><![CDATA[Stories by Qas Khandker on Medium]]></description>
        <link>https://medium.com/@qaskhandker?source=rss-81dee1f91811------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*sO4B_hol0WT7Dn85j2LJ1Q.jpeg</url>
            <title>Stories by Qas Khandker on Medium</title>
            <link>https://medium.com/@qaskhandker?source=rss-81dee1f91811------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 07:23:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@qaskhandker/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[ Automating AWS Infrastructure with TypeScript and CDK — My Module 10 Journey]]></title>
            <link>https://medium.com/@qaskhandker/automating-aws-infrastructure-with-typescript-and-cdk-my-module-10-journey-190617bc4060?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/190617bc4060</guid>
            <category><![CDATA[aws-cdk]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Thu, 29 May 2025 15:07:23 GMT</pubDate>
            <atom:updated>2025-05-29T15:07:23.859Z</atom:updated>
            <content:encoded><![CDATA[<h3>🚀 Automating AWS Infrastructure with TypeScript and CDK — My Module 10 Journey</h3><p>As part of my cloud engineering learning path, Module 10 introduced me to the power of automation using the AWS Cloud Development Kit (CDK) with <strong>TypeScript</strong>. This was a hands-on, code-first experience that helped me understand how to define, provision, and manage cloud infrastructure using modern programming techniques.</p><p>Here’s what I learned and built along the way.</p><h3>💡 Introduction to TypeScript</h3><p>Before diving into CDK, I spent time understanding <strong>TypeScript</strong> — a statically typed superset of JavaScript. TypeScript offers strong typing, interfaces, and other features that make large-scale infrastructure-as-code (IaC) projects easier to manage and less error-prone.</p><h3>🧰 AWS CDK Basics</h3><p>The <strong>AWS Cloud Development Kit (CDK)</strong> allows you to define cloud resources using familiar programming languages like TypeScript, Python, and Java. Instead of YAML or JSON, you get the power of loops, logic, and object-oriented programming.</p><h3>🏗️ CDK Stacks and Constructs</h3><p>CDK applications are composed of <strong>stacks</strong>, and within those stacks are <strong>constructs</strong> — the building blocks of your cloud architecture.</p><p>We learned how to create:</p><ul><li>CDK <strong>Apps</strong> — the container for stacks</li><li>CDK <strong>Stacks</strong> — groupings of infrastructure resources</li><li><strong>Constructs</strong> — reusable configurations for specific AWS services — understanding L1, L2 and L3</li></ul><h3>⚙️ Setting Up the Environment</h3><p>We set up our environment with:</p><p>npm install -g aws-cdk<br>cdk init app --language=typescript</p><p>We also made sure the AWS CLI was configured and bootstrap the environment with cdk bootstrap.</p><h3>🌐 Building a VPC with CDK</h3><p>Using CDK, we defined a <strong>custom VPC</strong> with public, private, and database subnets across two availability zones. Here’s what made it exciting:</p><ul><li>Defined using ec2.Vpc</li><li>Subnet configuration with subnetConfiguration</li><li>Tagged and outputted the VPC ID using cdk.CfnOutput</li></ul><p>This was my first taste of coding real infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*rbcC99cuj8kizwxOIqKbrg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v7pPMJ7l0BmIzKfRQvTspA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*1OMx1on4tpT4O2WsISAN8w.png" /></figure><h3>💻 Building EC2 Instances</h3><p>Next, we deployed an <strong>EC2 instance</strong> into a <strong>private isolated subnet</strong> (AZ1), and later added a second EC2 instance into <strong>private subnet 2 (AZ2)</strong> as part of a practical challenge.</p><p>Key takeaways:</p><ul><li>Use of ec2.Instance</li><li>Setting machine image and instance type</li><li>Subnet placement with vpcSubnets</li><li>Adding tags for clarity and identification</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*22f7cSdj417hGofF2qibew.png" /></figure><h3>🛠 Practical Exercises</h3><h3>✅ Exercise 1: Add EC2 to Private Subnet 2</h3><p>This exercise solidified my understanding of subnet placement and availability zones. I created a new EC2 instance and verified it was in the correct isolated subnet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*BNkIK4MQ3-G4lzHhOY94oQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-4vGUpKXY8nx2biO_z06bg.png" /></figure><h3>✅ Exercise 2: Build RDS in Database Subnet</h3><p>This was the most rewarding part:</p><ul><li>Created a <strong>MySQL RDS instance</strong> using rds.DatabaseInstance</li><li>Used <strong>t3.micro</strong> with 20GB initial storage, scalable to 30GB</li><li>Placed it in the <strong>database subnet</strong></li><li>Tagged the instance and outputted the endpoint for connection</li></ul><p>Here’s a snippet of what that looked like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*JfmHNmleMNUw-iBcWZVUkg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1et-5pLWvB0_38ZzLZ5ZHw.png" /></figure><h3>✅ Validating Resources</h3><p>Using the AWS Console and CLI, I confirmed:</p><ul><li>VPC and subnets were created properly</li><li>EC2 and RDS were deployed in correct subnets</li><li>Tags and outputs made debugging easier</li></ul><p>The cdk diff and cdk deploy --all commands became daily tools.</p><h3>🧠 Final Thoughts</h3><p>Module 10 showed me the <strong>power of infrastructure as code</strong> — how to build real-world, production-ready architectures using the CDK and TypeScript. I went from understanding basic syntax to deploying full VPCs, EC2s, and RDS databases programmatically.</p><p>This isn’t just about learning — it’s about mastering cloud automation the DevOps way.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=190617bc4060" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Switching Gears: My Journey into Python Programming Fundamentals]]></title>
            <link>https://medium.com/@qaskhandker/switching-gears-my-journey-into-python-programming-fundamentals-1c45c876d157?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c45c876d157</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Mon, 12 May 2025 20:14:58 GMT</pubDate>
            <atom:updated>2025-05-12T20:14:58.857Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RiC3uf_PXpUfXGEPHnQsog.png" /></figure><p>As a <strong>Quality Assurance (QA)</strong> professional, I’m no stranger to code — but it’s usually from the other side of the fence. I work closely with developers, reviewing their work, understanding system behaviors, and ensuring the quality of releases. But in <strong>Module 9 of the Cloud Engineering Academy</strong>, I took a significant step out of my usual territory and dove into <strong>Programming Fundamentals with Python</strong> — and what a rewarding experience it’s been.</p><h3>🧱 Building Blocks: Indentation, Comments, and Variables</h3><p>We began with the absolute basics: how Python uses <strong>indentation</strong> instead of braces to define code blocks. This was surprisingly intuitive — especially with a QA mindset that appreciates structure and consistency.</p><p>I also learned how to write <strong>comments</strong> clearly and meaningfully — a small detail, but crucial for collaboration and clarity. From there, we explored <strong>variables</strong>, which felt like unlocking the first door into coding. Assigning values, modifying them, and combining them through <strong>string concatenation</strong> was a fun start to seeing how code “talks.”</p><h3>📚 Collections: Lists and Dictionaries</h3><p>Next, we played with <strong>lists</strong> — how to create them, count their length with .len(), and access individual items using <strong>indexing</strong>. This was especially useful for imagining how data can be stored and retrieved, a concept I’ve often validated from the QA side but never directly constructed myself.</p><p>Learning about <strong>dictionaries</strong> — with key-value pairs — was another “aha” moment. It’s like structuring real-world information, something I now recognize in the backend of many systems I test daily.</p><h3>🔄 Control Flow: If, Elif, Else</h3><p>One of my favorite parts of the module was understanding <strong>control flow</strong>. Writing if, elif, and else statements genuinely felt like solving a logic puzzle or putting together pieces of a <strong>jigsaw</strong>—each condition helping the program decide what to do. It reminded me of designing test scenarios:</p><blockquote><em>“If the user logs in with the wrong password, show an error; else, let them through.”</em></blockquote><p>It was a gratifying intersection of logic and creativity.</p><h3>♻️ Loops and Functions</h3><p>We then jumped into <strong>for loops</strong> and <strong>while loops</strong>, making programs that could repeat actions. It gave me a whole new appreciation for the dynamic elements I test in applications — like user inputs or backend iterations.</p><p>Finally, we tackled <strong>functions</strong> using def, import, and even brought in some fun with Python’s random module. Seeing how reusable blocks of code can be structured and called upon felt empowering—especially knowing how essential this is in automation frameworks.</p><h3>💡 Seeing the Developer’s Side</h3><p>As a QA, this module was enlightening. I’m used to being the “final step” before code goes live, but writing Python code — even just the fundamentals — gave me a glimpse into the <strong>developer’s mindset</strong>. It helped me understand not just <em>what</em> goes wrong when bugs happen, but <em>why</em>.</p><h3>🚀 What’s Next?</h3><p>This experience has sparked a real interest in learning more about Python. I now want to explore <strong>automation testing</strong> using Python tools and frameworks, so I can bring this knowledge into my current QA role. Being able to write tests, automate repetitive tasks, or even contribute to testing frameworks will be a powerful step forward in my career.</p><p>🧩 <strong>Key Takeaway</strong>: Programming may feel like a different world at first, but with patience and curiosity, it becomes a bridge — not a barrier. I’m glad I took the first step.</p><h3>✨ Thanks for reading!</h3><p>Let me know if you’ve had a similar journey into coding, or any tips for a QA exploring the automation side with Python — I’d love to connect!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c45c876d157" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ My DevOps Journey: Learning GitHub Actions and CI/CD in Module 8 of the Cloud Engineering…]]></title>
            <link>https://medium.com/@qaskhandker/my-devops-journey-learning-github-actions-and-ci-cd-in-module-8-of-the-cloud-engineering-0ac6d7ff8745?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ac6d7ff8745</guid>
            <category><![CDATA[cloudformation-template]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cicd-pipeline]]></category>
            <category><![CDATA[github-actions]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Tue, 06 May 2025 14:58:08 GMT</pubDate>
            <atom:updated>2025-05-06T14:58:08.510Z</atom:updated>
            <content:encoded><![CDATA[<h3>🚀 My DevOps Journey: Learning GitHub Actions and CI/CD in Module 8 of the Cloud Engineering Academy</h3><p>DevOps is one of those terms that gets thrown around a lot — but this past module, <strong>Module 8 of the Cloud Engineering Academy</strong>, brought it to life for me in a real, hands-on way. In this module, I dove into <strong>CI/CD</strong>, explored <strong>GitHub Actions</strong>, built real workflows, and learned how to automate deployments for serverless apps. It was frustrating at times (okay, a lot of times), but the lessons I’ve learned are invaluable.</p><h3>🛠️ What I Learned</h3><p>Here are some of the core concepts and tools I picked up during this module:</p><p><strong>— CI/CD (Continuous Integration and Continuous Deployment):</strong><br> I now understand how crucial CI/CD is for modern development teams. It helps developers integrate code frequently, detect issues early, and deploy updates faster.</p><p><strong>— GitHub Actions:</strong><br> GitHub Actions allows us to automate software workflows directly from GitHub. It’s incredibly powerful for building, testing, and deploying applications automatically when changes occur in your repo.</p><p><strong>— Workflow Components:</strong><br> I learned how a workflow is structured — starting from the trigger (on:), the jobs that run, and the sequence of steps that execute within those jobs.</p><h3>🧪 Creating My First Workflow</h3><p>Writing my first GitHub Actions workflow felt a bit intimidating, but once I broke it down, it started to make sense. I began with a basic push workflow that simply echoed messages. From there, I gradually added complexity—building up to a fully working <strong>CI/CD pipeline</strong>.</p><h3>💻 Push Workflow: Real-World CI/CD for Serverless Apps</h3><p>This was a big step for me. I created an <strong>end-to-end CI/CD pipeline</strong> for a serverless application using:</p><p><strong>— AWS Lambda</strong></p><p><strong>— GitHub Actions for automation</strong></p><p><strong>— Securely handling AWS credentials in GitHub Secrets</strong></p><p><strong>— Deploy Lambda functions automatically on push</strong></p><p>I also set up a <strong>local development environment</strong> to support this work. Every time I pushed code, GitHub Actions picked it up and triggered a deploy workflow. It was incredibly satisfying to see automation in action.</p><p>But not everything went smoothly…</p><h3>🐞 Debugging: Frustration Turned Into a Learning Moment</h3><p>I made <strong>a lot</strong> of git commits and pushes.</p><p>And I mean <strong>a lot</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kyOE3AkrwFrijwlCWmxglQ.png" /></figure><p>Every time I thought I had fixed something, GitHub Actions would fail. Most of the time, it was because of small syntax errors in YAML or logic bugs in my CloudFormation or Lambda code. I’ll admit, I was <strong>really frustrated</strong> with myself. But here’s the thing — it was one of the <strong>best learning experiences</strong> I’ve had so far.</p><p>I learned:</p><p>— How to read and interpret GitHub Actions error logs</p><p>— How to isolate which part of my code was failing</p><p>— How to be more <strong>patient</strong> and <strong>systematic</strong> when debugging</p><p>And yes, I have to give a huge shoutout to <strong>ChatGPT</strong> — it was like having a DevOps mentor by my side. I constantly asked for help understanding errors, rewriting parts of workflows, and debugging deployment scripts. Every fix taught me something new.</p><h3>🔁 Pull Request Workflow &amp; CloudFormation Integration</h3><p>After the push workflow, I created a <strong>Pull Request (PR) workflow</strong>. This was a great way to simulate a more collaborative development process. When a PR was opened, my workflow:</p><p>— Validated a CloudFormation template</p><p>— Deployed a test stack using the PR number</p><p>— Commented on the PR with deployment status</p><p>— On PR merge, deleted the test stack (Cleanup step)</p><p>The cleanup step didn’t work at first. I spent a lot of time figuring out why it wasn’t triggering. It turns out it was related to how GitHub handles PR events — especially for merged PRs — and I eventually found a solution using the pull_request_target event. Another bug fixed, another lesson learned.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6RIuS00Mf1Gaqr-SuPdg6Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wh1XBnRKlV6gPfYBNE3ROQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ruYIffd6cBtGnBJo6yvZ7A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4W2VD4VOJEt3R4dSVJrjYw.png" /></figure><h3>🧠 Key Takeaways</h3><p>— DevOps isn’t just tools — it’s a mindset.</p><p>— CI/CD is about <strong>automating confidence</strong> in your code.</p><p>— YAML is sensitive. Take your time.</p><p>— Debugging is where the real learning happens.</p><p>— Document what you fix. It’s your future guide.</p><p>— Use tools like ChatGPT to fill in the knowledge gaps.</p><h3>✨ Final Thoughts</h3><p>Module 8 has been the most technically challenging yet <strong>most rewarding</strong> part of the Cloud Engineering Academy so far. I now feel confident in building automated workflows, understanding the lifecycle of a pull request, and deploying real applications in AWS using GitHub Actions. And while I still have more to learn, I’m proud of how far I’ve come.</p><p>Thanks to my mistakes, my persistence, and a bit of help from ChatGPT — I’m now one step closer to becoming a Cloud Engineer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ac6d7ff8745" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ What I Learned Using Terraform to Deploy a Next.js App on AWS on module 7.]]></title>
            <link>https://medium.com/@qaskhandker/what-i-learned-using-terraform-to-deploy-a-next-js-app-on-aws-on-module-7-4e263f227bd9?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e263f227bd9</guid>
            <category><![CDATA[terrraform]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Wed, 09 Apr 2025 23:10:54 GMT</pubDate>
            <atom:updated>2025-04-09T23:10:54.760Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*gk2qgVB1UoGKxSyQAmcN6Q.png" /></figure><p>Its been 5 months since I completed module 6 in the Cloud engineering academy. Life got in the way. Redundancies where I work took its toll on the QA dept and left us wondering what to do next. My cloud work was on the back burner as my focus shifted back to my QA role and working in a new team and new project. Safe to say 5 months later things have calmed down and I can focus on learning more about Cloud engineering.</p><p>In module 7, I’ve been diving deep into Terraform — an open-source infrastructure as code (IaC) tool that lets you provision and manage cloud infrastructure in a predictable, declarative way.</p><p>In this blog post, I’ll walk through what I learned about Terraform, its key concepts, and how I used it to deploy a production-ready <strong>Next.js</strong> app using <strong>AWS S3</strong>, <strong>CloudFront</strong>, and <strong>DynamoDB</strong>.</p><h3>🔧 Installing Terraform</h3><p>Getting started with Terraform was straightforward. I installed it via Homebrew on macOS:</p><pre>brew tap hashicorp/tap<br>brew install hashicorp/tap/terraform</pre><p>To confirm it was installed correctly:</p><pre>terraform -v</pre><p>This gave me the current version and confirmed that I was ready to start writing infrastructure code.</p><h3>🔌 Providers, Plugins &amp; Configuration Files</h3><p>Terraform uses <strong>providers</strong> to interact with different cloud platforms and services. For my project, I used the <strong>AWS provider</strong>, which lets Terraform manage resources on AWS like S3 buckets, CloudFront distributions, and DynamoDB tables.</p><p>Here’s what the basic configuration looked like:</p><pre>provider &quot;aws&quot; {<br>  region = &quot;eu-west-2&quot;<br>}</pre><p>Terraform plugins are automatically downloaded based on the provider you declare. You don’t need to manually install them — Terraform handles it on init.</p><h3>📁 Terraform Project Structure</h3><p>I organized my project with a clean file/folder structure:</p><pre>terraform-nextjs/<br>├── main.tf<br>├── variables.tf<br>├── outputs.tf<br>├── state.tf<br>└── .terraform.lock.hcl</pre><ul><li>main.tf contains the core resources (S3, CloudFront, DynamoDB)</li><li>state.tf defines backend state config (if using remote state)</li><li>variables.tf stores input variables for reusability</li><li>outputs.tf shows useful values after deployment</li></ul><h3>🧠 Understanding Terraform State</h3><p>Terraform uses a <strong>state file</strong> to keep track of the resources it manages. By default, it creates a local file called terraform.tfstate. You can also configure remote state storage, for example, in an S3 bucket, to enable team collaboration.</p><p>Managing state is crucial — it’s how Terraform knows what to create, update, or delete.</p><h3>📜 Useful Terraform Commands</h3><p>Here are the main Terraform commands I used regularly:</p><ul><li>terraform init – initializes your project and downloads required plugins</li><li>terraform plan – shows what Terraform will do before applying changes</li><li>terraform apply – actually applies the infrastructure changes</li><li>terraform destroy – tears down the resources</li><li>terraform fmt – formats the code</li><li>terraform validate – checks for syntax errors</li></ul><h3>📚 Learning from the Documentation</h3><p>One of the best things about Terraform is the <strong>documentation</strong>. Every provider and resource is well documented at <a href="https://registry.terraform.io/">registry.terraform.io</a>, with examples and supported parameters.</p><p>I often referred to:</p><ul><li>AWS S3 bucket documentation</li><li>CloudFront distribution config</li><li>DynamoDB resource details</li></ul><h3>🔁 Workflow &amp; Deployment Process</h3><p>Here’s the basic Terraform workflow I followed:</p><p>Write configuration files (.tf)</p><p>Run terraform init to set up the project</p><p>Run terraform plan to preview changes</p><p>Run terraform apply to create the infrastructure</p><p>Deploy the Next.js app (by uploading to S3)</p><p>Use CloudFront to serve the app globally via CDN</p><h3>💻 My Project: Deploying a Next.js App on AWS</h3><p>For my project, I built a personal <strong>Next.js portfolio site</strong> and deployed it on <strong>AWS using Terraform</strong>. The infrastructure includes:</p><h3>✅ S3 Bucket</h3><ul><li>Stores the static files from the Next.js build</li><li>Configured for public read access</li><li>Hosted as a static website</li></ul><h3>✅ CloudFront</h3><ul><li>Distributes the site via a global content delivery network (CDN)</li><li>Enforces HTTPS using the default CloudFront certificate</li><li>Linked to the S3 bucket as its origin</li></ul><h3>✅ DynamoDB</h3><ul><li>Used to store dynamic data such as form submissions or page views</li><li>Simple key-value structure with a primary key (LockID)</li><li>Provisioned using Terraform</li></ul><h3>🧩 What I Learned</h3><ul><li><strong>Terraform helps you treat infrastructure like code</strong> — version-controlled, reusable, and consistent.</li><li>Understanding <strong>state management</strong> is key to preventing unintended resource changes.</li><li>The <strong>AWS provider</strong> is extremely powerful but requires careful configuration, especially for things like permissions, access control, and policies.</li><li>Automating deployments makes your projects more professional and scalable.</li><li>Using <strong>CloudFront + S3</strong> is an efficient and cost-effective way to host static frontends.</li></ul><h3>✨ Final Thoughts</h3><p>I now feel way more confident working with infrastructure, and I love how Terraform gives you full control while keeping everything visible and trackable. As I continue to grow my full-stack skills, IaC will definitely be a key part of my workflow.</p><p>If you’re looking to level up your DevOps game — <strong>start with Terraform.</strong> It’s an incredibly powerful tool to have in your stack.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e263f227bd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Module 6: AWS Fundamentals with AWS CloudFormation]]></title>
            <link>https://medium.com/@qaskhandker/module-6-aws-fundamentals-with-aws-cloudformation-d77b639aee85?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/d77b639aee85</guid>
            <category><![CDATA[yaml]]></category>
            <category><![CDATA[visual-studio-code]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloudformation]]></category>
            <category><![CDATA[ec2-instance]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Mon, 07 Oct 2024 17:36:59 GMT</pubDate>
            <atom:updated>2024-10-07T17:36:59.792Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A6J5Ahl2U-VodlmEWJj0Wg.png" /></figure><p>This module has been by far the best one yet, and although it was a large and complex module, I learned a tremendous amount and thoroughly enjoyed every step of the process.</p><p>Diving into <strong>AWS CloudFormation</strong> with templates was incredibly rewarding, as I was able to create and manage infrastructure through code.</p><p>Learning to write:</p><ul><li><strong>yaml templates</strong> in Visual Studio was a highlight, as it allowed me to build projects like creating an <strong>S3 bucket</strong> and validating it through the AWS console, as well as deploying an S3 Static Website.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*V-aI47xYQXFamOg55Bz3BA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*rfblFKEuLYUTtiu2TeQ8XA.png" /></figure><p>The hands-on projects were fantastic. One project focused on creating a <strong>VPC</strong>, where I added both private and public subnets, an internet gateway, route tables, and a bastion host along with security groups.</p><p>Another project involved setting up <strong>EC2</strong> instances and successfully pinging them through the terminal, which really solidified my understanding.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*ngLS4jdKqPCbezbZFogSMA.png" /></figure><p>However, it wasn’t all smooth sailing. I made so many typing mistakes when writing <strong>YAML templates</strong>, especially with indentation errors! Debugging those errors through the AWS console was a great learning experience, and there was no better feeling than rerunning the commands and seeing the green “no errors” confirmation. There were even moments when I realised I was just rerunning old versions without saving the fixes! Despite the setbacks, this module taught me a crazy amount, and I loved every moment</p><p><strong>In addition:</strong></p><p>— I worked on configuring <strong>IAM users</strong>, adding <strong>IAM Groups</strong>, and defining <strong>IAM roles </strong>directly in the templates, further expanding my AWS skill set.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*jmRoKzCQoCJ2KSpvJDU-lw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*8j0gwmYGILu33aWK34TniQ.png" /></figure><p>— A major challenge and accomplishment was setting up an application <strong>load balancer</strong> using the <strong>VPC</strong> template and integrating all the necessary data.</p><p>— To cap it off, I built and configured relational database instances, further rounding out my knowledge of infrastructure management.</p><p>Overall, this module provided an incredible amount of practical knowledge, and each project reinforced my understanding of AWS, from basic components to more advanced architecture. I can’t wait to continue building on this foundation!</p><p>Next, Module 7 — <strong>Infrastructure as Code with Terraform!!!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d77b639aee85" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Module 5]]></title>
            <link>https://medium.com/@qaskhandker/module-5-695eebd4eecf?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/695eebd4eecf</guid>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[regions]]></category>
            <category><![CDATA[vpc]]></category>
            <category><![CDATA[global-infrastructure]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Tue, 17 Sep 2024 15:00:01 GMT</pubDate>
            <atom:updated>2024-09-17T15:00:01.138Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y02a21oIkEEo6zAMNnM_rA.jpeg" /></figure><p>Module 5 of the Cloud Academy is complete, so let’s recap what we covered</p><h3><strong>AWS Global Infrastructure</strong></h3><p>We explored several components that make up AWS’s global infrastructure, which enables users to build and deploy highly available, scalable, and resilient applications worldwide.</p><ul><li><strong>AWS Regions</strong> are geographic areas where AWS clusters its data centers. Each region is isolated from the others, ensuring fault tolerance and stability of AWS resources.</li><li><strong>AWS Availability Zones (AZs)</strong> are independent data centers within an AWS region. These operate separately, so if one AZ fails, the others remain unaffected.</li><li><strong>AWS Local Zones</strong> bring AWS services closer to end users for latency-sensitive applications.</li><li><strong>AWS Edge Locations</strong> are distributed data centers designed to cache content, allowing data to be delivered with the lowest possible latency to users globally.</li></ul><h3>AWS VPC (Virtual Private Cloud)</h3><p>A <strong>VPC</strong> is a logically isolated, private network on the AWS Cloud, giving us full control over our resources and network environment. Here’s an overview of some key VPC components:</p><ul><li><strong>CIDR Block</strong>: This defines the IP address range of the VPC, which determines how many resources can be created within it.</li><li><strong>Subnets</strong>: These are divisions within the VPC. A <strong>public subnet</strong> is accessible from the internet, while a <strong>private subnet</strong> is not. Multiple subnets can be used, such as public ones for front-end applications and private ones for back-end systems or databases.</li><li><strong>Internet Gateway (IGW)</strong>: Allows internet access for resources in public subnets.</li><li><strong>NAT Gateway</strong>: Enables resources in private subnets to send outbound traffic to the internet, while preventing inbound internet traffic.</li><li><strong>Route Tables</strong>: Used to control the flow of traffic within the VPC, route tables can be assigned to subnets to direct traffic to the appropriate destination.</li><li><strong>Security Groups</strong>: These control the inbound and outbound traffic to resources within the VPC. Security groups are stateful, meaning return traffic is automatically allowed without explicit rules.</li><li><strong>NACL (Network Access Control List)</strong>: Similar to security groups but at the subnet level, NACLs control traffic in and out of subnets. Unlike security groups, NACLs are stateless, so explicit rules must be set to allow return traffic.</li></ul><p>This week provided a strong foundation in understanding how AWS’s global infrastructure and VPCs work together to deliver scalable, secure, and resilient applications.</p><h3>Week 5 Project</h3><p><strong>Project 1: VPC Design with Multiple Availability Zones</strong></p><p>The goal of this project was to design a VPC across two availability zones (AZs). Each AZ was required to have:</p><p>- One public subnet<br>- Two private subnets (an Application Subnet and a Database Subnet)</p><p><strong>Steps Involved:</strong><br><strong>1. VPC Configuration:</strong><br> — Set up an <strong>Internet Gateway</strong> to enable internet access for the public subnet.<br> — Configure a <strong>Route Table</strong> for directing traffic in the VPC.<br> — Set up a <strong>NAT Gateway</strong> in the public subnet to allow instances in the private subnets to access the internet securely.<br> — Configure a <strong>Security Group</strong> to manage access control for the instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mM8xFd6SsA8cGXP6U0D7HQ.png" /></figure><p><strong>2. EC2 Instance Setup:</strong><br> — Deploy EC2 instances in the private subnets (Application Subnet) across both availability zones.<br> — Deploy a <strong>Bastion Host</strong> in one of the public subnets to securely manage access to the private instances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uTc0kRiQYIPvc_4iKL4obA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xzwTl2cTWKfzb94AafermA.png" /></figure><p><strong>3. Testing Connectivity:</strong><br> — SSH into the Bastion Host from the internet.<br> — From the Bastion Host, SSH into the EC2AppServer1 instance located in the private subnet of the first availability zone.<br> — Once connected to EC2AppServer1, test connectivity by pinging EC2AppServer2, which is in the private subnet of the second availability zone.</p><p>The successful connection and ping test confirmed the network setup and communication between the two availability zones.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U4LAY3N_TCSCEvoC0h15kw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/684/1*PdTObMIpLaeMk6lENAJiqw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*9A7LAOgf6nVzsPRm3kyBAg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*e8oMfNiHtENwV8ucBCUQ-g.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=695eebd4eecf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Module 4: What I Learned using Linux and Bash]]></title>
            <link>https://medium.com/@qaskhandker/module-4-what-i-learned-using-linux-and-bash-014eedf8c209?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/014eedf8c209</guid>
            <category><![CDATA[bash]]></category>
            <category><![CDATA[ec2-instance]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[iam-roles]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Mon, 29 Jul 2024 14:57:00 GMT</pubDate>
            <atom:updated>2024-07-29T14:57:00.236Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*iRQ8NcqIo7suj7LaZlMWpQ.jpeg" /></figure><h4>Setting Up an AWS EC2 Instance with Linux</h4><p>I began with setting up an AWS EC2 instance running Linux. This task provided hands-on experience with cloud-based infrastructure and the basics of launching and configuring virtual servers in AWS. Understanding the nuances of EC2 setup is crucial for any cloud engineer, as it forms the foundation for deploying scalable applications in the cloud.</p><h4>Navigating the Linux File System</h4><p>Once the EC2 instance was up and running, the next step was to navigate the Linux file system. This involved familiarising myself with the directory structure, understanding the hierarchy, and learning essential commands like ls, cd, pwd, and mkdir. Mastery of these commands is vital for efficiently managing files and directories on a Linux system.</p><h4>Creating and Editing Files</h4><p>Learning how to create and edit files is a fundamental skill in Linux. I used the touch command to create new files and edited them using text editors like Nano and Vim. While Nano is user-friendly and great for beginners, Vim offers powerful features for advanced users. Both tools are indispensable for editing configuration files, scripts, and other text-based documents in a Linux environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fCr8s7Bu9TcXjZFsGe_Y9A.png" /></figure><h4>Managing AWS IAM Roles and S3 Buckets</h4><p>Security and data management are key components of cloud computing. I learned how to create and manage AWS IAM roles and access keys, which are essential for controlling access to AWS resources. Additionally, I practiced creating S3 buckets and copying files to them. This skill is critical for storing and managing large volumes of data securely in the cloud.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uGNbsKXfniOknbRntbm1hA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IhgxfNn5hQB-vrv1be4nYw.png" /></figure><h4>Understanding Linux File Permissions with chmod</h4><p>File permissions in Linux are crucial for maintaining system security and proper access control. I learned how to use the chmod command to change file permissions. This command can grant or restrict read (4), write (2), and execute (1) permissions to the owner, group, and others. For example, setting a file to be readable and writable by the owner but only readable by the group and others involves using chmod 644 filename. Understanding how to manipulate these permissions is essential for protecting sensitive data and ensuring proper access control.</p><h4>Terminating EC2 Instances</h4><p>Finally, learning how to terminate EC2 instances is an important aspect of resource management in AWS. Properly terminating instances helps avoid unnecessary costs and ensures that resources are efficiently utilized. The ability to start, stop, and terminate instances as needed is a fundamental skill for managing cloud infrastructure effectively.</p><h3>Conclusion</h3><p>The Linux and Bash module has taught me skills for managing and operating Linux-based systems in a cloud environment. From setting up EC2 instances to navigating the file system, creating and editing files, managing security with IAM roles and S3 buckets, understanding file permissions, and terminating instances, each step has been a valuable learning experience. These foundational skills are crucial for any cloud engineer and will serve as a solid base for further exploration and specialisation in cloud technologies.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=014eedf8c209" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Week 3 Project 3: Designing a Video Sharing Platform]]></title>
            <link>https://medium.com/@qaskhandker/week-3-project-3-designing-a-video-sharing-platform-2734dab6f0a4?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/2734dab6f0a4</guid>
            <category><![CDATA[s3-bucket]]></category>
            <category><![CDATA[cloud-design]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[video-sharing]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Tue, 23 Jul 2024 23:49:28 GMT</pubDate>
            <atom:updated>2024-07-23T23:49:28.758Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*-YP3e6wYyc8ihVijH9C30g.png" /></figure><p>In this week’s project for the Cloud Engineering Academy, our task is to design a video sharing platform. The platform should enable users to upload videos, store video metadata, transcode videos into multiple resolutions, analyze content for appropriateness, and deliver videos to users with minimal latency.</p><p>Let’s walk through the solution step by step.</p><ol><li><strong>Video Upload and Storage:</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PNpPiLj5ONokembtsMsf1A.png" /></figure><p><strong>Amazon S3</strong> is our storage choice because it is ideal for storing media files. S3 offers highly scalable and durable object storage and is cost-effective since we only pay for the storage we use.</p><p>2. <strong>Metadata Handling:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fG7KCSorUMPR8rBx8ZvCqA.png" /></figure><p>I have chosen <strong>Amazon DynamoDB </strong>for metadata storage. As a fully managed NoSQL database, DynamoDB offers high scalability, performance, and availability. This makes it ideal for storing video metadata such as titles, tags, user likes/dislikes, comments, and other related information.</p><p><strong>3. Video Processing:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x9plUHK3qCO6ey1yICnekQ.png" /></figure><p>My choice for video processing is <strong>Amazon Elastic Transcoder</strong>. This scalable and cost-effective service converts uploaded videos into multiple formats and resolutions. Elastic Transcoder supports a wide range of codecs, enabling the optimisation of video outputs for various devices and network conditions.</p><p>4. <strong>Content Analysis:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*chZdzkpfFyeoYlpI9rddgg.png" /></figure><p>I have chosen <strong>Amazon Rekognition</strong> for content analysis. Amazon Rekognition is a machine learning service that identifies people, objects, text, scenes, activities, and inappropriate content. This capability will help flag unsafe or inappropriate content on the platform.</p><p><strong>Optimised Storage —</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KtVuN5aSZeNeo0ShPeMkog.png" /></figure><p>After processing the video and content analysis the videos are then stored back in another object storage AWS S3, orgainsed into different resolutions for streaming.</p><p><strong>5. Video delivery</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*36VnyY9sxcVvnb8FmO0U_g.png" /></figure><p>I have selected <strong>Amazon CloudFront</strong> as our CDN for global content distribution. CloudFront minimizes latency and ensures high transfer speeds by caching videos at edge locations worldwide. These cached videos are delivered to users from the nearest edge location, resulting in faster video streaming and reduced buffering times.</p><p>So as you can see, using the services from AWS, from S3 buckets, DynamoDb, Amazon Elastic transcoder, Amazon Rekognition Video and Amazon Cloudfront, we can create a Video sharing platform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2734dab6f0a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Module 3 Project 2 — Design Scalable Architecture]]></title>
            <link>https://medium.com/@qaskhandker/module-3-project-2-design-scalable-architecture-51b881ba95a3?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/51b881ba95a3</guid>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Tue, 16 Jul 2024 22:22:42 GMT</pubDate>
            <atom:updated>2024-07-16T22:22:42.162Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/262/1*TnipLH7Bnjn1ZsIaDZ_QIg.jpeg" /></figure><h3>Module 3 Project 2 — Design Scalable Architecture</h3><h3><strong>Traditional vs. Serverless Scaling Architectures</strong></h3><p>For this project, I am tasked with designing a traditional server scaling architecture for a web application and then redesigning it into a serverless architecture. I’ll highlight how scaling is simplified in a serverless approach compared to traditional server scaling.</p><p><strong>Part 1.1: Traditional Server Scaling Design</strong></p><p>Here is a high-level architecture diagram of my website application qascloudcomputing.com, incorporating load balancers, web servers, application servers, and databases:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZTz1IQtbsoYes8fgvm9ksg.png" /></figure><p><strong>Components:</strong><br>1. Load Balancer: Distributes incoming traffic across multiple web servers to ensure even load distribution and high availability.<br>2. Web Servers: Serve static content and handle client requests. In this diagram, there are three web servers.<br>3. Application Servers: Process the business logic of the application. Here, three application servers are depicted.<br>4. Database: Stores the data for the application.</p><p><strong>Connections:</strong><br>- The Load Balancer routes traffic to the Web Servers.<br>- The Web Servers communicate with the Application Servers.<br>- The Application Servers interact with the Database to store and retrieve data.</p><p>This architecture provides a scalable and fault-tolerant design by distributing the load and ensuring that multiple servers can handle the application logic and data storage.</p><p><strong>Part 1.2 Implementing Vertical Scaling for the Database Layer</strong></p><p>Now we will look at Vertical scaling and how it could improve the performance of my website qascloudcomputing.com.</p><p><strong>Vertical Scaling (Scaling Up)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YBT4s_8mDvV7KoPMgo_-fQ.png" /></figure><p>Vertical scaling involves increasing the resources of a single database instance, such as CPU, memory, and storage. Here’s how you would implement vertical scaling for the database layer:</p><p>1. <strong>Choose a Larger Instance Type</strong>: Select a larger instance type that offers more CPU, RAM, and storage. For example, you might move from a `db.t3.medium` instance to a `db.m5.large` instance.<br>2. <strong>Modify the Instance</strong>: In the AWS RDS console, modify the database instance to the new, larger instance type.<br>3. <strong>Storage Scaling</strong>: Increase the allocated storage for the database if more disk space is needed.<br>4. <strong>Maintenance Window</strong>: Schedule the scaling operation during a maintenance window to minimize downtime.<br>5. <strong>Performance Monitoring</strong>: Continuously monitor the database performance to ensure the new resources meet the application’s demands.</p><p><strong>Benefits of Vertical Scaling:</strong><br>- Simplicity: Easier to implement since it involves upgrading the existing instance.<br>- Consistency: Maintains a single database instance, simplifying data management and backups.<br>- Low Overhead: No need to manage multiple database instances.</p><p><strong>Limitations of Vertical Scaling:</strong><br>- Resource Limits: There’s an upper limit to how much you can scale a single instance.<br>- Downtime: Scaling up may require downtime, especially if instance types are changed.<br>- Cost: Larger instances are more expensive.</p><p><strong>Horizontal Scaling Strategy Using Auto Scaling Groups</strong></p><p>With the limitations of vertical scaling, lets think about adding Horizontal scaling to qascloudcomputing.com and the strategy involved.</p><p><strong>Horizontal Scaling (Scaling Out)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WX9XQBCw0UKP4v0vzJwWmA.png" /></figure><p>Horizontal scaling involves adding more instances to handle increased load. Here’s how you would implement horizontal scaling for the web and application server layers using an Auto Scaling Group (ASG) and a Load Balancer:</p><p><strong>1. Set Up Load Balancer:</strong><br> — Deploy an Application Load Balancer (ALB) to distribute incoming traffic across multiple instances.<br> — Configure health checks to ensure traffic is only routed to healthy instances.</p><p><strong>2. Configure Auto Scaling Group:</strong><br> — Create an Auto Scaling Group for the web servers.<br> — Define scaling policies based on metrics such as CPU utilization, request count, or custom metrics.<br> — Specify minimum, maximum, and desired instance counts.<br> — Create another Auto Scaling Group for the application servers with similar configurations.</p><p><strong>3. Launch Templates:</strong><br> — Define launch templates or configurations for web and application servers, specifying the instance type, AMI, and other configuration details.</p><p>4. <strong>Scaling Policies</strong>:<br> — Implement policies to add instances when load increases and remove instances when load decreases (e.g., add an instance when CPU utilization exceeds 70% and remove one when it drops below 30%).</p><p>5. <strong>Integration with Load Balancer</strong>:<br> — Ensure the Auto Scaling Group is associated with the Load Balancer so that new instances are automatically registered and deregistered.</p><p><strong>Benefits of Horizontal Scaling:</strong><br>- Scalability: Can handle large increases in traffic by adding more instances.<br>- Fault Tolerance: Provides redundancy and improves availability since traffic can be routed to multiple instances.<br>- Flexibility: Easier to scale specific layers independently based on demand.</p><p><strong>Limitations of Horizontal Scaling:</strong><br>- Complexity: More complex to implement and manage due to multiple instances.<br>- Latency: Potential for increased latency due to network hops between instances.<br>- Cost: Can be more expensive due to the need for more instances and load balancing.</p><p><strong>Comparing Scaling Strategies</strong></p><p><strong>Vertical Scaling</strong>:<br>- Pros: Simpler to implement, consistent data management.<br>- Cons: Limited by the maximum size of the instance, potential for downtime, higher costs for larger instances.</p><p><strong>Horizontal Scaling</strong>:<br>- Pros: Highly scalable, improved fault tolerance and availability, more flexible.<br>- Cons: Increased complexity, potential latency issues, ongoing management and monitoring overhead.</p><p>In the context of my website application, a hybrid approach could be beneficial. You can use vertical scaling for the database to maintain simplicity and data consistency, while employing horizontal scaling for the web and application servers to handle traffic spikes and ensure high availability. This way, you leverage the strengths of both strategies to optimize performance, cost, and scalability.</p><p><strong>Part 2: Serverless Architecture Design</strong></p><p>In part 2 we will look at serverless scaling. I will redesign the Architecture from part 1 to now show serverless components from AWS and how it can better support my applications functionalities, simplify scaling and whether overall if its better than traditional server applications.</p><p><strong>Serverless Scaling:</strong></p><p>Below is a high-level architecture diagram showing the interaction between these components:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N0cjPSQkd58krWGy-BgKjw.png" /></figure><p>1. Client Interaction:<br> — Users interact with the application through a web browser, which loads the static website hosted on Amazon S3.<br> — CloudFront distributes the static assets to provide low-latency access to users globally.</p><p>2. API Gateway:<br> — API Gateway receives HTTP requests from the front end and routes them to the appropriate Lambda functions.<br> — API Gateway can perform request validation, throttling, and transformation before invoking the Lambda functions.</p><p>3. AWS Lambda:<br> — Lambda functions execute the backend logic in response to API Gateway requests.<br> — Each Lambda function is stateless and executes in a fully managed runtime environment.</p><p>4. Amazon DynamoDB:<br> — Lambda functions interact with DynamoDB to store and retrieve application data.<br> — DynamoDB is a fully managed, serverless, NoSQL database that provides low-latency data access.</p><p>5. Amazon S3:<br> — Apart from serving the static website, S3 can also be used by Lambda functions for file storage, such as user uploads or generated reports.</p><p><strong>Benefits of Serverless Architecture:</strong></p><p>- Scalability: AWS handles scaling automatically. Lambda functions scale out based on the number of incoming requests.<br>- Cost Efficiency: Pay only for what you use. There are no costs when the Lambda functions are not running.<br>- Reduced Operational Overhead: No servers to manage, patch, or maintain.<br>- High Availability: AWS ensures that the services are highly available and fault-tolerant.</p><p>By leveraging these serverless services, your application can achieve greater scalability, reduced operational overhead, and cost savings, while still delivering a robust and responsive user experience.</p><h3>Part 3. Comparison and Analysis</h3><h4>Performance and Cost:</h4><p><strong>Traditional Server Scaling Architecture:</strong></p><p><strong>Performance:</strong></p><p><strong>Vertical Scaling -</strong></p><ul><li><em>Performance under Load</em>: Increasing CPU, memory, or storage on a single server can improve performance for specific tasks but has inherent limits.</li><li><em>Scalability</em>: Limited by the maximum size of the instance. As traffic grows, a single instance can become a bottleneck.</li></ul><p><strong>Horizontal Scaling -</strong></p><ul><li><em>Performance under Load</em>: Adding more instances can distribute the load more effectively. An auto-scaling group can dynamically adjust the number of instances based on traffic.</li><li><em>Scalability</em>: More scalable than vertical scaling. However, managing multiple instances requires more sophisticated load balancing and session management.</li></ul><p><strong>Cost Efficiency</strong>:</p><p><strong>Vertical Scaling -</strong></p><ul><li><em>Cost</em>: Increasing the size of an instance is straightforward but can be expensive. Cost grows significantly with higher instance sizes.</li></ul><p><strong>Horizontal Scaling -</strong></p><ul><li><em>Cost</em>: Costs grow with the number of instances. Auto-scaling helps optimize costs by running only the necessary instances based on demand.</li></ul><p><strong>Development, Deployment, and Maintenance -</strong></p><ul><li><strong>Development</strong>: Requires careful planning for both vertical and horizontal scaling. Developers need to account for load balancing, state management, and possible database bottlenecks.</li><li><strong>Deployment</strong>: Deployments can be complex, especially with horizontal scaling. Rolling updates and blue-green deployments can help minimize downtime.</li><li><strong>Maintenance</strong>: Requires constant monitoring and management of server health, load balancers, and auto-scaling policies. Patching and updates need to be handled manually.</li></ul><p><strong>Serverless Architecture:</strong></p><p><strong>Performance:</strong></p><p><strong>AWS Lambda</strong>:</p><ul><li><em>Performance under Load</em>: Automatically scales with the number of incoming requests. Each function invocation is independent, allowing for massive parallel processing.</li><li><em>Scalability</em>: Virtually unlimited scalability. AWS manages the scaling and load balancing behind the scenes.</li></ul><p><strong>DynamoDB</strong>:</p><ul><li><em>Performance under Load</em>: Scales automatically with demand. Provisioned throughput and on-demand modes ensure consistent performance.</li><li><em>Scalability</em>: Designed for high scalability with minimal management.</li></ul><p><strong>Cost Efficiency</strong>:</p><p><strong>AWS Lambda</strong>:</p><ul><li><em>Cost</em>: Pay-per-use model. Charges are based on the number of requests and execution time. No cost when functions are not running.</li></ul><p><strong>DynamoDB</strong>:</p><ul><li><em>Cost</em>: Charges based on read/write units (provisioned mode) or the number of read/write operations (on-demand mode). Cost-effective for variable or unpredictable workloads.</li></ul><p><strong>Development, Deployment, and Maintenance</strong>:</p><ul><li><strong>Development</strong>: Simplifies development by focusing on individual functions. Requires understanding of event-driven programming.</li><li><strong>Deployment</strong>: Easier deployments with tools like AWS SAM or CloudFormation. Functions can be deployed independently.</li><li><strong>Maintenance</strong>: Minimal maintenance as AWS handles server management, scaling, and availability. Focus shifts to code and business logic.</li></ul><h4>Use Cases:</h4><p><strong>1. Traditional Server Scaling Architecture:</strong></p><ul><li><strong>Complex Applications</strong>: Applications with complex, stateful interactions that require control over the environment.</li><li><strong>Consistent Load</strong>: Applications with a predictable and steady load where maintaining a few large instances is cost-effective.</li><li><strong>Legacy Systems</strong>: Existing applications that are difficult to refactor into a serverless architecture.</li><li><strong>Regulated Industries</strong>: Scenarios where specific compliance or data residency requirements necessitate direct control over the infrastructure.</li></ul><p><strong>2. Serverless Architecture:</strong></p><ul><li><strong>Variable Load</strong>: Applications with highly variable or unpredictable traffic patterns benefit from automatic scaling and pay-per-use pricing.</li><li><strong>Microservices</strong>: Architectures that can be decomposed into small, independent functions with clear input and output.</li><li><strong>Startups and Agile Development</strong>: Projects requiring rapid iteration and deployment, with a focus on reducing operational overhead.</li><li><strong>Event-Driven Applications</strong>: Use cases like real-time data processing, IoT, and backends for mobile apps, where functions are triggered by events.</li></ul><h3>Summary:</h3><p><strong>Traditional Server Scaling Architecture</strong> provides control and flexibility, making it suitable for complex and stateful applications, but comes with higher maintenance overhead and potential scalability limitations. <strong>Serverless Architecture</strong> offers unparalleled scalability and cost efficiency for applications with variable loads and simpler, event-driven logic, at the cost of some control and potential cold-start latency issues.</p><p>Choosing between these architectures depends on the specific needs of the application, including traffic patterns, complexity, and operational capabilities. For new projects, serverless can offer significant advantages, while existing applications might benefit from a gradual migration strategy.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51b881ba95a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Module 3 Project 1 —]]></title>
            <link>https://medium.com/@qaskhandker/module-3-project-1-5ed35a5f19bb?source=rss-81dee1f91811------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ed35a5f19bb</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[serverless-framework]]></category>
            <category><![CDATA[cloud-architecture]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Qas Khandker]]></dc:creator>
            <pubDate>Sun, 14 Jul 2024 11:09:47 GMT</pubDate>
            <atom:updated>2024-07-14T11:09:47.459Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/268/1*phzaEUxtuYy_Eyi1RzvcZQ.jpeg" /></figure><h3>Create your Architecture, compare the 3 different types.</h3><p>I have been tasked with designing an Ecommerce application using the 3 different architectures that I have learnt about in module 3. Using monolithic architecture, then refactor it into microservices, and finally, proposing a serverless approach for certain functionalities. This project aims to provide practical insights into the advantages, challenges, and use cases of each architectural style.</p><h4>Part 1: Monolithic Architecture Design</h4><h4>Monolithic Architecture Design</h4><p>In a monolithic architecture, the entire application is built as a single, cohesive unit. Below is a simplified design for an e-commerce application using this approach:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*daCGp7WN8wrah2daA527Ow.png" /></figure><h4>Components:</h4><p><strong>User Interface (UI) — </strong>Product Catalog/Shopping Cart/Checkout/User Profile</p><p><strong>Business Logic Layer — </strong>Product Management/Order Management/User Management/Payment Processing</p><p><strong>Data Access Layer — </strong>Database Interaction (SQL/NoSQL)</p><p><strong>Database — </strong>Users/Products/Orders/Payments</p><p><strong>Workflow:</strong></p><p><strong>Product Catalog</strong>: Users browse products.</p><p><strong>Shopping Cart</strong>: Users add products to their cart.</p><p><strong>Checkout</strong>: Users enter payment and shipping information.</p><p><strong>Order Processing</strong>: Application processes the payment and records the order.</p><h3>Part 2 Refactoring into Microservices architecture</h3><p>Microservices architecture breaks down an application into smaller, independent services, each responsible for a specific functionality. These services communicate over well-defined APIs, making it easier to develop, deploy, and scale each service independently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4XPGkGeVBTJY1YNleAl8dQ.png" /></figure><h4>Microservices Components:</h4><ol><li><strong>Users</strong> — via web, mobile,</li><li><strong>API Gateway</strong>: Central entry point for all clients.</li><li><strong>Microservices</strong>:</li></ol><ul><li><strong>Product Service</strong>: Manages product catalog.</li><li><strong>Shopping Cart Service</strong>: Manages shopping cart.</li><li><strong>Order Service</strong>: Handles order processing.</li><li><strong>User Service</strong>: Manages user information.</li></ul><p><strong>4. Database</strong>:</p><ul><li>Each service has its own database or schema.</li></ul><p><strong>Key Takeaways:</strong></p><ul><li><strong>Modularity</strong>: Each service is a separate module.</li><li><strong>Scalability</strong>: Services can be scaled independently.</li><li><strong>Flexibility</strong>: Easier to update and deploy individual services.</li><li><strong>Complexity</strong>: Requires managing multiple services and their interactions.</li></ul><h3>Part 3: Incorporating Severless architecture</h3><p>Serverless architecture allows developers to build and run applications without managing the underlying infrastructure. Cloud providers handle the server management, allowing developers to focus solely on writing code. Common examples include AWS Lambda, Azure Functions, and Google Cloud Functions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hpah3R5tsJgAheRkyXIlmQ.png" /></figure><h4>Serverless Components:</h4><p><strong>AWS API Gateway</strong>: Routes requests to appropriate services and serverless functions.</p><p><strong>AWS Lambda </strong>: Handle specific tasks like payment processing, order confirmation emails, and image resizing.</p><p><strong>AWS DynamoDB: </strong>Serverless databases for high scalability and performance. Stores user, product, and order data.</p><p><strong>Key Takeaways:</strong></p><ul><li><strong>No Server Management</strong>: Infrastructure is managed by the cloud provider.</li><li><strong>Scalability</strong>: Automatically scales with demand.</li><li><strong>Cost Efficiency</strong>: Pay only for the compute time you consume.</li><li><strong>Event-Driven</strong>: Functions are triggered by specific events.</li></ul><h4>Conclusion</h4><p>Starting with a monolithic architecture allows for easy development and deployment, suitable for small to medium-sized applications. As the application grows, refactoring into microservices enhances scalability, flexibility, and maintainability. Finally, adopting a serverless approach for specific functionalities like payment processing and notifications can further optimise performance, reduce operational overhead, and ensure seamless scalability. This evolutionary approach to application design ensures that your e-commerce platform remains robust, efficient, and ready to handle increasing user demands.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ed35a5f19bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>