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.
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 :
En gardant ces fonctionnalités à l’esprit, décomposons la mise en œuvre.
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
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")))
}
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 :
. ├── 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
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")))
}
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é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
}
Définir les variables d'environnement dans .env :
version: '3'
services:
redis:
image: "redis:alpine"
ports:
- "6379:6379"
Lancer l'application Go :
docker-compose up -d
Maintenant, l'application est en ligne et vous pouvez commencer à raccourcir les 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
Utilisez l'URL courte générée, comme http://localhost:6767/exmpl, pour être redirigé vers https://example.com.
Il y a quelques fonctionnalités et optimisations que j'aimerais ajouter à l'avenir :
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!
fil prix de la devise prix en temps réel
Quelles sont les manières d'exécuter des scripts Shell ?
Quel logiciel est cdr
Comment utiliser la fonction de filtre
Comment définir le numéro de page ppt
Utilisation de PathFileExists
cmccedu
Comment supprimer le filigrane du compte Douyin des vidéos téléchargées depuis Douyin
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
