DEV Community: ShivangDholaria

CI/CD in Action: Deploying an Application from Code to Cloud

ShivangDholaria — Fri, 07 Mar 2025 20:00:57 +0000

Hey all, In this post, I will be sharing a complete guide to CI-CD. This will be a multi-part series where I will talk through testing and deploying applications locally to all the way on the cloud.

Stay tuned for this! I am linking all the parts down below:

Deploying a Spring Boot Application on AWS: A Complete Guide

ShivangDholaria — Fri, 07 Mar 2025 20:00:05 +0000

Now that our application is running perfectly in the local environment, lets move it to the cloud. My preferred choice for cloud provider is AWS since its widely used and provides with 12-month of free usage.

Setting the cloud Infrastructure

I am assuming that you will an account in AWS and logged into it. If not, then it is really easy to setup the account. And yes, if you are creating an account for the first time, you will be needing a credit/debit card since it will use it for verification purposes. You will see a small amount debited, which will be refunded the next day once the account creation is successful.

Now that you are logged into your AWS account, we will be going to our server which will host our application. Creating it is simple, just navigate to EC2 from search bar.

Open it and click on launch instance, You will see this.

Given any name you want to your server.

Select Ubuntu from Application and OS images and keep the default as is.

Keep the instance type as t2.micro as it is free tier eligible.

For key-pair, if you already have one, select that. If not click create new pair and create one by keeping the defaults as is.

Keep the network settings default too. Make sure that Allow SSH traffic from is enabled and Anywhere is selected.

Now click on launch instance to create your server. You will see this once the creation is successful.

Once created, wait till you see your status check as 2/2 checks passed. This confirms that the server is now fully up and running.

Now lets log into the server and deploy our applicatio. Click on the server and then click on connect.

You will see any options. Do the following if you are:

a Windows user, setting the permission on the key is a tricky process, so we will use the EC2 Instance Connect option.

a Linux/Mac user, open the SSH client option and follow through the steps.

Once connected, you should be able to see this.

Run sudo apt update command to update the packages for the server.

Before cloning your repo, you will first need to install java. We wont be installing maven as the repo has a mvnw executable, which a maven wrapper. Install java using the following command:

sudo apt install openjdk-21-jre-headless -y
sudo apt install openjdk-21-jdk-headless -y

Once installed, clone the repo and cd into it. Make the mvnw executable by using the following:

sudo chmod +x mvnw

One more step and we are done, just enter the API key in the application.properties file and save it. Now just enter the command to run the application.

./mvnw spring-boot:run

Once you run that command, you will see successful execution. You will be thinking now if I open the browser and type localhost:<PORT>, I should be able to see the application running. Well, the short answer is no since you are running a different machine.

To access it, you need to enter the server's public IP followed by the port number to access it. Type the public IP address (which you can find at the homepage on Instance), followed by the port number in the browser. You still won't see the application since by default our server blocks any incoming connection to it on that port. To allow them, we need to edit its network rules.

This can be done by editing the security group of the instance. You can find the security group of the instance in its security tab. For me it is launch-wizard-4.

Open the security group and then click on edit inbound rules.

Click on add rule, keep the type as Custom TCP, Port range as your port number (I have kept mine as 8001 since thats the port which my application uses), Source as Anywhere and click on search bar next to it and select the CIDR range as 0.0.0.0/0 and Save rules

Once you are done, you should see the added rule, and now your app should be opening.

In part 3 we will be discussing the automation process.

Deploying Locally: A Developer’s Guide Before CI/CD

ShivangDholaria — Mon, 03 Mar 2025 21:16:13 +0000

This is the first part of a series where I'll guide you through deploying an app locally before moving to the cloud.

The assumption is that you already have an app built and are ready for deployment. I'll be skipping the testing phase as the app for this demonstration is simple enough not to require extensive testing.

The Project Set-up

Before we begin, ensure you have:

Java installed on windows, MacOS, Linux
Maven set up

For this tutorial, I've created a simple Weather App. You can fork the repository from here. It is a really super simple application.

Important Note: After cloning the repo, you'll need to add your API key from OpenWeather as the application requires it. Once you have your API key, add it to the application.properties file, which is located inside the src/main/resources directory, where the api.key field is located. The API is free; you don't have to pay for anything.

Open your preferred IDE (I'm using VS Code) and load the application. Your project structure should look something like this:

Also update the api.key value with your OpenWeather API key.

Once done, open the integrated terminal and run the mvn spring-boot:run command and see if the application runs perfectly. It should run perfectly; if not, write in the comment what went wrong, and I will try to help you out. You should see the following output once the execution starts.

I am using port 8001 for this project, but if the port is occupied by another process, you can change it and update the server.port value in the application.properties file.

Open up a browser and enter the URL localhost:<YOUR PORT NUMBER> in this case localhost:8001 and you will have the app running.

Enter any city that you want to check the weather in, and it will show you.

What's Next?

Now that we have the application working locally, it's time to deploy it to the cloud.

Continue to Part 2 for the cloud deployment guide.

EventLoop vs. ThreadPool: Which One Should You Use and When?

ShivangDholaria — Wed, 26 Feb 2025 01:51:01 +0000

Ever wondered how apps handle multiple tasks at once? That’s where ThreadPools and EventLoops come in. One uses multiple threads to juggle tasks, while the other relies on an async, non-blocking approach. But which one should you use?

In this post, we’ll break down ThreadPools vs. EventLoops, how they work, and when to pick one over the other—without the boring theory. Let’s dive in!

ThreadPool

Simply put, it is a collection of worker threads that are already present, and when a task comes, it is assigned to an available thread. Once the task finishes, the thread is released and made available for other tasks.

Pros

Good for parallelizable tasks
Reduces overhead for creating and destroying new thread for each task

Cons

Less efficient for I/O bound as once the pool gets exhausted, the incoming processes need to wait until a thread is available
Can lead to deadlocks and race conditions if proper synchronization methods are not implemented

EventLoop

It is a single-thread mechanism that executes asynchronous processes one at a time. To explain asynchronous processes, they are the processes that execute later in time rather than immediately.

For example, when you open a stock market app, it fetches data from multiple sources. Since all the data can’t load instantly, the app displays it as it arrives. That’s why stock prices appear one by one—this is an asynchronous process.

Pros

Less overhead since it runs on a single thread
Good for I/O-bound operations such as network requests, database queries, file I/O, etc

Cons

Not efficient for CPU-intensive tasks since it will consume a lot of time for execution
Helps achieve concurrency

So if you want to execute multiple tasks at once, ThreadPool is to-go.

And want to achieve data consistency? EventLoop is there for you!

That's it, folks! Let me know in the comment if you found this easy to understand!

Bash Scripting for Git: How to Fetch All Repo Collaborators Effortlessly

ShivangDholaria — Fri, 21 Feb 2025 17:56:05 +0000

I am excited to share my first post over here at Dev.to. As the post says, I will be discussing the script that will give the user list of all the collaborators that are currently working on a git repo. It might seem silly since users can check them directly via the Github UI, but what if you are working in a CLI environment?

Introduction

As a team manager or leader, you will be responsible for onboarding new hires, managing the workflow of the application, and many more. As the team grows or shrinks, you are the one who needs to keep strict access to the organization's repository. It would be a hassle to go to the Github UI and get the list of all the users who are working on the repo and add or revoke the access. So what I would be showing you is a simple script that would get you the list of all the users who are added as collaborators on the repo.

Prerequisites

First of all, you need to have git installed in your system. If you dont have it installed, you can install it via this link.

Once downloaded, you will need to configure it. You can find more on how to configure it here.

TL;DR for configuration - Use the command git config --global user.name "Your github login username" to add your username to the tool and git config --global user.name "Your github login email" to add your associated email.
Once done, run the script to get all the collaborators.

Also have jq installed since the response when using the Github API will be in JSON, jq will help us parse it. Installing it is simple; just run sudo apt install jq on Linux or brew install jq on Mac. For windows,
Open the PowerShell terminal and run this command choco install jq.

After all is installed, you need to create and set 2 environment variables named username and token which will be needed when we run our script. The username variable will contain your Github username used for logging into the account and token is the account token used for accessing. You can create the token by following this article.

Make sure NOT TO EXPOSE THE TOKEN because anyone with that token can use your account, so play safe.

Script Rundown

Here's the scipt that will give is the list of all the collaborators for a given repo.

#!/bin/bash

# Function to display usage information
function show_help {
    echo "Usage: $0 <repo_owner> <repo_name>"
    echo "Example: $0 octocat hello-world"
    echo "Lists all users with read access to the specified GitHub repository."
    echo "Requires GitHub personal access token to be set in environment variable 'token'"
    exit 1
}

# Show help if no arguments provided
[ $# -ne 2 ] && show_help

# GitHub API URL
API_URL="https://api.github.com"

# GitHub username and personal access token
USERNAME=$username
TOKEN=$token

# User and Repository information
REPO_OWNER=$1
REPO_NAME=$2

# Function to make a GET request to the GitHub API
function github_api_get {
    local endpoint="$1"
    local url="${API_URL}/${endpoint}"

    # Send a GET request to the GitHub API with authentication
    curl -s -u "${USERNAME}:${TOKEN}" "$url"
}

# Function to list users with read access to the repository
function list_users_with_read_access {
    local endpoint="repos/${REPO_OWNER}/${REPO_NAME}/collaborators"

    # Fetch the list of collaborators on the repository
    collaborators="$(github_api_get "$endpoint" | jq -r '.[] | select(.permissions.pull == true) | .login')"

    # Display the list of collaborators with read access
    if [[ -z "$collaborators" ]]; then
        echo "No users with read access found for ${REPO_OWNER}/${REPO_NAME}."
    else
        echo "Users with read access to ${REPO_OWNER}/${REPO_NAME}:"
        echo "$collaborators"
    fi
}

# Main script

echo "Listing users with read access to ${REPO_OWNER}/${REPO_NAME}..."
list_users_with_read_access

Lets go through the script.

Firstly, it's just a basic setup which will display the usage of script.
Moving on, We see that the script will need 2 arguments, namely the repo owner and repo name. This is how a repo looks like https://github.com/username/repo-name, pass those 2 as the parameters.
The 2 functions are where magic happens. The function github_api_get is where we build the GET request using the Github API and list_users_with_read_access is where we get the list of all the users who have access to the repo.

Please keep this in mind when using this script; you yourself must have the permission to access the repo otherwise, you won't be able to get other users.