DEV Community: Jeshlin P V

How I Passed the AZ-900 Exam: My Study Plan, Resources & Tips

Jeshlin P V — Sat, 01 Mar 2025 04:46:18 +0000

In this blog, I'll share my experience, the resources I used, and the strategies that helped me pass the exam with confidence.

Why I Took the AZ-900 Exam
As someone deeply interested in cloud computing, I wanted to solidify my understanding of Microsoft Azure and its core services. Since I already had hands-on experience with AWS, I thought learning Azure fundamentals would broaden my cloud knowledge and open up more opportunities.

AZ-900 is an entry-level certification designed for beginners in cloud computing, making it perfect for students, IT professionals, and even non-technical individuals who want to understand cloud concepts.

My Study Plan
I set aside two weeks to prepare for the exam. Here's how I structured my study plan:
Week 1: Focused on learning concepts from video tutorials
Week 2: Took practice tests and reviewed weak areas

Resources I Used
I relied on two main resources that were incredibly helpful:

1️. Adam Marczak's YouTube Videos
Adam Marczak is one of the best instructors for Azure. His free YouTube playlist on AZ-900 covers all topics in a simple, engaging, and practical manner. His real-world explanations helped me grasp concepts quickly. Link

Tip: Take notes while watching the videos and try to relate the concepts to real-world scenarios.

2️. Udemy Practice Tests
Udemy provides high-quality practice tests that helped me understand the exam pattern and identify weak areas. The detailed explanations for each question were useful in reinforcing my learning. Link

Tip: Don't just memorize answers - understand the logic behind them.

Topics You Should Focus On
AZ-900 tests your understanding of Azure's core services, pricing, security, and compliance. Here are the key topics I focused on:
Cloud Concepts - Types of cloud models & benefits
Azure Core Services - Compute, Storage, Networking
Security & Compliance - Identity, Governance, Policies
Azure Pricing & Support - Cost management, SLAs

My Exam Day Experience
On the day of the exam:
✔ I revised my notes for 30 minutes
✔ Managed my time well during the exam

Final Tips for AZ-900 Success
1. Watch Adam Marczak's videos - They simplify complex topics
2. Take Udemy practice tests - Helps in self-assessment
3. Use the Microsoft Learn portal - Explore official Azure documentation
4. Understand, don't memorize - Focus on concepts
5. Stay confident on exam day - You got this!

My Takeaway
Passing AZ-900 boosted my confidence in cloud computing and helped me understand Microsoft Azure better. If you're preparing for the exam, trust the process, use the right resources, and you'll definitely succeed!

Automated Image Labeling System Using AWS Rekognition: A Serverless Approach

Jeshlin P V — Sat, 17 Aug 2024 12:06:37 +0000

To create an image labeling system using AWS services, you can leverage AWS Rekognition, a powerful image and video analysis service. Below are the general steps to set up an image labeling system:

Step-by-Step Guide

1. Set Up AWS Rekognition

Go to the S3 console and create a new bucket.
Upload images to this bucket. I uploaded an image named 'street.jpg'.
Configure IAM Role: Ensure the IAM role has the necessary permissions to access S3 and use Rekognition.
Attach the following policies to the IAM role:

-AmazonRekognitionFullAccess
-AmazonS3ReadOnlyAccess

2. Use AWS Rekognition to Detect Labels

Python Script: Use Boto3, the AWS SDK for Python, to interact with Rekognition.
To configure AWS, run the command "aws configure".
Create a working directory and create a file named 'labels.py'.

Copy and paste the code in the text editor.

import boto3

def detect_labels(photo, bucket):
    client = boto3.client('rekognition')

    response = client.detect_labels(Image={'S3Object': {'Bucket': bucket, 'Name': photo}},
                                    MaxLabels=10)

    print('Detected labels for ' + photo)
    for label in response['Labels']:
        print(f"{label['Name']} : {label['Confidence']}")

def main():
    bucket = 'image-labels-bucket'
    photo = 'street.jpg'
    detect_labels(photo, bucket)

if __name__ == "__main__":
    main()

3. Run the Script

Run your Python script:

python labels.py

Output:

The image I used (street.jpg):

4. Test with Different Images

You can test the script with different images by modifying the image name.

Conclusion

This project effectively demonstrates the use of AWS Rekognition to automate image labeling, providing an efficient and scalable solution for processing visual data. By utilizing a serverless architecture, the system is both cost-effective and easy to maintain, making it a practical approach for real-world applications.

Design and Implementation of a Fault-Tolerant VPC Architecture with Multi-AZ High Availability on AWS

Jeshlin P V — Tue, 09 Jul 2024 07:42:44 +0000

In today's digital era, ensuring high availability and fault tolerance for applications is paramount. AWS offers robust tools and services to help achieve these goals, making it possible to build resilient, scalable, and secure infrastructure. This blog will walk you through the design and implementation of a custom Virtual Private Cloud (VPC) infrastructure on AWS, focusing on fault tolerance and high availability across multiple Availability Zones (AZs).

Introduction
Creating a fault-tolerant architecture means designing systems that continue to operate even when some components fail. By leveraging AWS services such as VPC, subnets, Internet Gateway (IGW), NAT Gateway, Elastic Load Balancer (ALB), and Auto Scaling Groups, you can build a highly resilient infrastructure that ensures your applications remain available and performant.

Project Overview
The primary objective of this project is to set up a custom VPC with the following key components:

VPC: A custom VPC with a defined CIDR block.
Subnets: Two public subnets and two private subnets spread across two different Availability Zones (AZs) to ensure high availability.
Internet Gateway (IGW): Provides internet access to resources in the public subnets.
NAT Gateway: Allows instances in the private subnets to access the internet securely for updates and patches.
Route Tables: Separate route tables for public and private subnets to manage traffic routing.
Elastic Load Balancer (ALB): Distributes incoming traffic across multiple instances in different AZs.
Auto Scaling Group: Manages and scales instances in the private subnets automatically based on demand.

Architecture Design

Multi-AZ Deployment

Distributing resources across multiple AZs enhances fault tolerance by ensuring that an outage in one AZ doesn't bring down the entire system. This architecture includes:

Public Subnets: Two public subnets located in different AZs.
Private Subnets: Two private subnets located in different AZs.

Internet Gateway and NAT Gateway

An Internet Gateway is attached to the VPC to facilitate inbound and outbound internet traffic for public-facing resources. A NAT Gateway is deployed in one of the public subnets to provide internet access to instances in the private subnets, ensuring they can download updates and patches securely without exposing them directly to the internet.

Route Tables

Two separate route tables are configured:

Public Route Table: Directs traffic from public subnets to the Internet Gateway.
Private Route Table: Routes traffic from private subnets to the NAT Gateway.

Elastic Load Balancer (ALB)

The ALB is deployed in the public subnets across multiple AZs, distributing incoming traffic to healthy instances. This setup ensures continuous availability and load distribution, even if an instance or an AZ fails.

Auto Scaling Group

The Auto Scaling Group launches instances in the private subnets, ensuring that the application scales automatically based on demand. By spreading instances across multiple AZs, the architecture can withstand AZ-level failures and maintain the desired capacity.

Fault Tolerance Features

Multi-AZ Distribution: By deploying resources in multiple AZs, the architecture can handle the failure of an entire AZ without affecting the application's availability.
Elastic Load Balancer: The ALB automatically routes traffic to healthy instances. If an instance or an AZ fails, the ALB reroutes traffic to instances in other AZs.
Auto Scaling Group: Ensures that the application maintains the required number of instances, launching new ones in different AZs if some instances fail.
NAT Gateway: Using multiple NAT Gateways in different AZs can enhance fault tolerance, ensuring continuous internet access for instances in private subnets even if one NAT Gateway fails. Benefits of the Architecture
Scalability: The Auto Scaling group adjusts the number of running instances based on demand, ensuring optimal resource usage.
High Availability: The multi-AZ deployment ensures that the application remains available even in the event of an AZ failure.
Security: The separation of public and private subnets enhances security by restricting internet access to internal resources.
Cost Efficiency: By automatically adjusting resources based on demand, the architecture helps minimize costs while maintaining performance.

Get the complete code here.

Procedures for Using Terraform Commands

Terraform is a powerful tool for managing infrastructure as code. By following these steps, you can efficiently create, manage, and destroy AWS infrastructure using Terraform. Below are the key procedures and commands you'll use:

Step 1: Initialize the Project
Initialize your Terraform project to download the necessary provider plugins.

terraform init

Step 2: Validate the Configuration
Validate your Terraform files to ensure there are no syntax errors.

terraform validate

Step 3: Plan the Infrastructure Changes
Generate an execution plan to see what changes Terraform will make to your infrastructure.

terraform plan

Step 4: Apply the Infrastructure Changes
Apply the changes specified in the execution plan to create or update your infrastructure.

terraform apply

Step 5: Destroy the Infrastructure
When you no longer need the infrastructure, you can destroy it using:

terraform destroy

Conclusion
Building a resilient and scalable VPC infrastructure on AWS involves leveraging various AWS services and best practices to ensure high availability and fault tolerance. By distributing resources across multiple AZs, utilizing load balancing, and implementing auto-scaling, you can create a robust environment capable of handling failures gracefully and maintaining continuous operation.

This architecture is an excellent foundation for deploying secure, scalable, and highly available applications on AWS, ensuring that your infrastructure can adapt to changing demands and withstand unexpected failures.

Blog: Creating, Modifying, and Destroying an EC2 Instance in AWS with Terraform

Jeshlin P V — Wed, 26 Jun 2024 15:42:21 +0000

Introduction

Hello Friends! I’ve been exploring the capabilities of Terraform and AWS. Recently, I worked on creating, modifying, and destroying an EC2 instance with Terraform. This blog will detail the steps I followed.

Understanding the tools

Terraform

Terraform is an open-source tool that allows you to define and provision infrastructure as code. Today, I learned some of the basics of Terraform and used it to create an EC2 instance.

Amazon EC2 (Elastic Compute Cloud)

Amazon EC2 provides scalable virtual servers in the cloud, allowing you to run applications and services with flexible computing power.

Here’s a brief overview of my Terraform journey:

● Installation: I started by installing Terraform on my local machine. This was straightforward, requiring just a few commands to download and install the binary.

● Writing Configuration Files: Terraform uses configuration files written in HashiCorp Configuration Language (HCL). I created a simple configuration file to define an EC2 instance.

● Applying the Configuration: Using the “terraform apply” command, I provisioned the resources defined in my configuration file. Terraform handled the creation of the EC2 instance, showing me the power of infrastructure as code.

Here's how I did it:

1. Install Terraform

Ensure Terraform is installed on your local machine. If not, download and install it from the Terraform website. I used Chocolatey software to install Terraform.

2. Set Up Your Working Directory

To configure AWS, open your terminal and run the command "aws configure".
Create a new directory for your Terraform configuration files.
Navigate to this directory in your terminal.

3. Create a Terraform Configuration File

In your working directory, create a new file named 'main.tf'.

Define the AWS provider and the region where the EC2 instance will be created:

provider "aws" {
  region = "us-west-2"
}

Define the EC2 instance resource with the desired AMI ID and instance type:

resource "aws_instance" "ec2-instance" {
  ami           = "ami-0c55b159cbfafe1f0"  # Replace with your desired AMI ID
  instance_type = "t2.micro"
}

4. Initialize Terraform

In the terminal, run the following command to initialize Terraform and download the necessary plugins for the AWS provider:

terraform init

5. Apply the Configuration to Create the EC2 Instance

Apply the configuration to create the EC2 instance by running:

terraform apply

Terraform will display a plan of what will be created. Type yes to confirm and create the instance.

6. Modify the EC2 Instance

To modify the EC2 instance, update the instance_type in the main.tf file:

resource "aws_instance" "ec2-instance" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.medium"  # Updated instance type
}

Apply the changes by running:

terraform apply

Terraform will detect the change and prompt you to confirm the update. Type yes to apply the modification.

7. Destroy the EC2 Instance

When you no longer need the EC2 instance, destroy it by running:

terraform destroy

Terraform will ask for confirmation. Type yes to confirm and destroy the instance.

Conclusion

Working with Terraform to create, modify, and destroy an EC2 instance, was an enlightening experience. This hands-on approach demonstrated the power of IaC in managing cloud resources efficiently and consistently. I'm excited to continue exploring Terraform and AWS and learning more about automating and managing infrastructure.