Service de raccourcissement d'URL Utilisation de Go

Vous êtes-vous déjà demandé comment les services comme bitly créent des liens concis et partageables à partir de longues URL? Ce tutoriel vous guide dans la construction d'un raccourcissement d'URL à l'aide de Go, Redis et Docker. C'est un excellent projet pour les développeurs d'améliorer leurs compétences en développement Web pratique.

Résultats d'apprentissage clés

Ce tutoriel couvre:

• GO Configuration du projet avec des modules.
• Développement API RESTFul en Go.
• Tire de redis pour un stockage efficace de valeur clé.
• Structurer le code GO pour la maintenabilité et l'évolutivité.

Prérequis

Assurez-vous que vous avez installé les suivants:

• docker
• Docker Desktop (l'installez-le sur votre système)

Implémentation étape par étape

1. Initialisation du projet

Créez un répertoire de projet et initialisez un module Go:

<code class="language-bash">mkdir url-shortener
cd url-shortener
go mod init github.com/<username>/url-shortener</code>

Cela génère un fichier go.mod pour la gestion de la dépendance. Remplacez <username> par votre nom d'utilisateur GitHub.

2. Structure du projet

Organisez vos fichiers de projet pour plus de clarté:

<code>url-shortener/
├── handlers/         # API request handlers
│   └── handlers.go
├── models/           # Data structures
│   └── url.go
├── router/           # Routing configuration
│   └── router.go
├── storage/          # Redis interaction logic
│   └── redis-store.go
├── main.go           # Application entry point
├── Dockerfile        # Docker build instructions
├── docker-compose.yml # Docker Compose configuration
└── go.mod            # Go module file</code>

3. Installation de dépendance

Installez les packages GO nécessaires:

<code class="language-bash">go get github.com/go-redis/redis/v8
go get github.com/gorilla/mux</code>

Ceux-ci fournissent des capacités d'interaction et de routage redis.

4. Définition du modèle de données

dans models/url.go, définissez les structures de données pour les demandes et les réponses:

<code class="language-go">package models

type ShortenRequest struct {
 URL string `json:"url"`
}

type ShortenResponse struct {
 ShortURL string `json:"short_url"`
}</code>

5. Configuration de stockage redis

Implémentez les opérations redis dans storage/redis-store.go:

<code class="language-go">// ... (RedisStore struct and methods as in original example) ...</code>

Ce code gère l'enregistrement et la récupération des URL à l'aide de redis. La fonction de hachage FNV-1A assure une génération efficace de l'URL courte.

6. Implémentation des gestionnaires d'API

Créez la logique de l'API dans handlers/handlers.go:

<code class="language-go">// ... (ShortenURL, RedirectURL, GetTopDomains functions as in original example) ...</code>

Ces gestionnaires gèrent le raccourcissement de l'URL, la redirection et la récupération du domaine supérieur.

7. Configuration de l'itinéraire

Définir les routes API dans router/router.go:

<code class="language-go">// ... (SetupRouter function as in original example) ...</code>

Cela configure les itinéraires pour le raccourcissement, la redirection et la récupération des domaines supérieurs.

8. Point d'entrée d'application

dans main.go, démarrez le serveur HTTP:

<code class="language-go">// ... (main function as in original example) ...</code>

Cela initialise le routeur et démarre le serveur, enregistrant tous les itinéraires enregistrés.

9. Création dockerfile

Créez un Dockerfile pour conteneuriser l'application:

<code class="language-dockerfile">// ... (Dockerfile content as in original example) ...</code>

10. Configuration docker-compose.yml

Utilisez docker-compose.yml pour gérer l'application et redis:

<code class="language-yaml">// ... (docker-compose.yml content as in original example) ...</code>

11. Exécution d'application

Créez et exécutez l'application:

<code class="language-bash">docker-compose up --build</code>

Cela construit les images Docker et démarre les conteneurs.

12. Test de point de terminaison de l'API

Testez les points de terminaison de l'API à l'aide d'outils comme Postman ou Curl (exemples fournis dans la réponse originale).

Conclusion

Vous avez réussi à construire un service de raccourcissement d'URL! Ce projet démontre des compétences pratiques, redis et docker.

Améliorations futures

Considérez ces extensions:

• URL courtes personnalisables: Permettez aux utilisateurs de définir leurs liens courts.
• Tableau de bord analytique: Suivre les statistiques d'utilisation de l'URL.
• Expiration de l'URL: Implémentez l'expiration de l'URL courte.

Le code complet est disponible [lien vers le référentiel]. N'oubliez pas de remplacer les espaces réservés comme <username> par vos valeurs réelles.

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!