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
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.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.Secure and Random Keys
The short URLs are generated using secure random values, ensuring uniqueness and reducing the chances of collisions.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:
- Enter the long URL.
- Click "Shorten URL".
- 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
- Gorilla Mux for Routing
Gorilla Mux is a powerful router for Go, and it’s used here to handle all the HTTP endpoints.
- 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.
- 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.
- 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:
- Send a POST request to /create with the url parameter:
curl -X POST -d "url=https://example.com" http://localhost:8080/create
- Response:
http://localhost:8080/abcde
- 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:
| Feature | URL Shortener with GUI (Gin) | URL Shortener V2 (Mux) |
|---|---|---|
| Framework | Gin | Gorilla Mux |
| Frontend | Desktop GUI (Fyne) | None |
| URL Key Generation | Secure Random Values | MD5 Hash |
| Storage | Not Specified | In-Memory |
| Complexity | Moderate | Simple |
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!! 🥂
Top comments (0)