Benefits of Separating the Database and Other Services from the Web Application

António Macave — Fri, 10 Jan 2025 16:28:24 +0000

Separating critical components, such as the database, queue services (e.g., RabbitMQ, Apache Kafka), and cache services (e.g., Redis), into physically distinct servers is a practice that offers several advantages, particularly in performance, scalability, and security. This practice also aligns with the 4th principle (Backing Services) of the 12-Factor App https://12factor.net/backing-services, which emphasizes the separation of responsibilities and the construction of applications with independent services.

Performance
Separating these components eliminates resource contention within the same machine. By dedicating specific servers to each service, resources like CPU, RAM, and storage are optimized for the exclusive use of one service. For example, we know that the database consumes significant CPU and memory resources, so allocating more resources to it can be an efficient strategy.

Security
This approach creates an additional layer of security, aligned with the Defense in Depth strategy. When all services are on the same server, exploiting a vulnerability in one service can affect others, leading to cross-contamination risks. The physical separation of services provides isolation, limiting the impact of a potential security breach.

Scalability
Scalability is one of the main advantages of this practice. By separating services, each can be scaled independently without affecting the others. For example, if the web application experiences a traffic surge, we can add more memory and CPU to the application server without impacting other services, such as the database.

This approach also aligns with the 4th principle of the 12-Factor App, which advocates for the separation of responsibilities between different components of the application. By adopting this practice, we ensure a more flexible and resilient architecture, allowing services to be scaled and managed independently, which is essential to face the challenges of modern applications.

How to generate a random password in Java

António Macave — Tue, 15 Aug 2023 18:55:44 +0000

Hi folks!
I hope you all are fine! Today, I want to show you how to generate a random password.
First of all, we need to create the class and define the valid characters for our password.

Well, lets consider characters 0 to 9, A to Z, capital and lower cases.
We can call the class PasswordGenerator.

public class PasswordGenerator {
    public static void main(String[] args) {
        String validChars = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
        char[] chars = validChars.split(",");
    }
}

Now, lets create the method that will generate the password. And this, is going to return a String. And we can call it with an int parameter, and lets call it length.
This method will look like this:

public static String generatePassword(int length) {
 //code here
}

Now, inside this method, lets write the real code that generates it for us!

public static String generatePassword(int passLength) {

        //Setting the valid charaters for the generated password
        String validChars = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";

        //Creating an array by splitting the above String by the comma
        String[] chars = validChars.split(",");

        //Create the String that will store each charater that will be chosen
        StringBuilder password = new StringBuilder();

        //This object will be the random that will "bounce" between the chars array.
        //Don't forget to import the Random class from util package (java.util.Random).
        Random r = new Random();

        //This loop will make the Random object (r) bounce between the array many times
        //The quantity of times is called "passLength"
        for (int i = 0; i < passLength; i++){
            password.append(chars[r.nextInt(chars.length)]);
        }

        return password.toString();
}

And now, we have to call this method inside the main method. Lets do it.

public static void main(String[] args) {
        //In this example, we generate a 20 lengthened password
        //But you can set the length you want
        System.out.println(generatePassword(20));

    }

Well, heres is the full code:

import java.util.Random;


public class PasswordGenerator {

    public static void main(String[] args) {
        //In this example, we generate a 20 lengthened password
        //But you can set the length you want
        System.out.println(generatePassword(20));

    }

    public static String generatePassword(int length) {

        String validChars = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
        String[] chars = validChars.split(",");

        StringBuilder password = new StringBuilder();

        Random r = new Random();

        for (int i = 0; i < length; i++){
            password.append(chars[r.nextInt(chars.length)]);
        }

        return password.toString();
    }


}

Lets compile the code.

Great! No errors!

Lets execute.

Lets execute again!

You see? Different results!

We did it!

DEV Community: António Macave

Benefits of Separating the Database and Other Services from the Web Application

How to generate a random password in Java