Forem: Zed

🚀 Automating Subdomains & Databases with AWS Route 53, FastAPI, and NGINX

Zed — Thu, 28 Aug 2025 17:37:47 +0000

Managing multi-tenant SaaS apps can get tricky.

Each tenant usually needs:

A unique subdomain
A dedicated database
A scalable backend to handle requests

Manually setting up subdomains and databases is painful. So… I automated it. 😎

In this guide, I’ll walk you through how I built an automatic subdomain + database provisioning system using:

AWS Route 53 → Manages subdomains
FastAPI → Handles tenant onboarding
MySQL → Stores tenant-specific data
NGINX → Routes traffic based on subdomain
Boto3 → Talks to AWS from Python

Let's dive in! 🏊‍♂️

🌐 Step 1 — Automate Subdomain Creation with Route 53

First, create a hosted zone in AWS Route 53 for your domain.

Install Boto3:

pip install boto3

Python Function to Create Subdomain:

import boto3

def create_subdomain(subdomain: str):
    route53 = boto3.client('route53', region_name='ap-south-1')
    hosted_zone_id = "ZXXXXXXXXXXX"  # Replace with your Hosted Zone ID
    domain_name = "example.com"

    response = route53.change_resource_record_sets(
        HostedZoneId=hosted_zone_id,
        ChangeBatch={
            "Changes": [
                {
                    "Action": "CREATE",
                    "ResourceRecordSet": {
                        "Name": f"{subdomain}.{domain_name}",
                        "Type": "A",
                        "TTL": 300,
                        "ResourceRecords": [{"Value": "YOUR_SERVER_PUBLIC_IP"}]
                    }
                }
            ]
        }
    )
    return response

This automatically registers a new subdomain inside Route 53.

🛢️ Step 2 — Create Tenant Databases Dynamically

Each tenant gets a separate MySQL database for better isolation.

import mysql.connector

def create_tenant_db(tenant_name: str):
    conn = mysql.connector.connect(
        host="localhost",
        user="root",
        password="your_password"
    )
    cursor = conn.cursor()
    cursor.execute(f"CREATE DATABASE IF NOT EXISTS {tenant_name}_db")
    conn.commit()
    conn.close()

⚡ Step 3 — FastAPI Endpoint for Tenant Signup

Whenever someone registers, we:

Create their database
Create their subdomain
Return their live URL 🚀

from fastapi import FastAPI

app = FastAPI()

@app.post("/register")
async def register_tenant(tenant: str):
    create_tenant_db(tenant)
    create_subdomain(tenant)
    return {"status": "success", "subdomain": f"{tenant}.example.com"}

🌍 Step 4 — Configure NGINX for Subdomains

We want all subdomains like client1.example.com or client2.example.com to hit the same backend, but serve different data.

Add this to your Nginx config:

server {
    listen 80;
    server_name ~^(?<subdomain>.+)\.example\.com$;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Then reload NGINX:

sudo nginx -t
sudo systemctl reload nginx

🏗️ Final Architecture

Signup → FastAPI → Route 53 → NGINX → Tenant DB → Tenant-Specific App

This gives you:

✅ Automatic subdomain creation
✅ Automatic database provisioning
✅ Scalable multi-tenant architecture

🎯 Conclusion

With AWS Route 53, FastAPI, MySQL, and NGINX, we built a SaaS-ready system that provisions subdomains and databases automatically.

This approach works great for multi-tenant apps, platforms, and SaaS dashboards — and saves hours of manual setup.

💡 Pro Tip: You can even take it further and integrate AWS ACM for automatic SSL certificates per subdomain.

What do you think? Would you like me to share a guide on auto SSL + HTTPS for all subdomains next? 🔐

Remote Access: A Complete Beginner-to-Advanced Guide

Zed — Sun, 10 Aug 2025 20:26:05 +0000

Remote access lets you control devices, transfer files, and manage servers without physically touching them. Whether you’re working from home, managing a personal server, or simply transferring files between devices, the tools and methods below cover secure, practical solutions for all platforms.

1. What is Remote Access?

Remote access is the ability to connect to another device over a network or the internet. Common uses include:

File transfer between devices
Remote server management
Collaborating with others on a shared machine
Monitoring systems without being on-site

2. Protocols & Tools Overview

Protocol	Purpose	Secure?	Common Tools
FTP	Transfer files	❌ No (unencrypted)	FileZilla, BusyBox FTP, Windows IIS FTP
SFTP	Transfer files over SSH	✅ Yes	OpenSSH, WinSCP, Cyberduck
SSH	Secure terminal access	✅ Yes	OpenSSH, PuTTY, Termius
RDP	Remote desktop access	✅ (with encryption)	Windows RDP, Remmina, AnyDesk
Mosh	Persistent shell access	✅ Yes	Mosh CLI
Rsync	Sync files efficiently	✅ Yes	rsync (Linux/macOS), cwRsync (Windows)

3. SSH (Secure Shell) – Universal Secure Remote Access

SSH is the most widely used method for remote server management.

It works on Linux, macOS, Windows (via PowerShell or PuTTY), and Android (via Termux).

On Linux/macOS:

ssh user@hostname_or_ip

Custom port:

ssh -p 8022 user@hostname_or_ip

On Windows:

Install PuTTY or use PowerShell:

ssh user@hostname_or_ip

Security Tip: Use public key authentication instead of passwords:

ssh-keygen -t rsa -b 2048
ssh-copy-id user@hostname_or_ip

4. SFTP – Secure File Transfer

SFTP uses the SSH protocol to encrypt file transfers.

Command line:

sftp user@hostname_or_ip
sftp -P 8022 user@hostname_or_ip  # custom port

Basic SFTP commands:

ls – list files
put file.txt – upload
get file.txt – download

GUI options:

WinSCP (Windows)
Cyberduck (Windows/macOS)
FileZilla (cross-platform)

5. Rsync – Sync Files Quickly

Rsync transfers only changes, making it faster for repeated syncs.

Example:

rsync -av /local/path/ user@remote:/remote/path/

Over SSH with custom port:

rsync -av -e "ssh -p 8022" /local/path/ user@remote:/remote/path/

6. Mosh – SSH for Unstable Connections

Mosh is great if you:

Move between Wi-Fi and mobile data
Have intermittent connectivity

Install on both ends:

mosh user@hostname_or_ip
mosh --ssh="ssh -p 8022" user@hostname_or_ip

7. RDP (Remote Desktop Protocol)

For full graphical desktop control.

Windows to Windows:

Built-in Remote Desktop Connection (mstsc)

Linux/macOS to Windows:

Use Remmina (Linux) or Microsoft Remote Desktop (macOS)

8. Using Termux as a Remote Server

If you want your Android device to act as a server:

Install Termux
Use openssh for SSH/SFTP
Default SSH port: 8022

pkg install openssh
sshd

Connect from PC:

ssh -p 8022 192.168.x.x

9. Security Best Practices

Disable password login once key-based authentication is set up.
Change default ports (e.g., 22 → 2222 or 8022).
Use strong passwords if keys aren’t possible.
Keep your SSH/SFTP/RDP software updated.
Avoid exposing your server directly to the internet — use a VPN if possible.

10. Quick Command Cheat Sheet

# SSH login
ssh user@host
ssh -p PORT user@host

# Generate SSH key
ssh-keygen -t rsa -b 2048

# Copy SSH key to server
ssh-copy-id -p PORT user@host

# SFTP file transfer
sftp user@host
put localfile
get remotefile

# Rsync sync folder
rsync -av /local/path/ user@host:/remote/path/

Final Thoughts

Remote access isn’t just for system administrators — it’s for anyone who wants seamless, secure control over their devices. Whether you’re syncing files from a laptop to a phone running Termux, managing a cloud server from your tablet, or helping a friend troubleshoot their computer remotely, mastering SSH, SFTP, and related tools will give you freedom and flexibility.

How to Deploy Your App with Docker on Render in 5 Minutes

Zed — Fri, 08 Aug 2025 18:08:01 +0000

If you’ve built a full stack app and want a super easy way to get it online, Render + Docker is a winning combo. In this quick guide, I’ll show you how I deployed my app using a Dockerfile on Render.com — with zero server config!

Prerequisites

A working app (Node.js, Python, etc.)
A Dockerfile in your project root
A GitHub repository
A free account on Render

Step 1: Create a Dockerfile

Here’s an example Dockerfile for a Node.js app:

# Use official Node image
FROM node:18

# Set working directory
WORKDIR /app

# Copy all files
COPY . .

# Install dependencies
RUN npm install

# Start the app
CMD ["npm", "start"]

# Expose port
EXPOSE 3000

For Python Flask, you might use:

FROM python:3.11
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
EXPOSE 5000

Make sure to customize the Dockerfile for your tech stack.

Step 2: Push Your Code to GitHub

If you haven’t already:

git init
git add .
git commit -m "initial commit"
git remote add origin <your-repo-url>
git push -u origin main

Step 3: Create a Web Service on Render

Go to https://render.com
Click New + → Web Service
Connect your GitHub repo
Render will auto-detect your Dockerfile
Set the following:
- Name: Anything you like
- Environment: Docker
- Build Command: Leave empty
- Start Command: Use from Dockerfile
- Port: 3000 (or 5000 for Flask)
Click Create Web Service

Render will start building your image and deploy it automatically.

Pro Tips

Use .env file locally and set the same Environment Variables in Render
Add a render.yaml file for Infrastructure as Code (optional)
Set up automatic deploys on every GitHub push
Monitor logs directly in the Render dashboard

Conclusion

Docker + Render makes it dead simple to go from local development to live deployment. No AWS console, no NGINX config — just push and deploy.

If you found this helpful, leave a like, share with your dev friends, or drop questions in the comments!

Creating a Console Game In Java

Zed — Sun, 04 Feb 2024 12:15:51 +0000

Hello everyone, I have been learning Java for a while, and I was thinking about making a project to practice programming. After giving it some thought, I decided to make a Java snake game that runs on consoles.

To create the game, I first had to figure out exactly where to move the cursor and print in the terminal. After some research, I found ANSI Escape Sequences, which are incredibly powerful and simple-to-use escape sequences that can manipulate your terminal with just a few lines of code. Basically, you can print "ESC[{x};{y}H" to move the cursor to a specific x, y position, and it will move there. There are many commands of this type, such as those that manipulate color, change the background and foreground colors, sound an alarm, clear the screen, etc. I've found a good list of commands created by fnky. You can see it here. (https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797)

I attempted to use a for loop to move the cursor to random locations after fiddling with the ANSI codes, as you can see here.

for (int i = 0; i<10; i++) {
   System.out.print("\e[i;iH");
}

The code above is merely an example; you can see that I am telling the terminal that the text that follows is an escape sequence by using the escape character "\e."

The next big task was figuring out the width and height of the terminal so that the game's boundaries and play area could be defined. This was actually a pretty challenging task because every operating system has a different way of figuring out the size of the terminal, like:
You may utilize tput in Linux:

tput lines # get number of lines (Height)
tput cols # get number of columns (Width)

and for PowerShell on Windows:

$Host.UI.RawUI.WindowSize.Width
$Host.UI.RawUI.WindowSize.Height

So, After researching, I've found multiple libraries, such as

And after doing some research, I ultimately decided on JLine because it was neither too complicated, which would help me learn new things, nor too simple, which would have prevented me from creating the main game logic. As a result of my decision, I now know how to create a terminal and obtain its height and width, essentially.

Terminal terminal = TerminalBuilder.builder().system(true).dumb(false).build());
System.out.println(terminal.getWidth());
System.out.println(terminal.getHeight());

Everything is enclosed in a try block in order to utilize all of Jline's features and prevent errors from occurring when a terminal is created that is not supported. To enable full functionality for cross-platform apps, it requires an additional library (https://github.com/jline/jline3?tab=readme-ov-file#jni-vs-jansi-vs-jna-vs-ffm-vs-exec), which may be jansi or jna.

After choosing and learning about JLine, I had to choose a build tool. Since I had never used Gradle before, I opted to use it so that I could become familiar with it. Next, I added JLine and Jna as dependencies.

Finally, after all of this, it was time to actually create the game. To do this, I started by creating a game class that will manage all of the main game mechanisms and an input handler that will handle user input. The input handler was created in a new thread because it required user input to be entered in a nonblocking manner, meaning that while the game class updates the screen, the input handler will continue to receive user input in order to move the snake.

I first created the bit class, which is the single bit of the snake, and the x and y coordinates of each bit are what will be used to print it. This is because the snake is composed of bits.

Syncing the movement of two printed pieces together posed an extremely significant challenge. In order to make it appear as though it was moving, I first tried printing a single bit. To do this, I printed it while increasing its x or y coordinates by one, then I printed it while printing space in its previous coordinates. To achieve this, I added prevX and prevY to the Bit class. Next, I added a second bit by matching the current x and y coordinates with the previous x and y of the first bits. In this way, I only updated the first bit, and everything will move in that direction.

In order to provide direction, I made an Enum Direction that will be mapped to the W A S D keys and contains the UP, DOWN, LEFT, and RIGHT directions.
Thus, the enum value will change to UP, and the snake will move upward when a user clicks the W key in this manner. I have therefore devised a clever mechanism to move the snake by simply adding and subtracting the x and y so that

UP: x--
Down: x++
Left: y--
Right: y++

The snake will move in that direction if the aforementioned operations are carried out on it in x and y coordinates, so I added a switch case and ran the loop to account for this.

In order to make the food appear, I made a new food class with x and y coordinates that were also randomly selected. This way, each time the snake eats the food, it will appear in a different location.

In order to determine when the snake is eating the food, I added checks to the snake class by observing the xy of the snake's initial bite and the xy of the food. The food will reappear at a random location if both are the same.

I also added a border check, noting that it was necessary in case the snake crossed it, so the game ends when the snake touches the border.

and also when it touched its body, but I decided to leave that feature in place since I thought it was cool that a snake could move in any direction even when it touched its body.

Thus, the main logic of the game was finally implemented. Colors and design were all that were lacking. After doing some research, I discovered that the jline ansi library or the ansi escape sequence can be used to implement colors. As a result, I chose to use the jline ansi library, and colors are now randomly selected from a color array. Additionally, I learned about ASCII art, or text-based art. After that, I came upon Ascii Art, a website that allows you to manipulate any text using ASCII art. I decided to use it to create my game's logo, Start Menu, Pause Menu, and Game Over Menu.

To make the snake appear like a rectangular box, I just colored a blank space a different color. For the food, I used various Unicode character sheet symbols, such as circles and zeros.Unicode Character Sheet

And so, I have finally finished the game after much modification and refactoring of all the functions in various classes.
So you can see the game's code in my Github page
Repo:- https://github.com/zedai00/snakez

This was my experience making the snake game, and although I apologize for not going into too much detail, I will do so in the comments section if you have any. Thanks.