Erstellen eines URL-Shorteners mit Ratenbegrenzung und Redis in Go

URL-Shortener wie Bitly oder TinyURL sind unglaublich beliebte Tools, aber haben Sie sich jemals gefragt, was zum Erstellen eines solchen Tools nötig ist? In diesem Blog befassen wir uns damit, wie ich in Go einen benutzerdefinierten URL-Shortener mit Ratenbegrenzung und einer Redis-Datenbank zur Datenspeicherung und IP-Verfolgung erstellt habe. Wir werden die Kernfunktionen, den Tech-Stack und die Herausforderungen behandeln, denen ich dabei begegnet bin.

Projektübersicht

Diese URL-Verkürzungsanwendung akzeptiert lange URLs von Benutzern, generiert kürzere, eindeutige Links und ermöglicht Benutzern, den verkürzten Alias ​​bei Bedarf anzupassen. Der Server leitet jeden Besucher, der die verkürzte URL verwendet, zur ursprünglichen langen URL weiter.

Hier ein kurzer Überblick über die Hauptkomponenten:

• WebServer: Verarbeitet Routing und Anfragen mithilfe des Fiber-Frameworks.
• Ratenbegrenzer: Verwaltet Benutzeranfragen, um Missbrauch zu verhindern, und begrenzt die Anzahl der Anfragen, die eine IP in einem bestimmten Zeitraum stellen kann.
• URL-Validator: Stellt sicher, dass URLs in einem gültigen Format vorliegen und zur Speicherung bereit sind.
• URL-Generator: Erzeugt eindeutige Kurzlinks für jede lange URL oder verwendet von Benutzern bereitgestellte benutzerdefinierte Aliase.
• Redis-Datenbank: Speichert URL-Zuordnungen und IP-Ratenbegrenzungen.

Lassen Sie uns unter Berücksichtigung dieser Funktionen die Implementierung aufschlüsseln.

Tech-Stack

• Go: Go ist schnell und effizient und eignet sich ideal zum Erstellen eines leistungsstarken URL-Shorteners.
• Fiber: Ein Web-Framework in Go, das aufgrund seiner leichten Leistung und Einfachheit ausgewählt wurde.
• Redis: Eine In-Memory-Datenbank, die zum Speichern von URL-Zuordnungen und IP-Kontingenten verwendet wird und uns Geschwindigkeit und Beständigkeit bietet.
• Docker: Container erleichtern die Einrichtung von Redis und stellen sicher, dass die Anwendung portierbar und skalierbar ist.

Projektstruktur

Die Kerndateien und Ordner sind wie folgt organisiert:

.
├── main.go               # Entry point for the application
├── routes/
│   ├── shorten.go        # Handles URL shortening and redirects
├── database/
│   ├── redis.go          # Database connection logic
├── helpers/
│   ├── helper.go         # Utility functions for URL validation
├── .env                  # Environment variables
├── docker-compose.yml    # Docker setup for Redis

Einrichten der Anwendung

1. Hauptserverlogik (main.go)

Unsere Hauptanwendungsdatei legt die Routen zum Kürzen und Auflösen von URLs fest. Hier ist der Codeausschnitt:

package main

import (
    "log"
    "os"

    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/logger"
    "github.com/joho/godotenv"

    "github.com/ravikisha/url-shortener/routes"
)

func setupRoutes(app *fiber.App) {
    app.Get("/:url", routes.ResolveURL)
    app.Post("/api/v1", routes.ShortenURL)
}

func main() {
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }

    app := fiber.New()
    app.Use(logger.New())

    setupRoutes(app)

    log.Fatal(app.Listen(os.Getenv("APP_PORT")))
}

2. Ratenbegrenzung und URL-Verkürzung (shorten.go)

Um Missbrauch zu verhindern, verwenden wir Redis, um jede IP-Adresse zu verfolgen und die Anzahl der zulässigen Anfragen zu begrenzen. Hier ist der Ablauf:

1. Ratenbegrenzungen prüfen: Wenn eine Anfrage gestellt wird, überprüft der Ratenbegrenzer Redis, um zu sehen, wie viele Anfragen die IP gestellt hat.
2. URL verarbeiten: Wenn das Ratenlimit nicht überschritten wird, validiert der Server die URL und kürzt sie.
3. Alias ​​generieren oder verwenden: Wenn der Benutzer einen benutzerdefinierten Alias ​​angibt, speichern wir ihn. Andernfalls generieren wir eine eindeutige ID.

.
├── main.go               # Entry point for the application
├── routes/
│   ├── shorten.go        # Handles URL shortening and redirects
├── database/
│   ├── redis.go          # Database connection logic
├── helpers/
│   ├── helper.go         # Utility functions for URL validation
├── .env                  # Environment variables
├── docker-compose.yml    # Docker setup for Redis

3. Redis-Datenbank-Setup (redis.go)

In redis.go definieren wir eine Hilfsfunktion zum Herstellen einer Verbindung zu Redis. Diese Verbindung wird komponentenübergreifend verwendet, um Kurz-URLs zu speichern und Ratenbegrenzungen durchzusetzen. Hier ist ein einfaches Beispiel für die Konfiguration von Redis:

package main

import (
    "log"
    "os"

    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/logger"
    "github.com/joho/godotenv"

    "github.com/ravikisha/url-shortener/routes"
)

func setupRoutes(app *fiber.App) {
    app.Get("/:url", routes.ResolveURL)
    app.Post("/api/v1", routes.ShortenURL)
}

func main() {
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }

    app := fiber.New()
    app.Use(logger.New())

    setupRoutes(app)

    log.Fatal(app.Listen(os.Getenv("APP_PORT")))
}

Docker-Setup

Um die Einrichtung von Redis zu vereinfachen, habe ich Docker verwendet. Dadurch ist die Anwendung portabel und einfach bereitzustellen.

package routes

import (
    "os"
    "strconv"
    "time"

    "github.com/asaskevich/govalidator"
    "github.com/go-redis/redis/v8"
    "github.com/gofiber/fiber/v2"

    "github.com/ravikisha/url-shortener/database"
    "github.com/ravikisha/url-shortener/helpers"
)

// Define structs for the request and response data
type request struct {
    URL         string        `json:"url"`
    CustomShort string        `json:"short"`
    Expiry      time.Duration `json:"expiry"`
}

type response struct {
    URL             string        `json:"url"`
    CustomShort     string        `json:"short"`
    Expiry          time.Duration `json:"expiry"`
    XRateRemaining  int           `json:"x-rate-remaining"`
    XRateLimitReset time.Duration `json:"x-rate-limit-reset"`
}

Ausführen der Anwendung

1. Klonen Sie das Repository von GitHub: URLShortener

2. Führen Sie den Docker-Container für Redis aus:
   

   package database
   
   import (
       "context"
       "github.com/go-redis/redis/v8"
   )
   
   var Ctx = context.Background()
   
   func NewClient(dbNum int) *redis.Client {
       rdb := redis.NewClient(&redis.Options{
           Addr:     "localhost:6379",
           Password: "",
           DB:       dbNum,
       })
       return rdb
   }
   

3. Umgebungsvariablen in .env festlegen:
   

   version: '3'
   services:
     redis:
       image: "redis:alpine"
       ports:
         - "6379:6379"
   

4. Führen Sie die Go-Anwendung aus:
   

   docker-compose up -d
   

Jetzt ist die Anwendung live und Sie können mit dem Kürzen von URLs beginnen!

Testen des URL-Shorteners

Kürzen einer URL

Senden Sie eine POST-Anfrage an /api/v1 mit der folgenden JSON-Nutzlast:

DB_ADDR="localhost:6379"
DB_PASSWORD=""
APP_PORT=":6767"
DOMAIN="localhost:6767"
APP_QUOTA=10

Zugriff auf eine verkürzte URL

Verwenden Sie die generierte Kurz-URL, z. B. http://localhost:6767/exmpl, um zu https://example.com weitergeleitet zu werden.

Wichtige Erkenntnisse

1. Verwendung von Redis zur Ratenbegrenzung: Redis ist unglaublich schnell und die Verwendung sowohl für die URL-Speicherung als auch für die Ratenbegrenzung war effizient und effektiv.
2. Erstellen einer REST-API mit Fiber: Die Einfachheit und Leistung von Fiber eignen sich gut für die Erstellung von APIs in Go.
3. Fehlerbehandlung und Validierung: Die Gewährleistung einer robusten Fehlerbehandlung und URL-Validierung war für die Bereitstellung einer benutzerfreundlichen Erfahrung von entscheidender Bedeutung.

Zukünftige Verbesserungen

Es gibt ein paar Funktionen und Optimierungen, die ich in Zukunft hinzufügen möchte:

• Admin-Dashboard: Eine Benutzeroberfläche zum Verfolgen der URL-Nutzung und zum Überwachen von Statistiken.
• Detaillierte Analysen: Verfolgen Sie Klickzahlen, Referrer und Benutzerdemografie.
• Skalierbarkeit: Stellen Sie die App bei einem Cloud-Anbieter bereit und verwenden Sie verteiltes Redis für die Verarbeitung umfangreicherer Daten.

Abschluss

Die Entwicklung dieses URL-Shorteners war eine lohnende Erfahrung und eine großartige Möglichkeit, Go, Fiber und Redis zu erkunden. Dieses Projekt bietet eine solide Grundlage, egal ob Sie etwas über Backend-Entwicklung lernen oder das Potenzial von Go in Webdiensten erkunden möchten.

Wenn Sie den Code in Aktion sehen möchten, schauen Sie sich hier das GitHub-Repository an. Teilen Sie mir Ihre Gedanken mit oder wenn Sie Vorschläge zur Verbesserung des Projekts haben!

Das obige ist der detaillierte Inhalt vonErstellen eines URL-Shorteners mit Ratenbegrenzung und Redis in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!