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.
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:
Lassen Sie uns unter Berücksichtigung dieser Funktionen die Implementierung aufschlüsseln.
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
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")))
}
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:
. ├── 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
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")))
}
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"`
}
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
}
Umgebungsvariablen in .env festlegen:
version: '3'
services:
redis:
image: "redis:alpine"
ports:
- "6379:6379"
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!
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
Verwenden Sie die generierte Kurz-URL, z. B. http://localhost:6767/exmpl, um zu https://example.com weitergeleitet zu werden.
Es gibt ein paar Funktionen und Optimierungen, die ich in Zukunft hinzufügen möchte:
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!
Welche Methoden gibt es zum Erstellen einer mobilen Website?
Was ist die geeignete Einstellung für den virtuellen Speicher?
Verwendung von PathFileExists
Tutorial zum Zusammenführen mehrerer Wörter zu einem Wort
So reinigen Sie das zu volle Laufwerk C des Computers
So öffnen Sie das JSON-Format
So erstellen Sie einen WeChat-Klon auf einem Huawei-Mobiltelefon
Lösung außerhalb des zulässigen Bereichs
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
