Créer un raccourcisseur d'URL avec Python Flask

PythonPythonBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce projet, nous allons apprendre à créer un raccourcisseur d'URL avec Python et Flask. Un raccourcisseur d'URL est un outil qui prend une longue URL et la convertit en une URL plus courte et plus facile à gérer. Cela peut être utile pour partager des liens sur les médias sociaux ou dans les e-mails, ainsi que pour rendre les longues URLs plus conviviales pour les utilisateurs.

👀 Aperçu

Aperçu de l'interface du raccourcisseur d'URL

🎯 Tâches

Dans ce projet, vous allez apprendre :

  • Comment configurer un dossier de projet et créer les fichiers nécessaires pour le raccourcisseur d'URL.
  • Comment configurer une base de données SQLite pour stocker les URLs originales et leurs URL raccourcies correspondantes.
  • Comment générer des URLs raccourcies à l'aide de caractères aléatoires.
  • Comment créer une page d'accueil où les utilisateurs peuvent soumettre une URL à raccourcir et afficher l'URL raccourcie.
  • Comment rediriger les utilisateurs vers l'URL originale lorsqu'ils entrent une URL raccourcie.
  • Comment créer une page d'historique pour afficher toutes les URLs qui ont été raccourcies.
  • Comment exécuter le projet et le tester dans un navigateur web.

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

  • Comprendre comment configurer un projet Flask et créer les fichiers nécessaires.
  • Utiliser SQLite pour créer une base de données et exécuter des requêtes.
  • Générer des caractères aléatoires pour les URLs raccourcies.
  • Développer des modèles HTML et étendre des modèles de base.
  • Gérer les soumissions de formulaires et afficher du contenu dynamique à l'aide de Flask.
  • Mettre en œuvre la redirection d'URL en fonction de l'entrée de l'utilisateur.

Création des fichiers du projet

Pour commencer, nous devons créer un dossier de projet et y ajouter les fichiers suivants :

  • app.py : Ce fichier contiendra tout le code de notre raccourcisseur d'URL.
  • templates/index.html : Ce fichier contiendra le code HTML pour la page d'accueil de notre site web.
  • templates/history.html : Ce fichier contiendra le code HTML pour la page d'historique de notre site web.
  • templates/base.html : Ce fichier contiendra le code HTML de base qui sera utilisé dans index.html et history.html.
cd ~/projet
touch app.py
mkdir templates
touch templates/index.html templates/history.html templates/base.html

Configuration de la base de données

Notre raccourcisseur d'URL devra utiliser une base de données pour stocker les URLs originales et leurs URL raccourcies correspondantes. Nous utiliserons SQLite pour notre base de données, qui est un système de gestion de base de données léger et facile à utiliser.

Pour configurer la base de données, nous devons tout d'abord importer les modules nécessaires dans app.py :

## app.py
from flask import Flask, render_template, request, redirect
import string
import random
import sqlite3

Ensuite, nous devons nous connecter à la base de données SQLite et créer un objet curseur :

## Se connecter à la base de données SQLite
conn = sqlite3.connect("urls.db", check_same_thread=False)
db = conn.cursor()

Ensuite, nous pouvons créer une table dans notre base de données pour stocker les URLs :

## Créer la table urls si elle n'existe pas
db.execute(
    """CREATE TABLE IF NOT EXISTS urls
              (id INTEGER PRIMARY KEY AUTOINCREMENT,
               original_url TEXT NOT NULL,
               short_url TEXT NOT NULL,
               created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)"""
)
conn.commit()
✨ Vérifier la solution et pratiquer

Génération d'URL raccourcies

Pour générer des URL raccourcies, nous utiliserons une combinaison de lettres et de chiffres aléatoires. Cela peut être réalisé à l'aide des modules string et random en Python. Nous allons créer une fonction appelée generate_short_url() qui renverra une chaîne de caractères aléatoire de 6 caractères :

def generate_short_url():
    characters = string.ascii_letters + string.digits
    short_url = "".join(random.choice(characters) for _ in range(6))
    return short_url
✨ Vérifier la solution et pratiquer

Création de la page d'accueil

La page d'accueil de notre site web permettra aux utilisateurs de soumettre une URL à raccourcir. Elle affichera également l'URL raccourcie une fois qu'elle aura été générée. Le code HTML de cette page se trouve dans templates/index.html.

Tout d'abord, nous devons étendre le modèle base.html et créer un formulaire pour que les utilisateurs puissent soumettre leurs URLs :

{% extends "base.html" %} {% block content %}
<div class="text-center">
  <h1 class="text-3xl font-bold text-gray-900 mb-8">Raccourcis ton URL</h1>
  <form action="/" method="POST" class="w-full max-w-sm mx-auto">
    <div
      class="flex items-center border-2 border-blue-500 rounded overflow-hidden"
    >
      <input
        type="text"
        name="original_url"
        placeholder="Entrez l'URL"
        class="appearance-none bg-transparent border-none w-full text-gray-700 py-2 px-4 leading-tight focus:outline-none"
      />
      <button
        type="submit"
        class="bg-blue-500 hover:bg-blue-700 text-white py-2 px-4 rounded-r focus:outline-none"
      >
        Raccourcir
      </button>
    </div>
  </form>
  {% if short_url %}
  <div class="mt-4">
    <p class="text-lg text-gray-700">
      URL raccourcie :
      <a href="{{ request.host_url }}{{ short_url }}" class="text-blue-500"
        >{{ request.host_url }}{{ short_url }}</a
      >
    </p>
  </div>
  {% endif %}
</div>
{% endblock %}

Dans index.html, nous avons un formulaire avec un seul champ d'entrée pour que l'utilisateur puisse entrer son URL. Le formulaire sera soumis sur la même page, donc nous définissons l'attribut action sur /. Nous définissons également l'attribut method sur POST de manière à ce que les données du formulaire soient envoyées dans le corps de la requête.

Maintenant, nous devons ajouter templates/base.html :

<!doctype html>
<html>
  <head>
    <title>Raccourcisseur d'URL</title>
    <link
      href="https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css"
      rel="stylesheet"
    />
  </head>
  <body>
    <nav class="p-6 bg-white flex justify-between items-center">
      <a href="/" class="text-2xl font-bold text-gray-900"
        >Raccourcisseur d'URL</a
      >
      <div>
        <a href="/" class="text-gray-800 mr-6">Accueil</a>
        <a href="/history" class="text-gray-800">Historique</a>
      </div>
    </nav>
    <main class="container mx-auto max-w-xl pt-8 min-h-screen">
      {% block content %} {% endblock %}
    </main>
  </body>
</html>

Dans base.html, nous avons une barre de navigation en haut de la page avec des liens vers la page d'accueil et la page d'historique. Nous avons également un élément main qui contiendra le contenu de chaque page. Le bloc content est où le contenu de chaque page sera inséré.

Nous devons également ajouter le code nécessaire dans app.py pour gérer les soumissions de formulaire et générer l'URL raccourcie :

@app.route("/", methods=["GET", "POST"])
def index():
    if request.method == "POST":
        original_url = request.form["original_url"]
        short_url = generate_short_url()

        ## Insérer les URLs originales et raccourcies dans la base de données
        db.execute(
            "INSERT INTO urls (original_url, short_url) VALUES (?,?)",
            (original_url, short_url),
        )
        conn.commit()

        return render_template("index.html", short_url=short_url)

    return render_template("index.html")

Dans index(), nous vérifions si la méthode de la requête est POST. Si c'est le cas, nous obtenons l'URL originale à partir des données du formulaire et générons une URL raccourcie. Nous insérons ensuite les URLs originales et raccourcies dans la base de données et affichons le modèle index.html avec l'URL raccourcie.

✨ Vérifier la solution et pratiquer

Redirection vers l'URL originale

Lorsque l'utilisateur entre une URL raccourcie, nous voulons le rediriger vers l'URL originale correspondante. Pour ce faire, nous devons créer une fonction qui récupérera l'URL originale dans la base de données à partir de l'URL raccourcie :

@app.route("/<short_url>")
def redirect_to_url(short_url):
    ## Récupérer l'URL originale dans la base de données à partir de l'URL raccourcie
    db.execute("SELECT original_url FROM urls WHERE short_url=?", (short_url,))
    result = db.fetchone()

    if result:
        original_url = result[0]
        return redirect(original_url)

    return render_template("index.html")
✨ Vérifier la solution et pratiquer

Création de la page d'historique

La page d'historique affichera toutes les URLs qui ont été raccourcies, ainsi que leur URL d'origine et la date à laquelle elles ont été ajoutées. Le code HTML de cette page se trouve dans templates/history.html.

Tout d'abord, nous devons étendre le modèle base.html et ajouter un tableau pour afficher les URLs :

{% extends "base.html" %} {% block content %}
<div class="w-full overflow-x-auto">
  <table class="w-full bg-white rounded shadow overflow-hidden">
    <thead class="bg-gray-200">
      <tr>
        <th
          class="text-left py-3 px-4 uppercase font-semibold text-sm text-gray-700"
        >
          URL d'origine
        </th>
        <th
          class="text-left py-3 px-4 uppercase font-semibold text-sm text-gray-700"
        >
          URL raccourcie
        </th>
        <th
          class="text-left py-3 px-4 uppercase font-semibold text-sm text-gray-700"
        >
          Date
        </th>
      </tr>
    </thead>
    <tbody>
      {% for result in results %}
      <tr class="hover:bg-gray-100">
        <td class="border-t">
          <p class="py-3 px-4">{{ result[0] }}</p>
        </td>
        <td class="border-t">
          <a
            href="{{ request.host_url }}{{ result[1] }}"
            class="py-3 px-4 text-blue-500 hover:text-blue-700"
            >{{ request.host_url }}{{ result[1] }}</a
          >
        </td>
        <td class="border-t">
          <p class="py-3 px-4">{{ result[2] }}</p>
        </td>
      </tr>
      {% endfor %}
    </tbody>
  </table>
</div>
{% endblock %}

Nous devons également ajouter le code nécessaire dans app.py pour récupérer les URLs dans la base de données et les passer au modèle :

@app.route("/history")
def history():
    ## Récupérer toutes les URLs de la base de données, triées par les plus récentes
    db.execute(
        "SELECT original_url, short_url, created_at FROM urls ORDER BY created_at DESC"
    )
    results = db.fetchall()
    return render_template("history.html", results=results)
✨ Vérifier la solution et pratiquer

Exécution du projet

Ajoutez le code suivant à la fin de app.py :

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=8080)

Une fois les modules installés, nous pouvons exécuter notre projet en exécutant python app.py dans notre terminal. Cela lancera le serveur de développement Flask et notre site web sera accessible à http://localhost:8080.

Accédez à l'onglet 8080 et actualisez la page. Vous devriez voir ceci :

Flask server running successfully
✨ Vérifier la solution et pratiquer

Résumé

Dans ce projet, nous avons appris à créer un raccourcisseur d'URL à l'aide de Python et de Flask. Nous avons tout d'abord configuré les fichiers et la base de données nécessaires, puis créé des fonctions pour générer des URLs raccourcies et gérer les soumissions de formulaires. Nous avons également appris à récupérer et afficher les URLs à partir de la base de données. Grâce à ce projet, vous pouvez désormais créer votre propre raccourcisseur d'URL et le personnaliser selon vos goûts.