DEV Community: Shubham Rathi

Must-Have Tunneling Tools for Developers: Effortlessly Expose Your Localhost in Minutes

Shubham Rathi — Thu, 15 Aug 2024 12:31:06 +0000

When working on development projects, especially on local environments, you might often need to expose your local server to the internet for testing or sharing with your team. Tunneling is your go-to solution. It works across platforms, but today, we'll focus on Ubuntu with a couple of tips that apply to other systems too.

Why Use a Tunnel?

Tunneling allows you to expose a locally running web application securely to the outside world. This is super helpful when you're:

Sharing a live demo with a client
Testing webhook integrations
Collaborating with remote team members on development

One popular tunneling tool is Ngrok, but we'll also check out alternatives like Localtunnel and Pinggy. Each has its unique perks, so let’s dive in.

1. Ngrok

Ngrok is the go-to for many devs because it’s easy to set up and has a good dashboard.

Installation

For Ubuntu users, installing Ngrok is straightforward:

brew install ngrok/ngrok/ngrok

For other platforms, you can download Ngrok here.

Setup

First, sign up for an account, then add your auth token:

ngrok config add-authtoken <your-token>

Start Tunneling

ngrok http 8080

This exposes your local server running on port 8080 to the world via a public URL.

2. Localtunnel

Localtunnel is another handy tool if you prefer a no-fuss setup with fewer features. It’s quick to get started and works with Node.js.

Installation

Install Localtunnel globally with npm

npm install -g localtunnel

Start Tunneling

lt --port 8080

Bonus: Auto-reconnect

You can set up a script to auto-reconnect in case of disconnections:

until lt --port 8085 --subdomain shubh-local --local-https false; do
  echo "Try again";
done

You can even create an alias for this command, making it easy to fire up the tunnel with a short keyword.

3. Pinggy

If you’re looking for a lightweight solution, Pinggy might be up your alley. It’s simple and works well if you’re familiar with SSH.

Start Tunneling

ssh -p 443 -R0:localhost:8000 qr@a.pinggy.io

This method doesn’t need much configuration, making it perfect for quick testing.

Conclusion

Tunneling is an essential skill for developers who frequently work with local servers, webhooks, or need to demo apps remotely. Ngrok is still the king when it comes to features, but tools like Localtunnel and Pinggy give you more options based on your specific needs.

Next time you need to share your localhost, give one of these tools a try and see which works best for you!

Happy tunneling 🚀

Why main method in JAVA is declared in Static?

Shubham Rathi — Sat, 13 Jan 2024 17:03:38 +0000

The main() method is declared static so that JVM can call it without creating an instance of the class containing the main() method.

What if the main method is not static?

If the main method of the java class is not static then it will throw an error, here you can try this code on any java compiler and it will throw the error.

Moreover, if a JAVA class is declared without a static keyword, the JVM has to create an instance of the main Class, and because the constructor might be overloaded and include arguments, there will be no reliable and consistent way for the JVM to find the main method in Java.

public class MyClass {
    public void main(String args[]) {
      System.out.println("Hello World!!");
    }
}

Error: Main method is not static in class MyClass, please define the main method as:
   public static void main(String[] args)

Day 1 with kotlin [Mastering Kotlin in 100 Days]

Shubham Rathi — Sat, 13 Jan 2024 10:11:01 +0000

Variable Types in kotlin

var vs val
The value of variable type val can not be changed later on,
forex, val a = 5

Later on, you cannot make this a = 6
To achieve this you need to initialize this with var a = 5

Set up a separate connection pool for reader and writer DB access | SpringBoot JOOQ

Shubham Rathi — Sat, 13 Jan 2024 09:35:46 +0000

🔍 Disclaimer:

The following is based on my experience and knowledge, and may not represent the best approach or most up-to-date information. Please feel free to share your insights and correct any outdated information.

This is an open dialogue; let's learn and improve together. 🚀

You might be using DB in your corporate application and may need a separate connection pool for the reader and writer DB connection.

One of the advantages of using this is that you can measure the no of requests your reader and writer handle.

Note: Problem with existing migration

In the initial setup, you might enter a problem where you will see your reader and writer connection are going from the connection. So, what's the cause!!

The cause is simple - existing queries, you need to check if your existing queries follow some pattern to not get into this problem. This happens when you write in db and then return, this causes that reader connection to connect to the writer, make sure to make your reader and writer queries go through separate queries.

Setting up in SpringBoot a different pool connection for JOOQ

To set up this make two different instances of DSlContxt, one for select queries and one for writing queries like insert, and update.

import org.jooq.DSLContext

class DSLContextResolver(
    private val reader: DSLContext,
    private val writer: DSLContext
) {
    fun getReaderContext(): DSLContext = reader

    fun getWriterContext(): DSLContext = writer
}

Instead of using direct DSLContext we will be using our custom DSLContextResolver class. For ex:-

private val readerContext = dslContextResolver.getReaderContext()
private val writerContext = dslContextResolver.getWriterContext()

    fun getBookById(id: Long): Book {
        return readerContext.selectFrom(Tables.BOOK)
            .where(Tables.BOOK.ID.eq(id))
            .fetchOne()

    fun addNewBook(book: Book): Book {
        return writerContext.insertInto(Tables.BOOK)
            .set(
                Book(
                    name = book.name,
                    author = book.author,
                    pages = book.pages,
                    ratings = book.ratings,
                )
                    .toBookRecord
            )
            .returning()
            .fetchOne()!!
            .toBook
    }
}

So this is how we can achieve our target. and as earlier I discussed the problem, we can solve this by using returning, if you want to read after inserting or updating. Or, you can use your reader context separately.

Getting Started with SpringBoot in Kotlin/Java [DRAFT]

Shubham Rathi — Sun, 07 Jan 2024 16:34:43 +0000

🔍 Disclaimer:

The following is based on my experience and knowledge, and may not represent the best approach or most up-to-date information. Please feel free to share your insights and correct any outdated information.

This is an open dialogue; let's learn and improve together. 🚀

If you are a beginner, you might face problems when you find resources in a particular language. My best advice is whenever you look for a resource be neutral to language as you might not find the best resource, you can always implement the same logic in another language

For example in Spring Boot, if you go with Kotlin (Gradle Kotlin DSL), on the internet you might find more implementation pom.xml rather than gradle in Kotlin. But when you match both syntaxes, you will learn how to read pom.xml and can convert it on your own without any AI to gradle compatible.

Quick Note

As a general approach before starting anything, you should know why SpringBoot and what's the alternatives in the market.

Springboot is widely used in ITs as a backend, because of its flexibility and ease to maintain large services using micro service and MVC architecture.

Springboot vs Spring Framework?

Simple -> Springboot is made over spring framework allows more functionality as follows:

Easily create standalone applications.
Offers production-ready features.
SpringBoot is easier to launch.
Easier customization and management.

Prerequisite

IntelliJ IDE [Community/ Enterprise]
Java/Kotlin
Knowledge of MVC Architecture

Getting Started with SpringBoot

We will be creating a basic REST Server. Use https://start.spring.io/ to create a start template for us. You can choose your combination as per your need. I am going with Gradle-Kotlin with language Kotlin.

Dependency and Plugins in Springboot

Dependency is nothing but a 'Library' that provides specific functionality that we can use in our application

whereas, plugins are used to: create jar files, create war files, compile code, unit test code, create project documentation, and on and on.

We will be adding some dependencies to start with.
-Spring Web- Provides functionality like live reload of server.

This will generate a zip file, extract it, and open it on IDE. When you open this, you will see some sync going on in the background i.e. Gradle Sync, this will download all the necessary dependencies to plugins defined in build.gradle.kt file.

Project Structure

.
└── src
    ├── main
    │   ├── kotlin
    │   │   └── com.example.demo
    │   │       └── Demo.Application.kt
    │   └── resources
    │       ├── static
    │       ├── template
    │       └── application.properties
    └── test
        └── kotlin
            └── com.example.demo
                └── Demo.Application.kt

src is our classpath where is our all application logic coded.

DemoApplication.kt Explained

@SpringBootApplication
class DemoApplication

fun main(args: Array<String>) {
    runApplication<DemoApplication>(*args)
}

@SpringBootApplication This is provided by springboot annotations, we will look at some annotations and their use cases.

The @SpringBootApplication annotation is equivalent to using @Configuration, @EnableAutoConfiguration, and @ComponentScan with their default attributes, as shown in the following example:

@EnableAutoConfiguration: enable Spring Boot’s auto-configuration mechanism
@ComponentScan: enable @Component scan on the package where the application is located
@Configuration: allow to register extra beans in the context or import additional configuration classes

Beans in SpringBoot

Beans are just like objects of classes, but these are not objects of class, these are objects of spring framework context and managed by spring