Skip to content

Latest commit

 

History

History
106 lines (75 loc) · 3.29 KB

README.md

File metadata and controls

106 lines (75 loc) · 3.29 KB

🔗 URL Shortener API

A simple URL shortener service built with Rust, Actix-web, and Redis. This API allows you to shorten long URLs and redirect users to the original URLs using short, user-friendly links.

Features

  • Shorten URLs: Convert long URLs into short, user-friendly URLs.
  • Redirect to Original URL: When a short URL is accessed, users are redirected to the original URL.
  • Redis Backend: URL mappings are stored in Redis for fast access.
  • Random Short URL Generation: Short URLs are created using a 6-character random string.
  • Rate Limiting: Protect the API from abuse with basic rate limiting.

Technologies Used

  • Rust (v1.68.0 or later)
  • Actix-web: A powerful web framework for Rust.
  • Redis: An in-memory key-value store used for fast URL storage and retrieval.
  • Serde: For serializing and deserializing JSON data.
  • Rand: A crate used for generating random short URL strings.

Getting Started

Prerequisites

  • Install Rust (version 1.68.0 or later).
  • Install Redis and ensure it is running locally on port 6379.
  • Ensure your project is set up with a Redis connection.

Installation

  1. Clone the repository:

    git clone https://github.com/yourusername/url-shortener.git
cd url-shortener

  2. Install dependencies:

    cargo build

  3. Start Redis Server: Make sure Redis is installed and running locally:

    redis-server

  4. Run the application:

    cargo run

    The server will be running on http://localhost:1025.

API Endpoints

POST /api/shorten

  • Description: Shortens a long URL.
  • Request Body: 
    {
    "original_url": "https://www.example.com"
}
  • Response: 
    {
    "short_url": "http://localhost:1025/api/qzpxlt"
}

GET /api/{short_url}

  • Description: Redirects the user to the original URL associated with the short URL.
  • Path Parameter:
    • short_url: The short URL code (e.g., qzpxlt).
  • Response: A 302 Redirect to the original URL.
    • Example: Redirects to https://www.example.com.

Code Structure

  1. Redis Client Initialization (database/mod.rs):
    The Redis client is initialized and wrapped in a Mutex and Arc for safe concurrent access.

  2. URL Models (models/url.rs):
    Defines the request and response models for handling URLs. The UrlRequest model takes the original URL, while the UrlResponse model returns the shortened URL.

  3. Shorten URL Route (routes/shorten.rs):
    Defines the logic for shortening a URL. When a POST request is made to /shorten, it generates a short URL, stores it in Redis, and returns the shortened URL.

  4. Redirect URL Route (routes/redirect.rs):
    Handles the redirection logic. When a GET request is made to a short URL, the system looks up the corresponding original URL in Redis and redirects the user.

  5. Utility for URL Generation (utils.rs):
    Generates a 6-character random short URL string.

  6. Main Server Setup (main.rs):
    Initializes and runs the Actix-web server, binds the routes, and connects to Redis.

License

This project is open-source and available under the MIT License.