📅 February 02, 2026
⏱ 10 min de lecture
Web & Networking

Comment créer un raccourcisseur d'URL avec redirections

Guide sur la création d'un service de raccourcissement d'URL, couvrant les choix technologiques, la conception de bases de données, la logique de base pour la génération de code et la redirection, ainsi que le déploiement.

⭐ Intermediate

La création d'un raccourcisseur d'URL avec redirections implique plusieurs composants et étapes clés. Voici un aperçu général de la manière dont vous pouvez vous y prendre :

1. Choisissez votre pile technologique

  • Langage/cadre backend : vous aurez besoin d'un langage et d'un cadre côté serveur pour traiter les requêtes, générer des codes courts et interagir avec une base de données. Les choix les plus courants sont Python (Flask, Django), Node.js (Express), Ruby (Rails), Go ou PHP (Laravel).
  • Base de données : une base de données est essentielle pour stocker le mappage entre les codes courts et les URL d'origine. Les options incluent PostgreSQL, MySQL, MongoDB ou même Redis pour des liens courts temporaires très performants.
  • Frontend (facultatif mais recommandé) : pour une interface conviviale, vous pouvez utiliser HTML, CSS et JavaScript (avec des frameworks tels que React, Vue ou Angular) afin de permettre aux utilisateurs de saisir des URL longues et de voir les URL courtes générées.

2. Conception du schéma de base de données

Vous aurez besoin d'une table (ou d'une collection) pour stocker vos mappages d'URL. Un schéma de base peut inclure : * id : clé primaire (entier auto-incrémenté ou UUID). * short_code : une chaîne courte unique (par exemple, « abcde ») qui fera partie de votre URL courte. Elle doit être indexée pour permettre des recherches rapides. * original_url : l'URL complète et longue vers laquelle le code court redirige. * created_at : horodatage de la création de l'URL courte. * clicks (facultatif) : un compteur indiquant le nombre de fois où l'URL courte a été consultée.

3. Logique backend principale

  • Génération du code court :

    • Lorsqu'un utilisateur soumet une URL longue, votre backend doit générer un short_code unique.
    • Cela peut être fait de la manière suivante :
      • Génération d'une chaîne aléatoire : générez une chaîne aléatoire d'une longueur fixe (par exemple, 6 à 8 caractères) à l'aide de caractères alphanumériques. Vous devrez vérifier si ce code existe déjà dans votre base de données et le régénérer si c'est le cas afin de garantir son unicité.
      • Hachage : Hachez l'URL d'origine ou une combinaison de l'URL et d'un horodatage, puis prenez une partie du hachage. Cette méthode peut être plus déterministe, mais nécessite tout de même des vérifications d'unicité.
      • Codage Base62 : si vous utilisez un id à incrémentation automatique dans votre base de données, vous pouvez convertir cet identifiant entier en une chaîne de caractères base62 (0-9, a-z, A-Z). Cela garantit l'unicité et est très efficace.

  • Stockage du mappage :

    • Une fois qu'un short_code unique est généré, stockez le short_code et l'original_url dans votre base de données.

  • Gestion des redirections :

    • Lorsqu'un utilisateur accède à une URL courte (par exemple, yourshortener.com/abcde), votre serveur doit :
      1. Extraire le short_code (abcde) du chemin d'accès de l'URL.
      2. Interroger votre base de données pour trouver l'original_url associé à ce short_code.
      3. Si elle est trouvée, émettre une redirection HTTP 301 (déplacé de manière permanente) ou 302 (trouvé) vers l'original_url. Une redirection 301 est généralement préférable pour les redirections permanentes, car elle est mise en cache par les navigateurs, ce qui réduit les requêtes ultérieures vers votre serveur.
      4. Si elle n'est pas trouvée, renvoyer une page d'erreur 404 Not Found (introuvable).

4. Points de terminaison API (pour le backend)

  • POST /shorten :

    • Prend original_url dans le corps de la requête.
    • Génère un short_code.
    • Stocke le mappage.
    • Renvoie l'URL courte complète (par exemple, yourshortener.com/generated_code).

  • GET /:short_code :

    • Récupère short_code à partir du chemin d'accès URL.
    • Recherche original_url.
    • Effectue la redirection.

5. Frontend (le cas échéant)

  • Une simple page web avec un champ de saisie pour l'URL longue et un bouton pour la soumettre.
  • Affiche l'URL courte générée à l'utilisateur.

6. Déploiement

  • Vous aurez besoin d'un nom de domaine (par exemple, myurl.short).
  • Hébergez votre application backend sur un serveur (par exemple, AWS, Google Cloud, Heroku, Vercel).
  • Configurez votre serveur web (par exemple, Nginx, Apache) pour acheminer les requêtes vers votre application backend et gérer le domaine.

Exemple de flux :

  1. L'utilisateur visite yourshortener.com.
  2. L'utilisateur saisit https://www.example.com/very/long/path/to/a/resource et clique sur « Raccourcir ».
  3. Le frontend envoie une requête POST à yourshortener.com/shorten avec l'URL longue.
  4. Le backend génère un short_code unique, tel que XyZ12a.
  5. Le backend stocke XyZ12a -> https://www.example.com/very/long/path/to/a/resource dans la base de données.
  6. Le backend répond avec yourshortener.com/XyZ12a.
  7. L'utilisateur partage yourshortener.com/XyZ12a.
  8. Un autre utilisateur clique sur yourshortener.com/XyZ12a.
  9. Son navigateur envoie une requête GET à yourshortener.com/XyZ12a.
  10. Le backend recherche XyZ12a et trouve l'URL d'origine.
  11. Le backend envoie une réponse de redirection HTTP 301 au navigateur de l'utilisateur, pointant vers https://www.example.com/very/long/path/to/a/resource.
  12. Le navigateur de l'utilisateur navigue alors vers l'URL longue d'origine.