DEV Community: Prajwal KP

Brew Your Own Compiler: Building LLVM/Clang from Source on Any OS!

Prajwal KP — Sun, 14 Sep 2025 13:47:36 +0000

Building LLVM/Clang from Source: Ubuntu, Fedora, Arch, Windows, macOS
Why build LLVM/Clang from source? Because pre-built binaries are like instant coffee functional, but you miss the aroma of roasting your own beans! Let’s brew the freshest compiler toolchain for your system, whether it’s Linux, Windows, or macOS.

👋 Hey there! I'm Prajwal from Bengaluru a relentless explorer in computing.

Started with crafting sleek, user-focused web apps, then dove deep into infrastructure automation and DevOps.
Now passionate about systems programming, compiler engineering, and the Rust ecosystem.
I thrive where software meets hardware: building safe, fast, and efficient code.

✨ Turning caffeine into code (and occasional bugs) since 2023
🔭 Interests: Systems programming • Compilers • The Rust ecosystem🦀 Advocate for: Safe, fast, and reliable software craftsmanship
🤝 Open to collaborate on: Rust, low-level projects, compiler toolchains
💡 Still hands-on with: TypeScript, Go, DevOps, Web Development but my heart beats in cargo run

⚙️ What drives me:

Systems Programming: kernel dev, OS work, drivers, performance tuning
Compiler Construction: language design, parsing, LLVM, optimizations
DevOps: modern infra, automation, CI/CD workflows
The Rust & Go Philosophy: safety, concurrency, and zero-cost abstractions

Prerequisites by OS
Ubuntu / Debian

sudo apt update
sudo apt install -y build-essential git cmake ninja-build \
    python3-dev libtinfo-dev libxml2-dev zlib1g-dev \
    libedit-dev swig curl

Installs GCC/g++, CMake, Ninja, Python headers, and necessary dev libraries.

Fedora

sudo dnf install -y @development-tools git cmake ninja-build \
    python3-devel ncurses-devel libxml2-devel zlib-devel \
    libedit-devel swig curl

Uses Fedora’s package groups and development headers.

Arch Linux

sudo pacman -Syu --needed base-devel git cmake ninja \
    python ncurses libxml2 zlib libedit swig curl

Uses pacman and Arch-specific base-devel group.

Windows
Requirements:

Visual Studio 2019 or newer (Community Edition OK)
Latest CMake (comes with recent Visual Studio)
Git for Windows
Python 3.x (from https://python.org or Microsoft Store)
Optional: Ninja build system

Steps:

Open x64 Native Tools Command Prompt for VS.
Install Git for Windows and ensure git is in your PATH.
Clone the repository:git clone --depth 1 https://github.com/llvm/llvm-project.git
cd llvm-project

Create a build directory:mkdir build
cd build

Configure with CMake and Visual Studio:

cmake -G "Visual Studio 17 2022" -A x64 ../llvm ^
  -DCMAKE_BUILD_TYPE=Release ^
  -DLLVM_ENABLE_PROJECTS="clang;lld" ^
  -DLLVM_ENABLE_ASSERTIONS=ON

For Ninja (if installed): Use -G "Ninja" instead.

Build LLVM (all targets in Release mode):
cmake --build . --config Release -- /m

Optionally run tests:
ctest -C Release

Install:
cmake --install . --config Release

For full instructions, see LLVM + Visual Studio Setup.

macOS
Requirements:

Xcode (install from App Store)
Homebrew (https://brew.sh)
Install tools:brew install cmake ninja git python3 swig curl

Some systems may need:
brew install bzip2 xz zlib lz4 zstd coreutils make

Steps:

Clone LLVM:git clone --depth 1 https://github.com/llvm/llvm-project.git
cd llvm-project

Create a build directory:
mkdir build && cd build

Configure the build:

cmake -G Ninja ../llvm \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_INSTALL_PREFIX=/usr/local \
  -DLLVM_ENABLE_PROJECTS="clang;lld" \
  -DLLVM_ENABLE_ASSERTIONS=ON

Build:ninja
Run tests:
ninja check-llvm

Install (may require sudo):
sudo ninja install

macOS builds use Clang and Xcode-provided SDKs by default.

General Build and Project Structure

These steps are the same across all platforms (use platform-specific package install and generator):

Clone Repository: git clone --depth 1 https://github.com/llvm/llvm-project.git
cd llvm-project

Out-of-Source Build:
mkdir build && cd build

CMake Configuration:cmake -G Ninja ../llvm \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_INSTALL_PREFIX=/usr/local \
  -DLLVM_ENABLE_PROJECTS="clang;lld" \
  -DLLVM_TARGETS_TO_BUILD="X86" \
  -DLLVM_ENABLE_ASSERTIONS=ON

Use -G "Visual Studio 17 2022" and -A x64 on Windows.

Build:

Linux/macOS: ninja

Windows:
cmake --build . --config Release -- /m

Run Tests (Optional):

Linux/macOS: ninja check-llvm
Windows: ctest -C Release

Install:

Linux/macOS: sudo ninja install
Windows: cmake --install . --config Release

Platform-Specific Notes

Windows: Only Visual Studio builds are officially supported. If forced to use MinGW, expect compatibility issues.
macOS: Must have Xcode's command-line tools. Some library locations may differ (Homebrew paths).
Linux: Most distros already provide LLVM as packages; building source is for custom/bleeding-edge needs.

Management: Uninstallation and Upgrades

Linux/macOS

Use install_manifest.txt after install to track files:cd build
sudo xargs rm -vf < install_manifest.txt

Or, prefer a custom install prefix and simply delete the install directory.

Windows

If you used the default CMake install, files were put under the chosen prefix (e.g., C:\Program Files\LLVM).
Use the Windows installer or simply remove the install folder.

Checking Installation

Run:

clang --version
llc --version

If these return your custom version info, installation succeeded!
Additional Resources

Congratulations, you’ve just compiled LLVM/Clang like a coding wizard! Now go forth and optimize the world or at least your next project. And if your compiler crashes, don’t blame me; I’m just the guide, not the gremlin in your machine!

Introduction to AWS CloudFormation: A Beginner's Guide to Infrastructure as Code

Prajwal KP — Fri, 28 Feb 2025 18:59:29 +0000

AWS CloudFormation is like a service that helps you model and set up your AWS resources so that you can like spend less time managing those resources and more time focusing on what matters most that is your application. The best part is you don't need to individually create and configure AWS resources and figure out what's dependent on what Cloud Formation handles that for you.

Introduction

I am Prajwal KP, a second-year student from Bangalore, passionate about full-stack web development and DevOps.
Here is my LinkedIn, GitHub

What is AWS CloudFormation?

AWS CloudFormation is an Infrastructure as Code( IAC ) service that allows you to define and provision AWS resources in a declarative way.
We use CloudFormation templates which can be written in YAML or JSON to like describe the desired state of the infrastructure.

Why do we need CloudFormation?

Managing cloud infra manually can quickly become complex and error-prone, mainly on a application scale.

AWS CloudFormation solves this by offering a way to define, deploy, and manage cloud resources using code. Here’s why it’s essential:

Automation and Consistency: With CloudFormation, we can automate resource creation and ensure every deployment is consistent — no more accidental misconfigurations.
Infrastructure as Code (IaC): It lets us version-control your infrastructure the same way we manage application code, making rollbacks and collaboration easier.
Dependency Management: CloudFormation automatically handles resource dependencies, so we don’t have to worry about creating resources in the correct order — it figures that out for us.
Scalability: Need to spin up identical environments for development, testing, or production? CloudFormation makes it seamless by deploying the same stack repeatedly.
Change Management: It allows you to preview changes (using Change Sets) before applying them, reducing the risk of unexpected updates breaking your setup.
Cross-Region and Cross-Account Deployments: Easily replicate infrastructure across AWS regions and accounts using a single template.

Now lets look into some terminology

Understanding AWS CloudFormation involves a few key terms. Let’s break them down simply and clearly!

Templates: These are text files written in either JSON or YAML that acts as the "scripts" for CloudFormation.
- CloudFormation reads templates as inputs.
- They describe the desired state of your infrastructure.
Stacks: A stack is a collection of AWS resources that CloudFormation manages as a single unit.
- CloudFormation uses templates to create stacks.
- To make changes, you updates the template and apply the changes by updating the stack.
ChangeSet: Before updating a stack, you can generate a change set.
- A change set shows how proposed changes will affect your existing resources.
- This is crucial for live systems to prevent unexpected disruptions.
- For example, renaming an RDS instance will:
  - Create a new instance.
  - Delete the old one.
- Result: This could cause data loss if not handled carefully.

Now lets look into Templates.

In AWS CloudFormation, templates are written with either JSON or YAML files that define the AWS resources you want to create, like EC2 instances, S3 buckets, or IAM roles. These templates act as blueprints for your infrastructure.

Templates Formats

CloudFormation supports two formats for writing templates:

YAML: A human-readable format, easier to write and maintain.
JSON: A structured format, more rigid but familiar to developers used to working with APIs.

Most developers prefer YAML because of its simplicity, especially for larger templates. Both formats work the same way, so it's just a matter of readability and convenience.

Example for template(JSON)

{
  "AWSTemplateFormatVersion": "version date",
  "Description": "JSON string",
  "Metadata": {},
  "Parameters": {},
  "Rules": {},
  "Mappings": {},
  "Conditions": {},
  "Transform": {},
  "Resources": {},
  "Outputs": {}
}

Example for template(YAML)

---
AWSTemplateFormatVersion: version date
Description: String
Metadata: template metadata
Parameters: set of parameters
Rules: set of rules
Mappings: set of mappings
Conditions: set of conditions
Transform: set of transforms
Resources: set of resources
Outputs: set of outputs

Now lets start an instance.

create a file named .yaml extenstion and write down the below code

Resources:
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      InstanceType: t2.micro
      ImageId: ami-0ff8a91507f77f867

Now lets run the above template

Search for the CloudFormation service in AWS.

Click on create task.
Click on Template is ready -> Upload a template file.
Select the file and upload it.
Give the stack name -> Click Next.
U can give some tags if required -> u continue with the default -> Next.
Last in review section just check everything and then click Create stack.
We can see that in events tab u can look at the status-it might say CREATE_IN_PROGRESS.
Click on refresh to see the updated status.
It says CREATE_COMPLETE after the completion.

now for updating the name we add tags to specify the instance name

Resources:
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      InstanceType: t2.micro
      ImageId: ami-0ff8a91507f77f867
      Tags:
        - Key: "Name"
          Value: "MyFirstInstance"

Now back to AWS console click on Update stack -> Replace current template -> Update a template file -> Click Next -> Keep everything default and click next -> At last click Update stack.
After it updates we can verify it by checking the EC2 instance and the name of it should be updated.

This is it for the introduction to AWS CloudFormation.

In the next blog, we'll tackle Intrinsic Functions, Change Sets, and how to manage multiple resources using Mappings and Pseudo Parameters. Stay tuned there’s a lot more to uncover!

Automate Spotify Playlist Management Using Terraform: A Step-by-Step Guide

Prajwal KP — Sat, 22 Feb 2025 07:28:34 +0000

If you're new to Terraform and infrastructure as code (IaC), I recommend going through my previous post here, where I covered the fundamentals of Terraform. Understanding the basics will help you follow along smoothly as we dive into provisioning an AWS EC2 instance using Terraform. Once you're comfortable with the core concepts, you can continue with this guide to apply Terraform in a real-world use case.

Introduction

I am Prajwal KP, a second-year student from Bangalore, passionate about full-stack web development and DevOps.
Here is my LinkedIn, GitHub

Terraform Spotify Playlist Automation

Project Overview

This project automates the creation and management of multiple Spotify playlists using Terraform. It utilizes the Spotify API to interact with your Spotify account and create playlists tailored for different occasions such as morning, evening, party night, etc.

Prerequisites

Before starting, make sure you have the following:

Terraform Installed: Ensure Terraform is installed on your machine.
Docker Installed: Make sure Docker is installed and running.
Spotify Account: You need a Spotify account (free tier is sufficient).
Spotify Developer Account: Register and create an application to get the Client ID and Client Secret.
VS Code Editor: Recommended for editing Terraform files.

Steps to Complete the Project

1. Set Up Terraform Project

Create a new directory for your Terraform project and navigate to it in your terminal.

2. Store Credentials Securely

Create a .env file to store your Spotify application's Client ID and Secret:

SPOTIFY_CLIENT_ID=<your_spotify_client_id>
SPOTIFY_CLIENT_SECRET=<your_spotify_client_secret>

Obtain Spotify API Credentials

To interact with Spotify's API, you need to create a Spotify Developer App:

Go to the Spotify Developer Dashboard.
Log in with your Spotify account.
Click on "Create an App" and fill in the required details.
Set the Redirect URLS as http://localhost:27228/spotify_callback
U can get the client id here.

3. Define Spotify Provider

Create file named provider.tf and paste the below content

terraform {
  required_providers {
    spotify = {
      source  = "conradludgate/spotify"
      version = "0.2.7"
    }
  }
}

provider "spotify" {
  # Configuration options
  api_key = var.spotify_api_key
}

Also create a .env and fill in the details

Now under variables.tf paste the below code

variable "spotify_api_key" {
  type = string
}

Now create terraform.tfvars

spotify_api_key = <Paste_Your_Api_key>

To get this keymake sure to run the below command and verify it.

docker run --rm -it -p 27228:27228 --env-file .env ghcr.io/conradludgate/spotify-auth-proxy

Now finally create playlist.tf

resource "spotify_playlist" "tearraform" {
  name = "Tearraform"
  tracks = ["2plbrEY59IikOBgBGLjaoe", "0VjIjW4GlUZAMYd2vXMi3b"]
}

data "spotify_search_track" "Eminem" {
  artist = "Eminem"
  limit = 10
}

resource "spotify_playlist" "From_Eminem" {
  name = "From Eminem"
  tracks = data.spotify_search_track.Eminem.tracks[*].id
}

Breakdown

Create a playlist with specific tracks:

resource "spotify_playlist" "tearraform" {
  name   = "Tearraform"
  tracks = ["2plbrEY59IikOBgBGLjaoe", "0VjIjW4GlUZAMYd2vXMi3b"]
}

Creates a playlist named "Tearraform".
Adds tracks using Spotify track IDs.
- Search for Eminem's top 10 tracks:

data "spotify_search_track" "Eminem" {
  artist = "Eminem"
  limit  = 10
}

Fetches top 10 tracks by Eminem from Spotify's API.
Create a playlist with Eminem's tracks:

resource "spotify_playlist" "From_Eminem" {
  name   = "From Eminem"
  tracks = data.spotify_search_track.Eminem.tracks[*].id
}

Creates a playlist named "From Eminem".
Dynamically adds the top 10 tracks found in the search.

4. Start Spotify Authorization Proxy

Ensure Docker Desktop is running, then start the authorization proxy server:

docker run --rm -it -p 27228:27228 --env-file .env ghcr.io/conradludgate/spotify-auth-proxy

5. Initialize and Apply Terraform Configuration

Initialize the Terraform configuration:

terraform init

Plan the Terraform configurations

terraform plan

Apply the Terraform configuration:

terraform apply

6. Verify Playlists on Spotify

After applying the Terraform configuration, log in to your Spotify account and verify that the playlists have been created and populated with the specified tracks.

Conclusion

Automating Spotify playlist management with Terraform streamlines the process of creating and maintaining playlists for various occasions. Customize the playlists and tracks according to your preferences to enhance your music listening experience.

Infrastructure as Code: Creating an AWS EC2 Instance with Terraform

Prajwal KP — Fri, 07 Feb 2025 21:39:23 +0000

If you're new to Terraform and infrastructure as code (IaC), I recommend going through my previous post here, where I covered the fundamentals of Terraform. Understanding the basics will help you follow along smoothly as we dive into provisioning an AWS EC2 instance using Terraform. This guide is beginner-friendly, so even if you're just getting started, you'll be able to follow along and apply Terraform in a real-world use case with ease.

Introduction

I am Prajwal KP, a second-year student from Bangalore, passionate about full-stack web development and DevOps.
Here are my LinkedIn, GitHub

What Is Terraform?

Terraform, developed by HashiCorp, is a powerful open-source Infrastructure as Code (IaC) tool that enables declarative provisioning, management, and automation of infrastructure across multiple cloud providers and on-premises environments.

It allows users to define infrastructure using a high-level configuration language (HCL) and facilitates infrastructure lifecycle management through execution plans, resource graphs, and state management. Terraform’s provider ecosystem extends beyond traditional cloud platforms like AWS, Azure, and Google Cloud to include Kubernetes, databases, networking, and even SaaS applications, making it a highly versatile tool for modern DevOps and cloud-native architectures.

Spinning Up an EC2 Instance with Terraform Magic

Let's Start Writing Some Terraform Code.

In this post, I'll walk you through the step-by-step process of launching an AWS EC2 instance using Terraform, making infrastructure deployment seamless and automated.

Open your VS Code or any other code editor to start coding.

Step 1: Find instanceId to launch an instance

Create a new file named instId.tf and copy the below code into it.

# data "resource type" "resource name"
data "aws_ami" "amiId" {
  most_recent = true

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }

  owners = ["099720109477"]
}

# output block

output "instance_id" {
  description = "AMI ID of the instance"
  value       = data.aws_ami.amiId.id
}

Breakdown:

This file is basically used to find an instance Id to launch an instance.

To launch an EC2 instance, we'll create additional .tf files to define the required configurations. Additionally, since an instance requires a key pair and a security group, I'll organize these resources into separate folders for better structure and maintainability.

Step 2: Create `provider.tf`

Our provider for this setup will be AWS, where we can specify important details such as the desired region, the key pair to use, and additional provider configurations to customize our deployment.
Paste the below code.

provider "aws" {
  region = "us-east-1"
}

For more details click here

Step 3: Set Up a Key Pair and Security Group

Create a new file under the same directory as KeyPair.tf and one more file as SecGrp.tf
Open file KeyPair.tf and paste the following

resource "aws_key_pair" "my-key" {
  key_name   = "my-key"
  public_key = ""
}

To generate the keys
- Open the terminal in the same directory and type ssh-keygen.
- Enter the name as mykey and let other fields be default.
- Then type ls and check whether the private and public keys are present.
- Then type cat mykey.pub and copy the output and paste it as the value for public_key inside KeyPair.tf and save it.
Now let's create the security group

Open the SecGrp.tf and paste the code.

resource "aws_security_group" "my-sg" {
  name        = "my-sg"
  description = "my-sg"

  tags = {
    Name = "my-sg"
  }
}

resource "aws_vpc_security_group_ingress_rule" "sshfromyIp" {
  security_group_id = aws_security_group.my-sg.id
  cidr_ipv4         = "Your_Ip/32"
  from_port         = 22
  ip_protocol       = "tcp"
  to_port           = 22
}

resource "aws_vpc_security_group_ingress_rule" "allow_http" {
  security_group_id = aws_security_group.my-sg.id
  cidr_ipv4         = "0.0.0.0/0"
  from_port         = 80
  ip_protocol       = "tcp"
  to_port           = 80
}

resource "aws_vpc_security_group_egress_rule" "allow_all_outbound_ipv4" {
  security_group_id = aws_security_group.my-sg.id
  cidr_ipv4         = "0.0.0.0/0"
  ip_protocol       = "-1" # -1 for all incoming protocols
}

resource "aws_vpc_security_group_egress_rule" "allow_all_outbound_ipv6" {
  security_group_id = aws_security_group.my-sg.id
  cidr_ipv6         = "::/0"
  ip_protocol       = "-1" # -1 for all incoming protocols
}

Breaking Down the Security Group Configuration

Creating the Security Group – Defines a security group named my-sg with basic tagging for identification.
Allowing SSH Access – Enables SSH (port 22) access only from your IP for security. Replace Your_Ip with your actual public IP find it here.
Allowing HTTP Access – Opens port 80 to allow HTTP traffic from anywhere (0.0.0.0/0).
Allowing All Outbound Traffic – Ensures the instance can access the internet by allowing unrestricted outbound traffic for both IPv4 and IPv6.

Step 4:

Let's write the code to launch instance or we can say that to maintain an instance

Create a new file as instance.tf and copy the below code.

resource "aws_instance" "web" {
  ami                    = data.aws_ami.amiId.id
  instance_type          = "t2.micro"
  key_name               = aws_key_pair.my-key.key_name
  vpc_security_group_ids = [aws_security_group.my-sg.id]
  availability_zone      = "us-east-1a"

  tags = {
    Name    = "my-web"
    Project = "First"
  }
}

resource "aws_ec2_instance_state" "web-state" {
  instance_id = aws_instance.web.id
  state = "running"
}

Breaking Down the EC2 Instance Configuration

Defining the EC2 Instance – Creates an EC2 instance using an AMI (amiId), sets the instance type to t2.micro, and assigns it a key pair for SSH access.
Security Group Association – Attaches the previously created security group (my-sg) to control inbound and outbound traffic.
Availability Zone Selection – Specifies the instance should launch in us-east-1a, ensuring control over its placement within the AWS region.
Tagging for Organization – Adds metadata with the name "my-web" and associates it with the project "First".
Ensuring the Instance is Running – Uses a separate resource to maintain the EC2 instance in a "running" state, preventing unintended shutdowns.

Cool! Now that we've defined our infrastructure, let's put it into action by executing our Terraform commands. We'll initialize the configuration, review the changes, and apply them to deploy our EC2 instance. 🚀

terraform init ( to download all the required libraries from the registry)
terraform fmt ( to correct the format )
terraform validate ( to check the syntax )
terraform plan ( it is important to read all the changes )
terraform apply

Voila! 🎉 If everything executed without errors, your EC2 instance should now be up and running. To verify, head over to the AWS Management Console, ensure you're in the correct region, and navigate to the EC2 Dashboard. Here, you can check the instance state to confirm it's running. Also, review the Security Group settings to ensure the correct inbound and outbound rules are applied. Happy automating! 🚀

After checking it and using it to delete the instance we can type terraform destroy to completely delete the instance.

Conclusion

And that’s a wrap! 🎉 You’ve successfully deployed and managed an EC2 instance using Terraform, making infrastructure automation easier and more efficient. But this is just the beginning! There’s so much more to explore in cloud computing, DevOps, and automation.

Stay tuned for my upcoming posts, where I'll dive into more exciting topics and hands-on guides to help you level up your skills. 🚀 See you in the next one! 😊

Getting Started with Terraform: Automating AWS Infrastructure

Prajwal KP — Wed, 05 Feb 2025 18:51:00 +0000

What Is Terraform?

It is a tool from HashiCorp, and its primary purpose is to manage the infrastructure on the cloud.

It's also called as Infrastructure as a code(IaC).

Terraform has become a default standard for cloud automation, and today's time it can manage almost all the cloud providers like AWS, Azure, Google Cloud, Oracle Cloud, even Docker, and even Kubernetes.

How Does It Look?

Terraform code is structured and declarative, similar to JSON or YAML, but with its own HCL (HashiCorp Configuration Language) syntax. Here’s an example of a simple Terraform configuration:

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "WebServer"
  }
}

Breakdown:

Provider Block: Specifies the cloud provider (AWS, Azure, etc.) and its configurations.
Resource Block: Defines the infrastructure resource (e.g., an EC2 instance).
Attributes: Properties like ami, instance_type, and tags configure the resource.

After writing this, running terraform apply provisions the instance. Terraform ensures that the infrastructure matches the defined state, making it a powerful tool for Infrastructure as Code (IaC).

To get started, install Terraform by following the official installation guide here.

To check the version to ensure it's installed, run:
terraform --version

Setting Up AWS Access for Terraform

Breakdown:

Go to your AWS account and create an IAM user.
Save the access key on your device.

Ok Let's Begin:

First log in to your AWS account search for IAM(Identify and Access Management)
Go to users -> create user -> enter name -> next.
For Set permissions select Attach policies directly -> Choose administratorAccess -> next and finally create user.

Now User Is Created So Lets Create The Access Key:

Click on the newly created username -> click on Security credentials tab.
Find Create access key -> Click on Create access key -> Select Command Line Interface(CLI) -> Next -> Create the access key.

Configure AWS CLI:

Open Git Bash or any other terminal and run:
Run aws configure. It will prompt you for an Access Key and Secret Key—paste them from your AWS account and keep the rest as default.

Let's Start Writing Some Terraform Code.

In this post, I'll cover how to find an amiId for an EC2 instance.
Steps:

Open your VS Code or any other code editor to start coding.
create a file called instId.tf and paste the code given below.

# The "data" block is used to fetch data from an existing resource
# This block retrieves information about the latest Amazon Machine Image (AMI) for Ubuntu 22.04
data "aws_ami" "amiId" {
  most_recent = true  # Ensures that the most recent AMI matching the filters is selected

  # First filter to match AMI names following a specific pattern
  filter {
    name   = "name"  
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]  
    # The wildcard (*) ensures it picks up all versions of Ubuntu 22.04 server AMIs
  }

  # Second filter to ensure the AMI uses HVM (Hardware Virtual Machine) virtualization
  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }

  owners = ["099720109477"]  
  # Specifies that the AMI must be owned by Canonical (official Ubuntu provider)
}

# Output block to display the fetched AMI ID
output "instance_id" {
  description = "AMI ID of the instance"  # Provides a description for the output
  value       = data.aws_ami.amiId.id  # Outputs the ID of the selected AMI
}

}

Breakdown:

Data Source Block (data "aws_ami" "amiId")
- Uses Terraform’s data block to query an existing AWS resource (AMI).
- Fetches the latest AMI that meets the specified filters.
- most_recent = true ensures the newest AMI is selected.
Filtering AMI by Name
- filter { name = "name" } applies a filter based on the AMI name.
- values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]:
  - Ensures that the AMI belongs to the Ubuntu 22.04 LTS (Jammy Jellyfish) Server series.
  - The * wildcard picks up all minor versions.
Filtering by Virtualization Type
- filter { name = "virtualization-type" } ensures that only HVM (Hardware Virtual Machine) AMIs are selected.
- values = ["hvm"]:
  - HVM provides full virtualization and is required for most modern AWS instance types.
Restricting to Official Ubuntu AMIs
- owners = ["099720109477"]:
  - Specifies that the AMI must be owned by Canonical (Ubuntu’s official publisher).
  - Prevents fetching AMIs from untrusted sources.
Output Block (output "instance_id")
- Outputs the selected AMI ID so it can be referenced elsewhere in the Terraform configuration.
- description = "AMI ID of the instance" provides a human-readable explanation.
- value = data.aws_ami.amiId.id:
  - Retrieves the id of the AMI selected from the data block.
  - Useful for provisioning EC2 instances with the latest Ubuntu AMI.

Running the Terraform Commands

Open your terminal in the same directory where the file is located and start typing the following commands:

terraform fmt
- It will check the format and fixes it if there is an issue.
- It will give a standard form.
terraform init
- This command reads all the .tf files in the current directory, checks the required resources, and downloads the necessary plugins from the Terraform registry.
terraform validate
- This command ensures that all the mentioned arguments and values are syntactically correct.
terraform plan
- This command creates an execution plan by comparing the current state with the desired configuration.
- It shows what changes Terraform will make without actually applying them.
- Helps in reviewing resource additions, modifications, or deletions before running terraform apply.
- Ensures there are no unexpected infrastructure changes.
terraform apply
- This command executes the planned changes to create, update, or delete resources as defined in the configuration.
- It prompts for confirmation before making any changes (unless -auto-approve is used).
- After successful execution, it provisions the infrastructure and displays the applied changes.
- Uses the Terraform state file to track managed resources.

Finally after apply is completed it prints out the output.

Conclusion

By following these steps, you can efficiently validate, plan, and apply your Terraform configurations to manage infrastructure. Ensuring proper validation and planning helps avoid unexpected changes and keeps your deployments smooth.

🚀 Stay tuned for my next post, where I'll cover launching an EC2 instance using Terraform!

DEV Community: Prajwal KP

Brew Your Own Compiler: Building LLVM/Clang from Source on Any OS!

General Build and Project Structure

Platform-Specific Notes

Management: Uninstallation and Upgrades

Linux/macOS

Windows

Checking Installation

Introduction to AWS CloudFormation: A Beginner's Guide to Infrastructure as Code

Introduction

What is AWS CloudFormation?

Why do we need CloudFormation?

Now lets look into some terminology

Now lets look into Templates.

Templates Formats

Now lets start an instance.

Now lets run the above template

In the next blog, we'll tackle Intrinsic Functions, Change Sets, and how to manage multiple resources using Mappings and Pseudo Parameters. Stay tuned there’s a lot more to uncover!

Automate Spotify Playlist Management Using Terraform: A Step-by-Step Guide

Introduction

Terraform Spotify Playlist Automation

Project Overview

Prerequisites

Steps to Complete the Project

1. Set Up Terraform Project

2. Store Credentials Securely

3. Define Spotify Provider

Breakdown

4. Start Spotify Authorization Proxy

5. Initialize and Apply Terraform Configuration

6. Verify Playlists on Spotify

Conclusion

Infrastructure as Code: Creating an AWS EC2 Instance with Terraform

Introduction

What Is Terraform?

Spinning Up an EC2 Instance with Terraform Magic

Let's Start Writing Some Terraform Code.

Step 1: Find instanceId to launch an instance

Breakdown:

Step 2: Create provider.tf

Step 3: Set Up a Key Pair and Security Group

Breaking Down the Security Group Configuration

Step 4:

Breaking Down the EC2 Instance Configuration

Conclusion

Getting Started with Terraform: Automating AWS Infrastructure

What Is Terraform?

How Does It Look?

Breakdown:

Setting Up AWS Access for Terraform

Breakdown:

Ok Let's Begin:

Now User Is Created So Lets Create The Access Key:

Configure AWS CLI:

Let's Start Writing Some Terraform Code.

Breakdown:

Running the Terraform Commands

Conclusion

Step 2: Create `provider.tf`