Building Dynamic Subdomain Routing for User Signups in Your SaaS Product

sai parisheth — Sat, 14 Sep 2024 04:42:38 +0000

Recently, I had the opportunity to help a friend set up dynamic subdomain routing for his SaaS product. He already had a functioning frontend in Angular, a backend built on Node.js, and a MongoDB database. However, his goal was to enhance the user experience by assigning a unique subdomain to each user upon signup.

The existing resources were:

A domain registered with GoDaddy.
An AWS account with access to key services such as Route 53, CloudFront, EC2, and S3.
The Plan
The primary requirement was to configure dynamic subdomain routing, where each new user would receive their own subdomain, e.g., user1.example.com. This involved configuring AWS services, primarily Route 53 for DNS management, CloudFront for content distribution, and S3 for hosting the static Angular frontend.

Step 1: Setting up the Frontend
The Angular frontend was hosted on an S3 bucket, which was configured as a static website. We then used CloudFront as the content delivery network (CDN) to distribute the static assets globally.

To handle dynamic subdomains, we added a wildcard domain (*.example.com) to the CloudFront distribution. This wildcard ensures that any subdomain requests (such as user1.example.com, user2.example.com, etc.) would point to the same CloudFront distribution, allowing us to serve the same frontend while handling the unique subdomains at the DNS level.

Step 2: Configuring Route 53 for Subdomain Traffic
Next, we set up Route 53 to manage DNS records for the domain. The key here was the ability to dynamically create A or CNAME records for each user’s subdomain. For example, when a new user signs up, we programmatically added a new record such as user1.example.com pointing to the CloudFront distribution.

Each new subdomain required a corresponding DNS entry in Route 53, which would route the traffic to CloudFront. The wildcard configuration in CloudFront allowed any subdomain created in Route 53 to automatically route traffic to the frontend.

Step 3: Automating DNS Record Creation on Signup
The real challenge came with automating the creation of subdomains in Route 53 for each user. To achieve this, we integrated AWS SDK into the backend (Node.js) to programmatically create DNS records. Here’s how we approached it:

AWS Credentials: We generated an Access Key ID and Secret Access Key from AWS IAM with appropriate permissions to modify Route 53 records. These keys were securely stored in our backend system.
Automating Route 53 Updates: On every user signup, the backend would generate a unique subdomain for the user, e.g., user1.example.com. Using the AWS SDK, the backend automatically added a new DNS record in Route 53, pointing the subdomain to the CloudFront distribution. This automation eliminated manual DNS configuration, making the process scalable.
Backend Logic: The backend code handled the generation of subdomain names and ensured that they were unique. It then communicated with AWS to create the necessary DNS records in Route 53, using the secret keys we had configured.
Additional Insights
Scalability: This architecture ensures scalability. With the dynamic subdomain routing, the system could handle thousands of users, each with their own subdomain, without the need for manual DNS management. The integration of Route 53 and CloudFront provides a seamless flow of traffic and ensures optimal performance for users across different geographical regions.
Security: Using IAM roles with the least privilege principle ensured that the backend only had access to Route 53 for creating DNS records, limiting potential security risks.
Performance Optimization: The use of CloudFront with a globally distributed edge network significantly reduced latency and improved the overall performance of the application, providing a fast experience for users regardless of their location.
This project was a valuable learning experience, particularly in how to leverage AWS services like Route 53 and CloudFront for dynamic DNS management. It not only streamlined the user signup process but also ensured scalability and performance for the SaaS product as it continues to grow.

Best RPA tips and tricks

sai parisheth — Sat, 01 Jun 2024 07:14:31 +0000

I’ve had the pleasure of working on Python RPA scripts, focusing on automation and data extraction from both modern and legacy web applications.

Two key takeaways were that automating and extracting data from modern web applications is relatively straightforward, but working with older, more complex applications presented some unique challenges.

Driver.cookies() this function helps to take the current cookies of the tab and we can reuse the same cookies to hit the api endpoint (which contains the data we need). By this we can reduce the automation process and scrap the data faster and effectively.

def get_hash_value(customer_id,document_id):
    cookies = driver.get_cookies()
    cookie_string=""
    #this loop sets the necessary cookies
    for cookie in cookies:
        cookie_string+=cookie['name']+'='+cookie['value']+'; '
    headers = {
        'authority': 'www.example.com',
        'accept': 'application/json, text/javascript, */*; q=0.01',
        'accept-language': 'en-US,en;q=0.9',
        'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
        'cookie': cookie_string,
        'origin': 'https://qa.devfovea.com',
        'referer': 'https://www.example.com/secret',
        'sec-ch-ua': '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"',
        'sec-fetch-dest': 'empty',
        'sec-fetch-mode': 'cors',
        'sec-fetch-site': 'same-origin',
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
        'x-requested-with': 'XMLHttpRequest',
    }
    data = {
    'querystring': f'CustId={customer_id}&DocumentId={document_id}',
    }
    url = 'https://www.example.com/GetHashedValue'
    response = requests.post(url, headers=headers, data=data)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Request failed with status code {response.status_code}")

2.To Extract specific datas from a table, You can find the particular table element. And iterate the the table through values

from selenium import webdriver
from selenium.webdriver.common.by import By

# Initialize the WebDriver
driver = webdriver.Chrome()  # Ensure chromedriver is in your PATH

# Navigate to the webpage
url = 'https://example.com/page-with-table'  # Replace with the target URL
driver.get(url)

# Locate the table by its ID
table = driver.find_element(By.ID, 'example-table')  # Replace with the actual ID of the table

# Extract table rows
rows = table.find_elements(By.TAG_NAME, 'tr')

# Initialize a list to store table data
table_data = []

# Loop through each row and extract cell data
for row in rows:
    # Extract cell data from each row
    cells = row.find_elements(By.TAG_NAME, 'td')
    cell_data = [cell.text for cell in cells]
    table_data.append(cell_data)

# Print the extracted data
for row in table_data:
    print(row)

# Close the WebDriver
driver.quit()

3.The last one but useful one. Whenever I get stuck in writing scripts for an old and shabby websites I use selenium webdriver extension and record the actions and clicks and export to python script. You can find the selenium webdriver extension in chrome webstore.

DEV Community: sai parisheth

Building Dynamic Subdomain Routing for User Signups in Your SaaS Product

Best RPA tips and tricks