DEV Community: Himanshu Neema

What is a Serverless VPN?

Himanshu Neema — Sun, 07 Jan 2024 08:00:00 +0000

Serverless VPN

Serverless VPN is a fusion of two concepts: Serverless Computing and VPN.
To understand, lets dive into the idea behind Serverless Computing and how it can be applied to VPN.

Serverless Computing

Serverless Computing is a method of using Servers efficiently. Yes, there are Servers still used.

Modern cloud providers host powerful servers in data centers around the world. To efficiently utilize each physical server, its resources are sliced into smaller units called Virtual Machines, or VMs in short.

Every physical resource is virtualized - storage, CPU, memory and even network. This way, many Virtual Machines with different Operating Systems can run simultaneously on same physical server with isolation from each other for security.

Cloud providers offer these VMs to their customers via an API (An API, in this context, enables a computer to communicate with another computer via the Internet). The API facilitates the on-demand creation of a Virtual Machine when needed and the deletion of it when not in use – effectively releasing any physical server resources it was consuming. This way, you only pay for the computing resources that the VM used during the time it was running.

This concept of creating a "slice" and customizing the configuration of the "slice" in the form of virtual server (or in the form of container - another lightweight virtualization technology) from a physical server on-demand and releasing its resources on-demand is foundational for Serverless Computing.

Applying Serverless Computing to VPN

The process of connecting to VPN and disconnecting from it indicates that a VPN server is only required for the duration of a VPN connection.

UpVPN leverages this connection boundary to seamlessly provision a VPN server when a user requests to connect to VPN, and deprovision the server when the user request to disconnect from the VPN.

This process of selecting a location and connecting to VPN, followed by disconnection after usage, constitutes a single VPN session.

UpVPN is the first commercial product to leverage Serverless Computing for the duration of a VPN session, giving birth to the world's first Serverless VPN!

Serverless Computing in other Domains

Serverless as a term became more popular when the cloud provider AWS launched the AWS Lambda product in 2014, allowing applications to run without managing servers. Many tools, called "Function as a Service", have emerged, applying the Serverless model of computing to run application code. The Serverless model has also been applied to databases, leading to serverless databases.

Benefits of Serverless VPN

Cost Effective

By efficiently utilizing servers, the cost benefit is passed on to consumers through inexpensive pricing models such as pay as you go pricing model.

Time Savings

Serverless VPN, like UpVPN, is a fully managed VPN service. Consumers can get an on-demand VPN server with a single click, single tap, or a single command line on the terminal. This saves time for technical consumers who like to run their own VPN servers, eliminating the hassles of managing their own servers and VPN configurations.

Scalability

Serverless VPNs, like UpVPN, leverage multiple cloud providers to offer numerous locations and can expand them in a short time.
And relies on cloud provider APIs to scale available VPN servers on-demand.

Cold or Warm Location

In computing, a 'cold start' or 'cold boot' is a term used to refer to the booting of a computing resource, such as a VM or container.

For a fully serverless VPN location (referred to as a cold location), the "cold start" manifests as a longer wait time before a server is ready for the consumer to connect to the VPN. Even though it takes more time, the consumer benefits from getting a dedicated VPN server along with a dedicated IP.

Alternatively, when server capacity at a location is immediately available (referred to as a warm location), a consumer can connect to the VPN immediately!

Conclusion

By applying Serverless Computing model to VPN, UpVPN has created a new kind of VPN and passed down its cost savings and time-saving benefits to consumers!

Ideas for crafting CLI in Rust

Himanshu Neema — Fri, 30 Jun 2023 00:21:31 +0000

I'm a big fan of Rust. My first real world usage of Rust was a cli I created for a hobby project.

In this article I want to share few ideas I used to create cli called upvpn for UpVPN to mange Serverless VPN sessions.

Idea: Subcommand Pattern

A lot of simple clis have following pattern: A cli with many sub-commands and each of the sub-command having its own arguments:

<cli-name> <sub-command> [<arg>] ...

Overtime we want to be able to add sub-command easily.

To do so, lets create a mental model of adding a new sub-command to our cli:

Each sub-command is represented as an enum variant.
Arguments or data to a particular sub-command is represented as struct.
To execute sub-command we call run() method on struct holding all the arguments.

Lets expand each point in detail:

Point #1 and #2

First two are simple use cases of clap.rs:

use clap::{Parser, Subcommand};

#[derive(Parser, Debug)]
#[command(author, version, about)]
pub struct Cli {
    #[clap(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
pub enum Commands {
    /// Sign in to your https://upvpn.app account
    SignIn(SignIn),
    /// Sign out current device
    SignOut(SignOut),
    /// Current VPN status
    Status(Status),
    /// Available locations for VPN
    Locations(ListLocations),
    /// Connect VPN
    Connect(Connect),
    /// Disconnect VPN
    Disconnect(Disconnect),
}

Here each of the variants SignIn, Locations etc. will be available as sub-command on cli with lower case. And their arguments are stored as data in the struct fields.

For instance, SignIn has optional argument to hold email of the user:

[derive(Args, Debug)]
pub struct SignIn {
    email: Option<String>,
}

Point #3

We define a trait RunCommand for each of the data structs to derive, so that we can execute the command by simply calling run() on it.

#[async_trait]
pub trait RunCommand {
    async fn run(self) -> Result<(), CliError>;
}

For instance, SignIn will be implemented it like this:

[derive(Args, Debug)]
pub struct SignIn {
    email: Option<String>,
}

#[async_trait]
impl RunCommand for SignIn {
    async fn run(self) -> Result<(), CliError> {
       // todo: implement sign in logic.
       // arguments to cli available here as data fields on self
    }
}

Having this trait makes main driver of whole cli very simple:

impl Cli {
    pub async fn run(self) -> ExitCode {
        let output = match self.command {
            Commands::SignIn(sign_in) => sign_in.run().await,
            Commands::SignOut(sign_out) => sign_out.run().await,
            Commands::Locations(list_locations) => list_locations.run().await,
            Commands::Connect(connect) => connect.run().await,
            Commands::Disconnect(disconnect) => disconnect.run().await,
            Commands::Status(status) => status.run().await,
        };

        // process error in output to return exit code
     }
}

Idea: Error messages for user

Having RunCommand trait with single method with return type Result<(), CliError> has another benefit, because now we only need to implement Display for CliError for displaying errors in a user friendly way.

thiserror crate makes it easy to do so using macros on CliError enum.

Idea: Graceful Termination

Certain cli operations may be long running in nature, in this situation cli user should be able to exit it gracefully by SIGTERM or ctrl+c.

To handle it would require a dedicated async task (or dedicated thread) to listen to these system events and notify rest of the system through oneshot or broadcast channels, or as simple as printing a message and exiting whole process by std::process::exit(code).

Tokio's doc on the Shutdown topic is very informative.

Idea: Configuration

Cli can take its global configuration from files (json, toml), environment variables or even combination of them.

Figment makes merging configuration from various sources very easy.

Idea: Progress, Colors and User Input

Colors and Progress of a cli not only make cli pleasant to use, but can convey important information to user about errors, success, and progress of long running operations.

When asking user input from list of many options, make it easy to filter by typing few characters through dialoguer::FuzzySelect.

When asking user for password, keep it stay hidden using dialoguer::Password

dialoguer, indicatif, and console are your best friends for a good cli UX.

That's all! For more, checkout this book on building cli in Rust.

To see it all together, checkout cli code in upvpn-app Github repository.