DEV Community: Sai Shanmukkha Surapaneni

Part 1: Mastering Dynamic Programming — 5 Steps to Solve It (Longest Increasing Subsequence Using Tabulation / Bottom-Up)

Sai Shanmukkha Surapaneni — Sat, 15 Nov 2025 19:06:40 +0000

Dynamic Programming (DP) has a reputation for being one of the trickiest topics in algorithms. Many learners struggle not because DP is inherently complex, but because they lack a structured approach to reasoning about problems. In this blog, we’ll break DP down into five simple steps that you can apply to most problems.

To make things concrete, we’ll use the Longest Increasing Subsequence (LIS) problem as our running example.

## 🧠 5-Step Framework to Solve DP Problems

### 1. Visualize Examples (Think in Terms of a DAG)

Almost all DP problems can be imagined as paths in a Directed Acyclic Graph (DAG). Each state represents a choice, and edges represent transitions to future states.

Let’s take our example array:

arr = [3, 1, 8, 2, 5]

Try to imagine all sequences that can be formed by picking numbers in increasing order.
Visualizing a few example sequences helps greatly:

Starting at 3 → [3, 8] or [3, 5]
Starting at 1 → [1, 8], [1, 2, 5]
Starting at 8 → [8]
etc.

Each number can go to any number greater than it that appears later in the list — this is your DAG.

### 2. Find an Appropriate Subproblem

A good DP solution boils down to defining the right subproblem.

For LIS, a natural subproblem is:

What is the longest increasing subsequence starting at index i?

Or more commonly:

What is the LIS ending at index i?

Let’s define:

dp[i] = length of the longest increasing subsequence ending at index i

### 3. Find Relationships Among Subproblems

Now that we have dp[i], how do we compute it?

For each index i, look at all previous indices j < i:

If arr[j] < arr[i], then we can extend the subsequence ending at j.

This gives:

dp[i] = 1 + max(dp[j]) over all j < i where arr[j] < arr[i]

If no such j exists, then dp[i] = 1 (the element itself).

### 4. Generalize the Relationship

Combining everything:

dp[i] = 1 + max(dp[j] for all valid j)
otherwise dp[i] = 1

This is our recurrence relation.

The final LIS answer is:

max(dp[i] for all i)

### 5. Implement by Solving Subproblems in Order

We fill the dp array from left to right, ensuring all dp[j] values needed for dp[i] have already been computed.

Here’s a full implementation:

def LIS(arr):
    n = len(arr)
    dp = [1] * n  # Every element is a subsequence of length 1

    for i in range(1, n):
        for j in range(i):
            if arr[j] < arr[i]:
                dp[i] = max(dp[i], dp[j] + 1)

    return max(dp)

Testing it:

arr = [3, 1, 8, 2, 5]
print(LIS(arr))  # Output: 3  (The subsequence is [1, 2, 5])

Nice, let’s zoom all the way in on this array and see exactly what’s happening:

arr = [3, 1, 8, 2, 5]

Let's go step-by-step:

0. What does `dp[i]` mean?

dp[i] = length of the Longest Increasing Subsequence that ends exactly at index i

So for each position i, we assume arr[i] is the last element of the subsequence.

Step-by-step for `[3, 1, 8, 2, 5]`

Indexing:
i = 0 1 2 3 4
arr = [3, 1, 8, 2, 5]

Initial state

dp = [1, 1, 1, 1, 1]

Why all 1’s?
Because every single element alone is a subsequence of length 1.

i = 0 → element = 3

For i = 0, the loops don’t run (no j < 0), so:

dp[0] stays 1 → subsequence [3]

Current:

dp = [1, 1, 1, 1, 1]

i = 1 → element = 1

We look at all j < 1 → only j = 0.

j = 0 → compare arr[0] < arr[1] → 3 < 1? ❌ No.

So there is no previous smaller element that can come before 1 in an increasing subsequence.

dp[1] stays 1 → subsequence [1]

Current:

dp = [1, 1, 1, 1, 1]

Subproblems so far:

LIS ending at index 0 is 1 ([3])
LIS ending at index 1 is 1 ([1])

i = 2 → element = 8

We look at all j < 2 → j = 0, 1.

j = 0:

arr[0] < arr[2] → 3 < 8 ✅ We can extend the subsequence ending at index 0.

Candidate length if we extend:
dp[0] + 1 = 1 + 1 = 2

Update:

dp[2] = max(dp[2], dp[0] + 1) = max(1, 2) = 2

j = 1:

arr[1] < arr[2] → 1 < 8 ✅ We can also extend the subsequence ending at index 1.

Candidate length:
dp[1] + 1 = 1 + 1 = 2

Update:

dp[2] = max(2, 2) = 2

So the best we can do for subsequences ending at 8 is length 2:
Either [3, 8] or [1, 8].

Current:

dp = [1, 1, 2, 1, 1]

i = 3 → element = 2

We look at all j < 3 → j = 0, 1, 2.

j = 0:

arr[0] < arr[3] → 3 < 2? ❌ No. Can't put 2 after 3 in an increasing sequence.

j = 1:

arr[1] < arr[3] → 1 < 2 ✅ We can extend the subsequence ending at 1.

Candidate length:
dp[1] + 1 = 1 + 1 = 2

Update:

dp[3] = max(dp[3], dp[1] + 1) = max(1, 2) = 2

This corresponds to subsequence [1, 2].

j = 2:

arr[2] < arr[3] → 8 < 2? ❌ No.

So best subsequence ending at 2 has length 2 → [1, 2].

Current:

dp = [1, 1, 2, 2, 1]

i = 4 → element = 5

We look at all j < 4 → j = 0, 1, 2, 3.

j = 0:

arr[0] < arr[4] → 3 < 5 ✅ Extend subsequence ending at index 0 (which is [3]).

Candidate length:
dp[0] + 1 = 1 + 1 = 2

dp[4] = max(1, 2) = 2

So, one candidate subsequence is [3, 5].

j = 1:

arr[1] < arr[4] → 1 < 5 ✅ Extend subsequence ending at index 1 ([1]).

Candidate:
dp[1] + 1 = 1 + 1 = 2

dp[4] = max(2, 2) = 2   # no change

So [1, 5] is another subsequence of length 2.

j = 2:

arr[2] < arr[4] → 8 < 5? ❌ No.

We cannot put 5 after 8.

j = 3:

arr[3] < arr[4] → 2 < 5 ✅ Extend subsequence ending at index 3 (which was [1, 2]).

Candidate:
dp[3] + 1 = 2 + 1 = 3

dp[4] = max(2, 3) = 3

Now we’ve found a better subsequence ending at 5:
[1, 2, 5] of length 3.

Final dp array:

dp = [1, 1, 2, 2, 3]

Final Answer

The LIS length is:

max(dp) = 3

And one actual longest increasing subsequence is:

[1, 2, 5]

(There’s no longer one in this example.)

How this is DP (subproblem view)

Each dp[i] depends on smaller indices:

To compute dp[4] (LIS ending at 5), we reused solutions to earlier subproblems: dp[0], dp[1], dp[2], dp[3].

So the subproblem is:

“What’s the length of the longest increasing subsequence that ends at index i?”

You solve that for i = 0, 1, 2, 3, 4 in order → bottom-up tabulation DP.

## 💡 Final Thoughts

Dynamic Programming becomes much easier when you approach it systematically.
By following these 5 steps:

Visualize examples
Identify subproblems
Find relationships
Generalize
Implement in order

—you can confidently tackle even the most intimidating DP problems.

How to Set Up n8n Workflow Automation Tool From Scratch and Make It Accessible via Domain

Sai Shanmukkha Surapaneni — Mon, 11 Aug 2025 06:28:44 +0000

n8n is a powerful open-source workflow automation tool, enabling you to automate repetitive tasks by connecting different apps and services. In this guide, you’ll learn how to set up n8n from zero on any cloud provider or even a bare-metal server, and expose it securely through your own custom domain — all in a cloud-agnostic way.

Why Use n8n?

Open-source and self-hostable
Highly customizable workflows
Supports over 200 apps natively
Extendable with custom nodes
Free to run on your own infrastructure

Overview of What We’ll Cover

Prerequisites
Setting Up a Server
Installing Docker and Docker Compose
Running n8n with Docker
Setting Up a Reverse Proxy with HTTPS using Caddy
Pointing Your Domain and Configuring DNS
Securing and Managing Your Setup

1. Prerequisites

A server (cloud VM or bare-metal) running Linux (Ubuntu recommended)
A domain name you own and control DNS records for
Basic command line and SSH access knowledge
Docker and Docker Compose installed (we’ll install them in the guide)
Optional: An Elastic IP or static IP on your server for consistent access

2. Setting Up Your Server

Choose any cloud provider (AWS, Google Cloud, Azure, DigitalOcean, Linode, Vultr, Hetzner, etc.) or your own Linux server.

Ubuntu 20.04 or 22.04 LTS is preferred.
Make sure ports 80 and 443 are open for HTTP/HTTPS traffic.
SSH into your server to run the commands.

3. Install Docker & Docker Compose

Docker makes deployment straightforward and consistent. Run these commands on your server:

sudo apt-get update -y
sudo apt-get upgrade -y
sudo apt-get install -y docker.io docker-compose unzip curl

# Enable and start Docker
sudo systemctl enable docker
sudo systemctl start docker

# Verify Docker installed correctly
docker --version
docker-compose --version

4. Run n8n Using Docker Compose

Create a project directory and define your Docker Compose file.

mkdir ~/n8n
cd ~/n8n

Create a file named docker-compose.yaml with this content:

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - GENERIC_TIMEZONE=America/Chicago  # Change timezone as needed
      - TZ=America/Chicago
      - N8N_PROTOCOL=http
      - N8N_HOST=yourdomain.com            # Replace with your domain
      - N8N_PORT=5678
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:

Then start your container:

docker-compose up -d

You should now be able to reach n8n on http://your-server-ip:5678 (replace with your actual IP).

5. Setup Reverse Proxy and HTTPS with Caddy

To make your n8n instance accessible securely via HTTPS and your domain, we use Caddy — an automatic HTTPS reverse proxy.

Create a `Caddyfile` in the same directory:

yourdomain.com {
    reverse_proxy n8n:5678
}

Update your `docker-compose.yaml` to add Caddy service:

version: "3"

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    environment:
      - GENERIC_TIMEZONE=America/Chicago
      - TZ=America/Chicago
      - N8N_PROTOCOL=http
      - N8N_HOST=yourdomain.com
      - N8N_PORT=5678
    volumes:
      - n8n_data:/home/node/.n8n

  caddy:
    image: caddy:latest
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - n8n

volumes:
  n8n_data:
  caddy_data:
  caddy_config:

Restart the services:

docker-compose down
docker-compose up -d

6. Point Your Domain DNS

Create an A record in your domain's DNS management panel pointing your domain (e.g., yourdomain.com) to your server's public IP address.
If using a cloud provider with Elastic IPs or static IPs, make sure this IP doesn’t change.
It may take some time for DNS changes to propagate.

7. Secure and Manage Your Setup

Caddy automatically provisions SSL certificates via Let's Encrypt.
Your n8n is now accessible securely at https://yourdomain.com.
Use docker logs caddy or docker logs n8n to debug if necessary.
Backup your /home/node/.n8n data volume regularly.
Consider setting up firewall rules to restrict access.

Conclusion

You now have a self-hosted n8n workflow automation instance running behind a secure HTTPS domain — all set up in a cloud-provider-agnostic way! This setup allows full control over your automation workflows with no vendor lock-in.

If you want to scale or add databases like Postgres, n8n supports that too with minor config changes.

Happy automating! 🚀

References

Automate Everything: Why Bash Scripting is a Must-Learn Skill

Sai Shanmukkha Surapaneni — Wed, 12 Mar 2025 16:08:23 +0000

Introduction

Have you ever wished you could automate boring, repetitive tasks on your computer? Whether you're managing files, monitoring servers, or just simplifying everyday tasks, Bash scripting can be a game-changer. If you're working with Linux, macOS, or even Windows (using tools like Git Bash), learning Bash scripting is a must-have skill that can make your life easier and your workflow more efficient.

Let’s dive into why Bash scripting is so important and why you should start learning it today!

Why Bash Scripting is Important

Automating Repetitive Tasks
- Efficiency: Instead of manually running the same commands over and over, write a script once and let your computer do the work for you.
- Consistency: Ensure tasks are executed exactly the same way every time.
- Examples: File management, backups, log monitoring, and software deployment.
System Administration Made Easy
- Server Management: Bash scripts can manage users, monitor disk usage, and keep systems updated.
- Scheduled Tasks: Use cron jobs to run scripts automatically at specific intervals (e.g., cleaning temp files daily).
Data Processing and File Manipulation
- Handling Text Files: Use grep, awk, and sed to filter and manipulate data.
- Processing Logs: Analyze logs and extract useful insights.
- Batch Processing: Rename, move, or modify multiple files with just one script.
Boosting Productivity and Speed
- Speed: Automate tasks that would take hours manually.
- Customization: Create scripts tailored to your specific needs.
- Example: Write a script to back up your work folder every night.
Cost-Effective and Built-In
- No Extra Software Needed: Bash comes pre-installed on most Linux and macOS systems.
- Cross-Platform: Works on Linux, macOS, and Windows (via WSL or Git Bash).
Essential for DevOps and Cloud Computing
- Automate Deployments: Bash is widely used in CI/CD pipelines.
- Infrastructure Management: Write scripts for AWS, Google Cloud, and Azure automation.
Career Growth and Opportunities
- In-Demand Skill: System administrators, DevOps engineers, and software developers all need Bash.
- Efficiency at Work: Companies love employees who can automate tasks and improve workflows.

How to Learn Bash Scripting (Roadmap)

Ready to start? Follow this roadmap to master Bash scripting!

1. Prerequisites

Before diving into Bash scripting, make sure you have the following:

Basic knowledge of Linux/Unix command-line: Familiarity with common commands like ls, cd, cp, mv, cat, etc.
Understanding of text editors: Learn how to use editors like nano, vim, or emacs for writing scripts.

2. Basic Concepts

Start by learning the foundational aspects of Bash scripting:

Bash Basics: Understand what a Bash script is and how to run one.
- Writing a simple script (e.g., hello.sh).
- Running a script with bash script_name.sh or making it executable with chmod +x script_name.sh and running it directly.
Shebang (#!/bin/bash): Learn about the shebang and why it's used to specify the shell for script execution.
Variables:
- Declaring variables and using them (var_name=value).
- Accessing variables ($var_name).
User Input:
- Using read to get input from the user.

3. Control Flow and Conditional Statements

If Statements:
- Learn if, else, elif for decision-making.
- Example: if [ $a -gt $b ]; then echo "a is greater"; fi.
Comparison Operators:
- Understand numerical and string comparisons (-eq, -gt, -lt, -ne, =, !=).
Case Statements:
- Using case for multiple conditions.
Logical Operators:
- Learn && (and), || (or), and ! (not).

4. Looping Constructs

For Loops:
- Learn both simple loops and loops with a range or list of values.
While and Until Loops:
- Using while and until for repeating commands until a condition is met.
Nested Loops:
- Learn how to nest loops for more complex logic.

5. Functions

Defining Functions:
- Learn how to define and call functions within your script.
- Example: function_name() { ... }
Passing Arguments to Functions:
- Accessing function arguments using $1, $2, etc.
Returning Values from Functions:
- Use return and echo to return values.

6. Working with Files and Directories

File Manipulation:
- Using commands like cp, mv, rm, touch, cat, and echo.
File Permissions:
- Using chmod, chown, chgrp to modify file permissions and ownership.
Directory Manipulation:
- Navigating directories (cd, ls), and creating/removing directories (mkdir, rmdir).
Redirecting Input/Output:
- Learn about >, >>, <, << for redirection.
- Using | (pipe) for chaining commands.

7. Text Processing

Text Utilities:
- Master grep, sed, awk, cut, sort, uniq for text processing.
Regular Expressions:
- Learn basic and advanced regular expressions for pattern matching in files and strings.
String Manipulation:
- Learn string manipulation techniques like substring extraction, replacement, and case conversion.

8. Arrays and Associative Arrays

Arrays:
- Creating and accessing indexed arrays.
- Example: array=(1 2 3).
Associative Arrays:
- Learn about hashmaps/dictionaries (available in Bash 4.0+).
- Example: declare -A map for associative arrays.

9. Error Handling and Debugging

Exit Status:
- Learn how to handle the exit status ($?) of commands and scripts.
- Understand success (0) vs failure (non-zero exit codes.
Using set for Debugging:
- Use set -x for tracing script execution.
- Learn set -e to exit the script if a command fails.
Logging Errors:
- Use 2> for redirecting errors to a file.

10. Advanced Topics

Processes and Job Control:
- Learn how to manage background processes (bg, fg, jobs, disown).
- Use wait to wait for a process to finish.
Command Substitution:
- Learn command substitution with backticks or $(...) for embedding command output.
Scheduling Tasks:
- Learn how to use cron to schedule jobs and at for one-time tasks.
Scripting Best Practices:
- Writing clean, maintainable scripts (use comments, consistent naming conventions).
- Making scripts portable and secure.

11. Putting It All Together

Project Ideas:
- Automating system backups.
- Writing a script to manage log files.
- Creating a system monitoring script.
- Building a script for file organization or batch renaming.
Refactoring Code:
- Refactor large scripts into smaller functions and better-organized components.

12. Resources and Learning Materials

Books:
- "Learning the Bash Shell" by Cameron Newham
- "Bash Cookbook" by Carl Albing, JP Vossen, and Cameron Newham
Online Tutorials:
- GNU Bash Manual
- Bash Scripting Tutorial
Interactive Learning:
- LinuxCommand.org
- Bash Academy
Practice:
- Try coding exercises on platforms like Exercism.io and Hackerrank.

Final Thoughts

Mastering Bash scripting involves consistent practice. Start with small, simple scripts, and gradually take on more complex tasks. Always challenge yourself with real-world problems like automation, system management, and creating custom utilities. The more you script, the more efficient and comfortable you'll become!

Understanding Networking in Oracle's Virtualbox - NAT Network Adapter

Sai Shanmukkha Surapaneni — Mon, 03 Mar 2025 19:44:13 +0000

Oracle VirtualBox provides several network adapter modes to help virtual machines (VMs) connect to external networks, such as the internet. These adapters include:

NAT
NAT Network
Bridged Adapter
Internal Network
Host-only Adapter (Plus a few experimental options.)

In this post, we’ll focus on the NAT (Network Address Translation) Network adapter, which is the default mode for newly created VMs.

NAT Network is different from the NAT Adapter.

Among these, NAT Network is often confused with NAT Adapter, but they serve different purposes. In this post, we'll break down how NAT Network works, why you might use it, and how to configure it for optimal DevOps workflows.

What is NAT Network in VirtualBox?

The NAT Network adapter in VirtualBox acts as a private network for multiple VMs, allowing them to communicate with each other while still having access to the external internet through the host.

Key Features of NAT Network:

Inter-VM Communication – VMs connected to the same NAT Network can talk to each other.
Internet Access – Each VM can access the internet via the host machine.
Port Forwarding – Allows specific ports to be forwarded from the host to the VM.
DHCP Support – VirtualBox provides automatic IP assignment through DHCP.
Network Isolation – The VMs in a NAT Network cannot be directly accessed by the host or other external devices, increasing security.

Can Multiple VMs Communicate with Each Other?

Not with NAT Adapter, but yes with NAT Network.

NAT Adapter isolates VMs; they cannot talk to each other.
NAT Network allows multiple VMs on the same virtual network to communicate while still having internet access.
If you need both internet access and inter-VM communication, you should use NAT Network instead of the NAT Adapter.

What's the difference?

NAT Adapter is best when you just need a single VM to have internet access without network visibility.
NAT Network is useful when multiple VMs need to talk to each other while maintaining external internet access.

NAT Network Diagram

Both VM1 and VM2 can communicate within the NAT Network.
The VirtualBox NAT engine handles internet access for all VMs.
Port forwarding enables external access if needed.

Setting Up NAT Network with a Custom Subnet in VirtualBox

Yes! You can set up a NAT Network in VirtualBox with a custom subnet from the 10.x.x.x private IP range. This allows you to define the IP addressing scheme and ensures VM-to-VM communication within the NAT Network, while still allowing internet access.

Step 1: Create a NAT Network with a Custom Subnet

Open VirtualBox.
Press (Ctrl+H) or Navigate to Tools -> File → Tools -> Network Manager
Go to the NAT Networks tab.
Click Add New NAT Network (green + icon).
Select the new network and click Edit.
Configure the following:
- Network Name: MyCustomNATNetwork
- Enable DHCP: ✅ (Optional, if you want automatic IP assignment)
- Subnet CIDR: 10.10.10.0/24
Click OK and close the Preferences window.

Step 2: Attach VMs to the NAT Network

For each VM:

Select a VM in VirtualBox.
Click Settings → Network.
Choose Adapter 1.
Set Attached to: NAT Network.
Select the NAT Network you created (MyCustomNATNetwork).
Save the settings and start the VM.

Each VM will now receive an IP address in the 10.10.10.x range.

Example:

VM1: 10.10.10.10
VM2: 10.10.10.11

These VMs can now communicate directly with each other.

Step 3: Configure Port Forwarding for Inbound Traffic (Internet → VM)

By default, VirtualBox blocks inbound traffic from the internet. To access a VM from an external machine, port forwarding is required.

Enable Port Forwarding for SSH (Example)

Open VirtualBox.
Select the VM you want to access.
Go to Settings → Network → Advanced → Port Forwarding.
Add a new rule:
- Name: SSH
- Protocol: TCP
- Host IP: 0.0.0.0 (Or your_host_IP)
- Host Port: 2222
- Guest IP: 10.10.10.10
- Guest Port: 22
Save and restart the VM.

Now, you can SSH into the VM from the internet using:

ssh -p 2222 user@your_host_IP

Note: 0.0.0.0 will listen on all network interfaces of the host. If you want to limit access to a specific interface, use your_host_IP.

NAT Network Traffic Flow (10.x.x.x Subnet)

1. Outbound Traffic (VM → Internet)

VM1 (10.10.10.10) sends a request to google.com.
The VirtualBox NAT Engine replaces the VM’s private IP (10.10.10.10) with the host’s public IP.
The request is sent to the internet.
The external website (Google) responds to the host’s public IP.
VirtualBox identifies the VM that made the request and forwards the response to VM1 (10.10.10.10).

➡️ VM1 and VM2 can access the internet but are not directly reachable from the internet unless port forwarding is configured.

2. Inbound Traffic (Internet → VM in NAT Network)

By default, NAT Network blocks unsolicited inbound traffic. However, port forwarding allows selective traffic to be forwarded.

Example: SSH Access from the Internet to VM1

An external user runs:
```
   ssh -p 2222 user@your_host_IP
```
The request reaches the host machine.
The VirtualBox NAT engine checks the port forwarding rules.
The request is forwarded to VM1 (10.10.10.10:22).
The SSH connection is established.

➡️ Only explicitly forwarded ports allow inbound traffic; all other traffic is blocked.

3. Inter-VM Traffic (VM1 ↔ VM2 within NAT Network)

VM1 (10.10.10.10) pings VM2 (10.10.10.11).
The request remains inside the NAT Network (does not go through the host or internet).
VM2 receives the request and responds.
VM1 gets the response, completing the communication.

➡️ VMs within the same NAT Network communicate directly without port forwarding.

Best Practices for Using NAT Network in DevOps

Use NAT Network for Multi-VM Setups – Ideal for running clusters (e.g., Kubernetes, Docker Swarm).
Enable Port Forwarding for Remote Access – Allows SSH and web services to be accessible from the host.
Combine with Bridged Adapters if Needed – If external devices need to reach the VM directly, consider adding a second adapter in Bridged Mode.
Use Static IPs for Stability – Manually assign static IPs to VMs within the NAT Network to avoid conflicts.
DHCP Lease Considerations - Be aware that DHCP leases will expire, and while VirtualBox will attempt to reassign the same IP, it is not guaranteed. For long term stability, static IPs are recommended.
Security Best Practices - Remember that even with network isolation, it is important to maintain security best practices on the host OS. Keep the host OS up to date with security patches, and use strong passwords.

Conclusion

The NAT Network Adapter in VirtualBox is a powerful and flexible option for virtual machine networking, enabling inter-VM communication while maintaining external internet access. By understanding how to configure it properly, you can optimize your development, testing, and DevOps workflows.

Understanding SSH Socket-Based Activation in Ubuntu 24.04

Sai Shanmukkha Surapaneni — Thu, 20 Feb 2025 01:52:02 +0000

With Ubuntu 24.04 LTS, Canonical has continued its trend of optimizing system resources, particularly with how SSH (OpenSSH) is handled. If you've been configuring SSH for a while, you might have noticed that starting from Ubuntu 22.10, SSH uses systemd socket-based activation instead of running as a standalone service by default.

While this change improves memory efficiency (especially for VMs and containers), it can also be a bit confusing if you're trying to configure SSH ports or listen addresses. In this article, I'll try to break it all down and show you how to manage SSH the way you want!

I have faced this issue when I launched Ubuntu instances in AWS Cloud and tried to enable password authentication in /etc/ssh/sshd_config, but it didn't work. I then started researching online to understand what was happening.

What’s Changed with SSH?

Socket-Based Activation by Default

Ubuntu now uses socket-based activation for SSH. This means that sshd doesn’t start until an incoming connection request is received. The benefits? Lower memory usage, especially in cloud and containerized environments, as SSH is only active when needed.

Instead of the traditional SSH service (ssh.service), ssh.socket is now responsible for listening on port 22. When a connection attempt is made, ssh.socket directly starts sshd to handle the session, without starting ssh.service persistently.

Configuring a Custom SSH Port

Previously, to change the SSH port, you'd edit /etc/ssh/sshd_config and set:

Port 5643

However, with socket-based activation, systemd intercepts port configurations and defaults to port 22 unless explicitly changed. Ubuntu 24.04 dynamically pulls port settings from /etc/ssh/sshd_config, eliminating the need to manually migrate configurations.

Edit /etc/ssh/sshd_config, for example:

   Port 5643

Reload systemd and restart ssh.socket:

sudo systemctl daemon-reload
sudo systemctl restart ssh.socket

That’s it! The new port setting should now be active.

What If You Don’t Like This Change?

If you prefer the traditional method where SSH starts at boot and isn’t dependent on systemd sockets, you can disable socket-based activation and restore the classic behavior.

Run:

sudo systemctl disable --now ssh.socket
sudo systemctl enable --now ssh.service

This will:

Stop socket-based activation (ssh.socket)
Enable ssh.service to run at boot
Allow /etc/ssh/sshd_config to fully control SSH settings (including ports and listen addresses)

Avoiding SSH Listening on Multiple Ports

By default, when using socket-based activation and adding a custom port, SSH may end up listening on both the new port and the default port 22. If you only want SSH to listen on one specific port, you must explicitly clear previous settings.

To make SSH listen only on port 5463:

mkdir -p /etc/systemd/system/ssh.socket.d
cat > /etc/systemd/system/ssh.socket.d/listen.conf <<EOF
[Socket]
ListenStream=
ListenStream=5463
EOF

Then reload systemd and restart ssh.socket:

sudo systemctl daemon-reload
sudo systemctl restart ssh.socket

Now SSH will only listen on port 5463.

Conclusion

While systemd socket activation for SSH can be an adjustment, it ultimately provides better efficiency. That said, Ubuntu still allows you to revert to traditional SSH behavior if needed. Understanding these changes ensures you have full control over your system’s SSH configuration.

If you’re fine with the new socket-based activation, just edit /etc/ssh/sshd_config and restart ssh.socket.
If you want SSH to run traditionally (like in Ubuntu 20.04 or before), disable ssh.socket and enable ssh.service.
To ensure SSH only listens on a custom port, clear previous socket settings.

If you have any thoughts or experiences with this change, feel free to share them in the comments!

Understanding Networking in Oracle's VirtualBox - NAT Adapter

Sai Shanmukkha Surapaneni — Sun, 02 Feb 2025 22:52:22 +0000

Oracle VirtualBox provides several network adapter modes to help virtual machines (VMs) connect to external networks, such as the internet. These adapters include:

NAT
NAT Network
Bridged Adapter
Internal Network
Host-only Adapter (Plus a few experimental options.)

In this post, we’ll focus on the NAT (Network Address Translation) adapter, which is the default mode for newly created VMs.

What Is a NAT Adapter?

A NAT (Network Address Translation) adapter creates a separate subnetwork for each VM and uses NAT to connect the VM to the internet, keeping it isolated from the host’s local network. In other words, any request from the VM appears to come from the host machine. Although the VM can access the host, the host cannot directly access the VM unless you set up port forwarding or other configurations.

Can Multiple VMs Communicate With Each Other?

By default, multiple VMs using the NAT adapter cannot communicate with each other. One workaround is to use port forwarding for each VM. Another option is to use the specialized host IP address 10.0.2.2 (for example, 10.0.2.2:) to allow some level of communication. However, this can get tricky for multiple VMs, so you may want to explore other adapter modes if you need direct VM-to-VM communication.

How Does NAT Work?

When a VM is set to use NAT, VirtualBox creates a virtual router that manages network traffic for that VM. The VM receives a private IP address from VirtualBox’s built-in DHCP server, and all outbound traffic is translated (NATed) before reaching external networks (like the internet).

In the figure above:

VM1 and VM2 each use their own NAT table (NAT1 and NAT2).
Both connect to the host machine’s network interface card (NIC).
Each VM is on its own isolated subnetwork, so they cannot directly reach each other’s IP addresses.

Step-by-Step NAT Traffic Flow

Outbound Traffic (VM → Internet)

The VM sends a request (e.g., visiting google.com).

The NAT engine replaces the VM’s private IP (e.g., 10.0.2.15) with the host’s public IP.

The request is sent to the internet.

The response from the external site returns to the host machine.

VirtualBox forwards the response back to the VM.

Inbound Traffic (Internet → VM)

Because the VM is behind NAT, unsolicited inbound traffic is dropped.

Only traffic forwarded via port forwarding rules can reach the VM.

Conclusion

The NAT adapter is a simple and secure way to provide internet access to your VMs without exposing them directly on the host network. If you need more control over network configurations or VM-to-VM communication, consider exploring other VirtualBox network adapters like Bridged or Host-only.

DEV Community: Sai Shanmukkha Surapaneni

Part 1: Mastering Dynamic Programming — 5 Steps to Solve It (Longest Increasing Subsequence Using Tabulation / Bottom-Up)

## 🧠 5-Step Framework to Solve DP Problems

### 1. Visualize Examples (Think in Terms of a DAG)

### 2. Find an Appropriate Subproblem

### 3. Find Relationships Among Subproblems

### 4. Generalize the Relationship

### 5. Implement by Solving Subproblems in Order

0. What does dp[i] mean?

Step-by-step for [3, 1, 8, 2, 5]

Initial state

i = 0 → element = 3

i = 1 → element = 1

i = 2 → element = 8

j = 0:

j = 1:

i = 3 → element = 2

j = 0:

j = 1:

j = 2:

i = 4 → element = 5

j = 0:

j = 1:

j = 2:

j = 3:

Final Answer

How this is DP (subproblem view)

## 💡 Final Thoughts

How to Set Up n8n Workflow Automation Tool From Scratch and Make It Accessible via Domain

Why Use n8n?

Overview of What We’ll Cover

1. Prerequisites

2. Setting Up Your Server

3. Install Docker & Docker Compose

4. Run n8n Using Docker Compose

5. Setup Reverse Proxy and HTTPS with Caddy

Create a Caddyfile in the same directory:

Update your docker-compose.yaml to add Caddy service:

6. Point Your Domain DNS

7. Secure and Manage Your Setup

Conclusion

References

Automate Everything: Why Bash Scripting is a Must-Learn Skill

Introduction

Why Bash Scripting is Important

How to Learn Bash Scripting (Roadmap)

1. Prerequisites

2. Basic Concepts

3. Control Flow and Conditional Statements

4. Looping Constructs

5. Functions

6. Working with Files and Directories

7. Text Processing

8. Arrays and Associative Arrays

9. Error Handling and Debugging

10. Advanced Topics

11. Putting It All Together

12. Resources and Learning Materials

Final Thoughts

Understanding Networking in Oracle's Virtualbox - NAT Network Adapter

What is NAT Network in VirtualBox?

Key Features of NAT Network:

Can Multiple VMs Communicate with Each Other?

What's the difference?

NAT Network Diagram

Setting Up NAT Network with a Custom Subnet in VirtualBox

Step 1: Create a NAT Network with a Custom Subnet

Step 2: Attach VMs to the NAT Network

Step 3: Configure Port Forwarding for Inbound Traffic (Internet → VM)

Enable Port Forwarding for SSH (Example)

NAT Network Traffic Flow (10.x.x.x Subnet)

1. Outbound Traffic (VM → Internet)

2. Inbound Traffic (Internet → VM in NAT Network)

Example: SSH Access from the Internet to VM1

3. Inter-VM Traffic (VM1 ↔ VM2 within NAT Network)

Best Practices for Using NAT Network in DevOps

Conclusion

Understanding SSH Socket-Based Activation in Ubuntu 24.04

What’s Changed with SSH?

Socket-Based Activation by Default

0. What does `dp[i]` mean?

Step-by-step for `[3, 1, 8, 2, 5]`

Create a `Caddyfile` in the same directory:

Update your `docker-compose.yaml` to add Caddy service: