🔧 URL Shortener in Go

Building URL Shorteners in Go: A Tale of Two Frameworks

URL shorteners are a classic example of how simple tools can make a big impact. Whether you’re sharing links on social media or sending them in a text, shorter URLs are easier to manage and look clean.

In this blog post, I’ll walk you through these two URL shortener projects that are lightweight and very quick to create, they are both built-in Go: one using the Gin framework and the other using Gorilla Mux.

Each brings a unique approach to the table, and I’ll highlight their features and differences.

~ Source Code: Found here

URL Shortener with GUI: Feature-Rich and Intuitive

Let’s start with the first project—a URL shortener that goes beyond a simple API. It includes both a REST API backend and a desktop GUI application, making it accessible for developers and non-technical users alike. This project uses the Gin framework for its backend and Fyne for the GUI.

Key Features

1. REST API Backend
   
   The Gin framework powers a fast and reliable API for shortening and redirecting URLs. It’s lightweight yet robust, perfect for this use case.

2. Desktop GUI
   
   Built with the Fyne framework, the GUI is clean, minimalistic, and easy to use. It enables users to shorten URLs without needing to touch a terminal.

3. Secure and Random Keys
   
   The short URLs are generated using secure random values, ensuring uniqueness and reducing the chances of collisions.

4. Dual Access
   
   Whether you’re comfortable with REST APIs or prefer a GUI, this project has you covered.

Getting Started

To get started, clone the repository and install the necessary external Go packages:

git clone https://github.com/SirTingling/cloudprojects.git
cd url-shortener
go get -u github.com/gin-gonic/gin
go get -u fyne.io/fyne/v2

Running the App

• Backend Server

Run the backend server with:

go run server.go

The server will start at http://localhost:8080.

• Desktop GUI

Launch the GUI application with:

go run gui.go

This opens a simple window where you can input long URLs and get shortened links in return.

How does it work?

• API Endpoints:

POST /shorten: Accepts a long URL and returns a short URL.
GET /:short: Redirects the short URL to the original URL.

• GUI Workflow:

1. Enter the long URL.
2. Click "Shorten URL".
3. Copy the shortened link and share it.

The inclusion of a GUI makes it more versatile than a typical backend-only application.

URL Shortener V2: Lightweight and Straightforward

The second project is all about simplicity. Built with Gorilla Mux, it focuses on providing a basic yet functional URL shortener. If you’re looking for a lightweight solution that gets the job done, this is the one, my friends.

Key Features

1. Gorilla Mux for Routing

Gorilla Mux is a powerful router for Go, and it’s used here to handle all the HTTP endpoints.

1. MD5-Based Key Generation

Shortened URLs are created using an MD5 hash of the original URL. Yes, I do agree, that it’s not as secure as random generation, nevertheless, it’s efficient and ensures deterministic results.

1. In-Memory Storage

The shortener uses a simple in-memory map to store URLs. This makes it fast, though it’s not ideal for production-scale applications.

1. Minimal Dependencies

With only Gorilla Mux as an external dependency, this project is easy to set up and deploy.

Let's Go!

git clone <repository-url>
cd url-shortener
go get -u github.com/gorilla/mux

Running the App

• Start the server with:

go run main.go

The server will run at http://localhost:8080.

How It Works

• Create Short URL:

1. Send a POST request to /create with the url parameter:

curl -X POST -d "url=https://example.com" http://localhost:8080/create

1. Response:

http://localhost:8080/abcde

1. Redirect: Access the shortened URL

curl http://localhost:8080/abcde

This redirects to the original URL.

Honestly, it’s quick to implement and works well as a learning project or for small-scale use cases. I liked it as a quick mini-project.

Comparing the Two Approaches

Here’s a quick breakdown of the differences:

Working with both approaches was straightforward in my personal opinion and I hope you guys will give them both a try as they can both be used in many different scenarios outside of URL shortening.

The Gin-based solution is ideal for those who want an all-in-one tool with a user interface, while the Mux-based version is perfect for lightweight, API-only use cases.

Thanks for tuning in again to my mini-project adventure with Go (and many more languages & tools). I'll catch you guys in the next one! Cheers!! 🥂