Création d'un raccourcisseur d'URL avec limitation de débit et Redis in Go

Les raccourcisseurs d'URL comme Bitly ou TinyURL sont des outils incroyablement populaires, mais vous êtes-vous déjà demandé ce qu'il fallait pour en créer un ? Dans ce blog, nous verrons comment j'ai créé un raccourcisseur d'URL personnalisé dans Go avec une limitation de débit et une base de données Redis pour le stockage des données et le suivi IP. Nous aborderons les fonctionnalités principales, la pile technologique et les défis que j'ai rencontrés en cours de route.

Aperçu du projet

Cette application de raccourcissement d'URL accepte les URL longues des utilisateurs, génère des liens plus courts et uniques et permet aux utilisateurs de personnaliser l'alias raccourci s'ils le souhaitent. Le serveur redirige tout visiteur qui utilise l'URL raccourcie vers l'URL longue d'origine.

Voici un aperçu rapide des principaux composants :

• WebServer : gère le routage et les requêtes à l'aide du framework Fiber.
• Rate Limiter : gère les demandes des utilisateurs pour éviter les abus, limitant le nombre de demandes qu'une IP peut effectuer dans un laps de temps donné.
• Validateur d'URL : garantit que les URL sont dans un format valide et prêtes à être stockées.
• Générateur d'URL : génère des liens courts uniques pour chaque URL longue ou utilise des alias personnalisés fournis par les utilisateurs.
• Base de données Redis : stocke les mappages d'URL et les limites de débit IP.

En gardant ces fonctionnalités à l’esprit, décomposons la mise en œuvre.

Pile technologique

• Go : Rapide et efficace, Go est idéal pour créer un raccourcisseur d'URL performant.
• Fiber : Un framework web en Go, choisi pour sa légèreté, ses performances et sa simplicité.
• Redis : une base de données en mémoire utilisée pour stocker les mappages d'URL et les quotas IP, nous offrant vitesse et persistance.
• Docker : les conteneurs facilitent la configuration de Redis et garantissent que l'application est portable et évolutive.

Structure du projet

Les fichiers et dossiers principaux sont organisés comme suit :

.
├── 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

Configuration de l'application

1. Logique du serveur principal (main.go)

Notre fichier d'application principal configure les itinéraires de raccourcissement et de résolution des URL. Voici l'extrait de code :

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. Limitation de débit et raccourcissement d'URL (shorten.go)

Pour éviter les abus, nous utilisons Redis pour garder une trace de chaque adresse IP et limiter le nombre de requêtes autorisées. Voici le flux :

1. Vérifier les limites de débit : lorsqu'une demande est effectuée, le limiteur de débit vérifie Redis pour voir combien de demandes l'IP a effectuées.
2. URL du processus : Si la limite de débit n'est pas dépassée, le serveur valide l'URL et la raccourcit.
3. Générer ou utiliser un alias : si l'utilisateur fournit un alias personnalisé, nous le stockons. Sinon, nous générons un identifiant unique.

.
├── 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. Configuration de la base de données Redis (redis.go)

Dans redis.go, nous définissons une fonction d'assistance pour se connecter à Redis. Cette connexion est utilisée sur différents composants pour stocker des URL courtes et appliquer des limites de débit. Voici un exemple simple de la façon dont Redis est configuré :

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")))
}

Configuration du menu Docker

Pour simplifier la configuration de Redis, j'ai utilisé Docker. Cela rend l'application portable et facile à déployer.

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"`
}

Exécution de l'application

1. Cloner le dépôt depuis GitHub : URLShortener

2. Exécutez le conteneur Docker pour Redis :
   

   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. Définir les variables d'environnement dans .env :
   

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

4. Lancer l'application Go :
   

   docker-compose up -d
   

Maintenant, l'application est en ligne et vous pouvez commencer à raccourcir les URL !

Test du raccourcisseur d'URL

Raccourcir une URL

Envoyez une requête POST à ​​/api/v1 avec la charge utile JSON suivante :

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

Accéder à une URL raccourcie

Utilisez l'URL courte générée, comme http://localhost:6767/exmpl, pour être redirigé vers https://example.com.

Apprentissages clés

1. Utilisation de Redis pour la limitation du débit : Redis est incroyablement rapide, et son utilisation à la fois pour le stockage d'URL et la limitation du débit était efficace et efficiente.
2. Créer une API REST avec Fiber : la simplicité et les performances de Fiber sont bien adaptées à la création d'API dans Go.
3. Gestion et validation des erreurs : garantir une gestion robuste des erreurs et une validation des URL était essentiel pour offrir une expérience conviviale.

Améliorations futures

Il y a quelques fonctionnalités et optimisations que j'aimerais ajouter à l'avenir :

• Tableau de bord d'administration : une interface utilisateur pour suivre l'utilisation des URL et surveiller les statistiques.
• Analyses détaillées : suivez le nombre de clics, les référents et les données démographiques des utilisateurs.
• Évolutivité : déployez l'application sur un fournisseur de cloud et utilisez Redis distribué pour gérer des données plus volumineuses.

Conclusion

Construire ce raccourcisseur d'URL a été une expérience enrichissante et un excellent moyen d'explorer Go, Fiber et Redis. Ce projet fournit une base solide, que vous en appreniez sur le développement backend ou que vous exploriez le potentiel de Go dans les services Web.

Si vous souhaitez voir le code en action, consultez le référentiel GitHub ici. Faites-moi part de vos impressions ou si vous avez des suggestions pour améliorer le projet !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!