DEV Community: Akashdeep

Load Balancer Algorithms

Akashdeep — Tue, 21 Jan 2025 08:58:03 +0000

Introduction: What is a Load Balancer?

In the realm of distributed systems, a load balancer acts as a traffic manager that distributes network or application traffic across multiple servers. Its primary goal is to ensure no single server bears an excessive load while optimizing resource utilization, minimizing response times, and maintaining system reliability.

The Problem Without a Load Balancer and a Single Server Setup

A system with only one server is a single point of failure. If this server becomes overwhelmed or crashes, the entire application goes offline. Additionally, such setups struggle to handle increasing traffic, leading to slower response times and reduced user satisfaction.

The Problem with Horizontal Scaling Without a Load Balancer

Horizontal scaling involves adding more servers to handle increasing traffic. However, without a load balancer, there is no mechanism to efficiently distribute requests among servers. This can lead to uneven loads, with some servers becoming overutilized while others remain underutilized. Consequently, the system cannot take full advantage of the additional servers.

Why Are Health Checks Important?

Health checks ensure the load balancer routes traffic only to healthy and responsive servers. By regularly monitoring server status, health checks prevent traffic from being sent to failed or underperforming servers, thereby improving reliability and user experience.

Load Balancer Algorithms

Load balancers use algorithms to decide how to distribute traffic among servers. These algorithms fall into two main categories: static and dynamic.

Static Algorithms

Static algorithms use predefined rules for traffic distribution. They are simple and fast but lack adaptability to changing server conditions.

Characteristics of Static Algorithms:

Predefined Rules: Traffic distribution follows fixed patterns or rules.

Simple and Fast: Minimal computational overhead makes them efficient.

Not Adaptive: They do not consider real-time server health or load.

Examples of Static Algorithms:

Round Robin: Requests are distributed sequentially to each server in the pool. Once the last server is reached, the algorithm loops back to the first.

IP Hashing: The client’s IP address is hashed to determine the server for routing, ensuring consistent server assignments for returning clients.

URL Hashing: Requests are routed based on a hash of the requested URL, which is useful for caching and content distribution.

Dynamic Algorithms

Dynamic algorithms make decisions based on real-time metrics like server health, load, and response time. They are more accurate but require continuous monitoring.

Characteristics of Dynamic Algorithms:

Real-Time Metrics: Decisions are informed by live server data.

Accurate: Better distribution leads to optimized performance.

Requires Monitoring: Relies on constant feedback from servers, increasing complexity.

Examples of Dynamic Algorithms:

Least Connections: Routes traffic to the server with the fewest active connections. This is ideal for long-lived connections.

Least Response Time: Routes traffic to the server with the quickest response time, ensuring faster user experiences.

Big O Complexity for Graphs: Adjacency Matrix vs Adjacency List

Akashdeep — Tue, 14 Jan 2025 17:56:58 +0000

Graphs can be represented in two main ways: Adjacency Matrix and Adjacency List. Each method has its own pros and cons depending on how much memory it needs and how quickly it can handle different operations.

1. Space Complexity

Adjacency Matrix : O(V^2)
Adjacency List : O(V+E)

V: Number of vertices.
E: Number of edges.
Adjacency Matrix requires a V×V grid, making it less efficient for sparse graphs.
Adjacency List only stores edges for each vertex, making it space-efficient for sparse graphs.

2. Time Complexity: Adding a Vertex

Adjacency Matrix : O(V^2)
Adjacency List : O(1)

Adjacency Matrix: Adding a vertex may require creating a new 𝑉+1×𝑉+1 matrix and copying the old matrix, which is expensive.
Adjacency List: Simply add a new empty list for the new vertex, which is constant time.

3. Time Complexity: Adding an Edge

Adjacency Matrix : O(1)
Adjacency List : O(1)

Both representations allow constant-time edge additions:

Matrix: Set the matrix cell to 1 (or edge weight).
List: Append the edge to the list.

4. Time Complexity: Removing an Edge

Adjacency Matrix : O(1)
Adjacency List : O(E/V)

Adjacency Matrix: Directly unset the cell, which is constant time.
Adjacency List: Requires searching through the list for the edge, leading to O(E/V) time on average.

5. Time Complexity: Removing a Vertex

Adjacency Matrix : O(V^2)
Adjacency List : O(V+E)

Adjacency Matrix: Removing a vertex involves deleting its row and column, which can require shifting elements in the matrix.
Adjacency List: Removing a vertex requires deleting the list for the vertex and traversing all other lists to remove edges to the vertex.

Choosing the Right Representation

Adjacency Matrix:
Suitable for dense graphs where E≈V2.
Offers constant-time edge operations but consumes more space.
Adjacency List:
Ideal for sparse graphs where E≪V2.
Space-efficient and generally faster for operations involving vertices.

Hosting a Custom Login and Registration UI with AWS Amplify and AWS Cognito

Akashdeep — Tue, 13 Aug 2024 10:34:03 +0000

Walk through the steps to adopt a custom login and registration user interface (UI) using AWS Amplify and AWS Cognito. AWS Amplify is a powerful tool that provides simplified framework for developing and running cloud-powered applications, while AWS Cognito provides secure authentication with user management. By the end of this guide, you will have a custom login and registration UI implemented and connected to AWS Cognito for user authentication.

Step-by-Step Guide

Begin by installing the AWS Amplify CLI globally on your system. This will enable you to interact with Amplify services from the command line.

npm install -g @aws-amplify/cli

Configure AWS Amplify

Set up the Amplify CLI with your AWS credentials. Follow the prompts to configure your AWS account.

amplify configure

Initialize Amplify in Your Project

Initialize an Amplify project in your React application.

amplify init

Add Authentication with AWS Cognito

Add authentication to your Amplify project using AWS Cognito.

amplify add auth

Deploy Changes

Push your changes to the cloud. This will configure AWS Cognito and other backend resources.

amplify push

Install Required Packages

Install AWS Amplify and the Amplify UI components for React.

npm install aws-amplify @aws-amplify/ui-react

Start Your React Application

Run your React application locally.

npm start

Initialize a Git Repository

Initialize a Git repository.

git init

Commit Your Changes

Stage and commit your changes with an initial commit message.

git add .
git commit -m "Initial commit"

Set Up Git Branch

git branch -M main

Connect to Remote Repository

Add a remote repository URL to your Git configuration.

git remote add origin <repository URL>

Push Changes to Remote Repository

Push your commits to the remote repository.

git push -u origin main

Access AWS Amplify Console

Log in to the AWS Management Console.
Navigate to the AWS Amplify Console.

Connect Your Repository

In the Amplify Console, click on "Get Started" under the "Deploy" section.
Choose your repository provider (e.g., GitHub, GitLab, Bitbucket, AWS CodeCommit).
Authenticate and authorize AWS Amplify to access your repository.

Configure the Build Settings

Choose the repository you want to connect.
Select the branch you want to deploy (usually master).

Save and Deploy

Click "Save and Deploy". AWS Amplify will start the deployment process, building and deploying your application based on the configuration provided.

Conclusion

By integrating AWS Amplify with your CI/CD pipeline, you automate the process of building, testing, and deploying your React application. This setup streamlines your development workflow and ensures that changes are quickly and reliably reflected in your live environment.

If you need further customization or have specific requirements, refer the AWS Amplify documentation for more detailed information on advanced CI/CD configurations and best practices.

Diagram showing the CI/CD workflow.

Understanding JPA Mappings in Spring Boot: One-to-One, One-to-Many, Many-to-One, and Many-to-Many Relationships

Akashdeep — Tue, 13 Aug 2024 07:43:10 +0000

When building applications with Spring Boot and JPA (Java Persistence API), managing relationships between entities is crucial. Understanding how to map these relationships effectively will help you model your data accurately and perform efficient queries. In this guide, we'll explore the different types of JPA mappings supported by Spring Boot: one-to-one, one-to-many, many-to-one, and many-to-many. Will provide example on both unidirectional and bidirectional mappings.

One-to-One Relationship

Unidirectional One-to-One

In a unidirectional one-to-one relationship, one entity references another without the second entity knowing about the first.

Example:

// User.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String username;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "fk_profile_id", referencedColumnName = "id")
    private Profile profile;

}

// Profile.java
import javax.persistence.Entity;
import javax.persistence.Id;

@Data
@Entity
public class Profile {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String bio;
}

Bidirectional One-to-One

In a bidirectional one-to-one relationship, both entities reference to each other.

Example:

// User.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String username;

    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private Profile profile;

}

// Profile.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.JoinColumn;

@Data
@Entity
public class Profile {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String bio;

    @OneToOne
    @JoinColumn(name = "user_id")
    private User user;
}

One-to-Many Relationship

Unidirectional One-to-Many

In a unidirectional one-to-many relationship, one entity references a collection of another entity.

Example:

// Author.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.List;

@Entity
@Data
public class Author {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "fk_book_id", referencedColumnName = "id")
    private List<Book> books;
}

// Book.java
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
@Data
public class Book {
    @Id
    private Long id;
    private String title;
}

Bidirectional One-to-Many

In a bidirectional one-to-many relationship, both entities are referenced to each other.

Example:

// Author.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.CascadeType;
import javax.persistence.FetchType;
import java.util.List;

@Entity
@Data
public class Author {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private List<Book> books;

}

// Book.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
@Data
public class Book {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String title;

    @ManyToOne(name = "fk_author_id", referencedColumnName = "id")
    private Author author;
}

Many-to-One Relationship

Unidirectional Many-to-One

In a unidirectional many-to-one relationship, multiple entities reference a single entity.

Example:

// Order.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
@Data
public class Order {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String description;

    @ManyToOne
    private Customer customer;

}

// Customer.java
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
@Data
public class Customer {

    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

}

Bidirectional Many-to-One

In a bidirectional many-to-one relationship, the referenced entity has a collection of the referring entities.

Example:

// Order.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
@Data
public class Order {

    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String description;

    @ManyToOne
    private Customer customer;

}

// Customer.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.List;

@Entity
@Data
public class Customer {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "customer")
    private List<Order> orders;

}

Many-to-Many Relationship

Unidirectional Many-to-Many

In a unidirectional many-to-many relationship, each entity has a collection of the other, but the relationship is not explicitly managed by either side.

Example:

// Student.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Student {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @ManyToMany
    private Set<Course> courses;

}

// Course.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Course {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String title;

    @ManyToMany
    private Set<Student> students;
}

Bidirectional Many-to-Many

In a bidirectional many-to-many relationship, both entities are referencing each other, and the relationship is explicitly managed.

Example:

// Student.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Student {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @ManyToMany(mappedBy = "students")
    private Set<Course> courses;
}

// Course.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Course {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String title;

    @ManyToMany
    private Set<Student> students;
}