AWS with Intermediate Level Projects - My Journey Through Level 200 Projects

Introduction

In my cloud computing journey, I've successfully completed eight Level 200 (Intermediate) AWS projects, each aimed at mastering different services and gaining hands-on experience with core AWS functionalities. This blog provides an in-depth explanation of these projects, the AWS services I worked with, and the key takeaways from each.

Whether you are a cloud enthusiast or an aspiring AWS professional, these projects will provide valuable insights into scaling, securing, and managing AWS infrastructure efficiently.

Level 200 Intermediate - AWS Projects

Project 1: Create an Auto Scaling Group

In this project, I explored the power of AWS Auto Scaling to manage and automatically adjust EC2 instance capacity based on demand. Auto Scaling helps maintain high availability and improves cost-efficiency by scaling in or out as necessary.

Services Used:

• EC2
• Auto Scaling Group
• CloudWatch (for metrics)
• Launch Template

Objectives:

• Set up an Auto Scaling Group (ASG) to maintain a desired number of instances.
• Define scaling policies based on CloudWatch metrics.
• Ensure instances are launched in multiple Availability Zones for high availability.

Steps Involved:

• Create a Launch Configuration to define instance settings.
• Set up scaling policies based on CPU utilization and NetworkIn.
• Configure CloudWatch alarms to monitor the scaling.

Outcome:
By implementing this project, I gained hands-on experience in dynamically managing EC2 resources to handle varying loads while optimizing costs.

Project 2: Deploy a Docker Container Image on AWS Fargate

AWS Fargate offers serverless compute for containers, and in this project, I deployed a Docker image on Fargate, allowing me to focus on building and deploying the application without managing infrastructure.

Services Used:

• Amazon ECS
• AWS Fargate
• Amazon ECR (Elastic Container Registry)
• IAM (for permissions)

Objectives:

• Build and push a Docker container image to Amazon ECR.
• Deploy the container image using AWS Fargate with ECS.
• Automate scaling and ensure secure access using IAM roles.

Steps Involved:

• Create a Docker image and push it to an ECR repository.
• Define an ECS task definition that specifies the container.
• Deploy the container using AWS Fargate.

Outcome:
The deployment of containerized applications using Fargate demonstrated how easy it is to scale containers without managing the underlying EC2 infrastructure.

Project 3: Create an Aurora RDS Database

Amazon Aurora is a highly available and scalable relational database service. In this project, I set up an Aurora MySQL-compatible database and connected it with an application.

Services Used:

• Amazon Aurora RDS
• Amazon VPC (for networking)
• Security Groups
• IAM

Objectives:

• Launch an Aurora database in a VPC.
• Set up appropriate security configurations to ensure secure database access.
• Optimize the database performance for read and write operations.

Steps Involved:

• Configure an Aurora RDS cluster with multiple availability zones.
• Set up security groups to control access.
• Connect to the database from a local machine using a MySQL client.

Outcome:
This project enhanced my understanding of managed databases in AWS and how Aurora provides scalability and durability while maintaining compatibility with MySQL.

Project 4: Setup a Simple State Machine with at Least Two Steps

This project involved creating a Step Functions state machine, which orchestrates AWS Lambda functions for building serverless workflows.

Services Used:

• AWS Step Functions
• AWS Lambda
• IAM

Objectives:

• Design and deploy a state machine with at least two steps, each step invoking a Lambda function.
• Ensure smooth orchestration and error handling between different functions.
• Monitor execution history for debugging and optimization.

Steps Involved:

• Create two AWS Lambda functions: one for summing numbers, and one for squaring.
• Define a Step Functions state machine that chains the Lambda functions.
• Test the state machine by passing input parameters through the workflow.

Outcome:
The successful orchestration of serverless workflows using Step Functions helped streamline complex processes without managing servers.

Project 5: Create a Serverless API
In this project, I created a serverless API using API Gateway and Lambda to enable fast and scalable web APIs.

Services Used:

• Amazon API Gateway
• AWS Lambda
• Amazon DynamoDB (optional, if used for data storage)
• IAM

Objectives:

• Deploy an API using API Gateway and Lambda.
• Secure the API with IAM roles and API Keys.
• Monitor the API's performance and usage with CloudWatch.

Steps Involved:

• Create an API Gateway endpoint and integrate it with a Lambda function.
• Secure the API using an API key.
• Deploy the API and test the response from a browser or API tool like Postman.

Outcome:
This project gave me a clear understanding of how to create and secure serverless APIs, paving the way for fast, scalable back-end services.

Project 6: Create a CloudWatch Alarm

Monitoring is critical in AWS, and in this project, I created a CloudWatch alarm to automatically notify me when specific thresholds are breached.

Services Used:

• Amazon CloudWatch
• EC2
• SNS (Simple Notification Service)

Objectives:

• Set up monitoring for an EC2 instance.
• Create a CloudWatch alarm based on instance performance metrics.
• Notify through SNS when alarms are triggered.

Steps Involved:

• Create a CloudWatch Alarm based on EC2 CPU utilization.
• Configure SNS notifications for the alarm.
• Test the alarm by generating high CPU load on the instance

Outcome:
This project highlighted the importance of proactive monitoring and automatic alerts, ensuring that potential issues are addressed before they become critical.

Project 7: Create a New CMK in KMS and Encrypt an Object

In this security-focused project, I created a Customer Master Key (CMK) in KMS and used it to encrypt objects in an S3 bucket.

Services Used:

• AWS Key Management Service (KMS)
• Amazon S3

Objectives:

• Create a new CMK in AWS KMS.
• Upload an object to S3 and encrypt it using the CMK.
• Ensure secure access to encrypted objects using IAM roles.

Steps Involved:

• Create a Customer Master Key (CMK) in AWS KMS.
• Configure S3 bucket policies to require encryption using the CMK.
• Upload and encrypt objects with the CMK.

Outcome:
This project deepened my understanding of encryption practices in AWS, especially how KMS and S3 can work together to enhance data security.

Project 8: Create an EFS Shared File System

Amazon Elastic File System (EFS) offers scalable file storage. In this project, I created an EFS file system and shared it across multiple EC2 instances.

Services Used:

• Amazon EFS
• EC2
• Security Groups

Objectives:

• Set up an EFS file system.
• Mount it to EC2 instances in different availability zones.
• Test file sharing between instances.

Steps Involved:

• Create an EFS file system and configure it for multi-AZ access.
• Mount the file system on two EC2 instances in different availability zones.
• Test file-sharing between the instances by creating and accessing files.

Outcome:
This project provided valuable insights into setting up and scaling file storage solutions that can be accessed by multiple instances simultaneously.

Closure

Completing these Level 200 (Intermediate) projects has been an exciting journey. Through these hands-on tasks, I've developed a deeper understanding of various AWS services, from Auto Scaling and serverless technologies to database management and security.

As I move forward, I'll be tackling Level 300 (Advanced) and Level 400 (Expert) projects, which will take more time to complete due to their complexity. Stay tuned for more updates on my cloud journey as I continue pushing the boundaries of AWS!

Shubham Murti — Aspiring Cloud Security Engineer | Weekly Cloud Learning !!

Let’s connect: Linkdin, Twitter, Github