Pour construire une application de raccourcissement d’URL en utilisant Python et le framework Flask, il est important de comprendre les éléments clés de cette tâche. Tout d’abord, il faut avoir une bonne connaissance de Python, en particulier des concepts tels que les fonctions, les classes, les structures de données et les modules. De plus, une compréhension de base du protocole HTTP et des principes de développement web est nécessaire.
En ce qui concerne Flask, il s’agit d’un micro-framework web pour Python, conçu pour être simple et facile à utiliser tout en étant suffisamment flexible pour construire des applications web de toutes tailles. Flask utilise Werkzeug comme bibliothèque sous-jacente pour gérer les aspects bas niveau tels que le routage et les requêtes HTTP, et Jinja2 pour la gestion des templates HTML.
La première étape pour construire notre application consistera à installer Flask. Cela peut être fait en utilisant pip, le gestionnaire de paquets Python, via la commande suivante dans votre terminal :
bashpip install Flask
Une fois Flask installé, nous pouvons commencer à concevoir notre application. Pour ce faire, nous allons créer un fichier Python que nous appellerons app.py par exemple. Dans ce fichier, nous allons importer la classe Flask depuis le module flask, créer une instance de cette classe et définir les routes et les fonctions associées à chaque route.
Voici un exemple de code pour commencer :
pythonfrom flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return 'Bienvenue sur notre service de raccourcissement d\'URL !'
if __name__ == '__main__':
app.run(debug=True)
Dans ce code :
- Nous importons la classe Flask depuis le module flask.
- Nous créons une instance de la classe Flask et l’assignons à la variable app.
- Nous utilisons le décorateur @app.route(‘/’) pour spécifier la route de notre application, dans ce cas, la route principale.
- Nous définissons une fonction home() qui renvoie un message de bienvenue.
- Enfin, nous utilisons la méthode app.run() pour lancer le serveur Flask.
Pour exécuter notre application, il suffit de lancer le fichier app.py à l’aide de Python :
bashpython app.py
Cela lancera un serveur de développement Flask sur votre machine, généralement sur le port 5000 par défaut. Vous pouvez accéder à votre application en ouvrant un navigateur web et en entrant l’adresse http://localhost:5000/.
Maintenant que nous avons une application web de base en place, nous pouvons commencer à ajouter la fonctionnalité de raccourcissement d’URL. Cela implique de créer une interface utilisateur où les utilisateurs peuvent soumettre une URL longue et obtenir en retour une version raccourcie de cette URL. Ensuite, nous devons stocker ces URL dans une base de données, associer chaque URL longue à une clé unique et fournir un mécanisme pour rediriger les utilisateurs de l’URL raccourcie vers l’URL originale lorsqu’ils accèdent à l’URL raccourcie.
Dans la partie suivante, nous explorerons comment ajouter cette fonctionnalité à notre application Flask de base.
Plus de connaissances
Pour enrichir davantage notre application de raccourcissement d’URL, nous devons maintenant ajouter la logique nécessaire pour générer des URL raccourcies uniques, stocker ces URL dans une base de données, et fournir un mécanisme pour rediriger les utilisateurs vers les URL originales lorsqu’ils accèdent aux URL raccourcies.
Génération d’URL raccourcies uniques
Pour générer des URL raccourcies uniques, nous pouvons utiliser des bibliothèques Python telles que uuid ou shortuuid pour créer des identifiants uniques. Voici comment nous pouvons le faire :
pythonimport shortuuid
def generate_short_url():
return shortuuid.uuid()[:6] # Utilise les 6 premiers caractères de l'UUID
Cette fonction génère un identifiant unique de 6 caractères à partir d’un UUID (Universal Unique Identifier) en utilisant la bibliothèque shortuuid.
Stockage des URL dans une base de données
Nous devons également configurer une base de données pour stocker les correspondances entre les URL originales et les URL raccourcies. Flask prend en charge différents moteurs de base de données via des extensions. Par exemple, l’extension Flask-SQLAlchemy est populaire pour l’intégration d’une base de données SQL.
Voici comment nous pouvons configurer Flask-SQLAlchemy dans notre application :
pythonfrom flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///urls.db'
db = SQLAlchemy(app)
class URL(db.Model):
id = db.Column(db.Integer, primary_key=True)
original_url = db.Column(db.String(512))
short_url = db.Column(db.String(10), unique=True)
def __repr__(self):
return f"URL('{self.original_url}', '{self.short_url}')"
Dans ce code, nous avons créé une classe URL qui représente notre modèle de données pour les URL. Elle comporte trois champs : id (clé primaire), original_url et short_url. Nous avons également configuré Flask-SQLAlchemy pour utiliser une base de données SQLite stockée localement dans un fichier urls.db.
Redirection des utilisateurs
Enfin, nous devons fournir un mécanisme pour rediriger les utilisateurs vers les URL originales lorsqu’ils accèdent aux URL raccourcies. Nous devons définir une nouvelle route dans notre application Flask pour gérer les redirections :
python@app.route('/' )
def redirect_to_original(short_url):
url = URL.query.filter_by(short_url=short_url).first_or_404()
return redirect(url.original_url)
Cette route utilise le paramètre dynamique
Interface utilisateur
Pour permettre aux utilisateurs de soumettre des URL à raccourcir, nous devons créer un formulaire HTML dans une nouvelle route de notre application Flask. Cette route recevra les URL soumises, les raccourcira, les stockera dans la base de données, puis renverra à l’utilisateur un lien vers l’URL raccourcie.
Voici un exemple de route pour afficher le formulaire et traiter les soumissions :
pythonfrom flask import request, render_template, redirect, url_for
@app.route('/shorten', methods=['GET', 'POST'])
def shorten_url():
if request.method == 'POST':
original_url = request.form['original_url']
short_url = generate_short_url()
new_url = URL(original_url=original_url, short_url=short_url)
db.session.add(new_url)
db.session.commit()
return render_template('shortened.html', short_url=short_url)
return render_template('shorten.html')
Dans ce code, nous vérifions si la méthode de la requête est POST, ce qui indique que le formulaire a été soumis. Nous récupérons alors l’URL originale soumise par l’utilisateur, générons une URL raccourcie, créons un nouvel objet URL avec ces valeurs, le sauvegardons dans la base de données, puis renvoyons à l’utilisateur un template HTML avec l’URL raccourcie.
Templates HTML
Nous devons créer deux templates HTML : un pour afficher le formulaire de soumission d’URL et un autre pour afficher l’URL raccourcie générée. Voici à quoi ils pourraient ressembler :
html
html>
<html>
<head>
<title>Raccourcir URLtitle>
head>
<body>
<h2>Raccourcir une URLh2>
<form method="post" action="{{ url_for('shorten_url') }}">
<input type="text" name="original_url" placeholder="Entrez l'URL à raccourcir" required>
<button type="submit">Raccourcirbutton>
form>
body>
html>
html
html>
<html>
<head>
<title>URL Raccourcietitle>
head>
<body>
<h2>URL Raccourcieh2>
<p>URL raccourcie générée : <a href="{{ url_for('redirect_to_original', short_url=short_url) }}">{{ url_for('redirect_to_original', short_url=short_url) }}a>p>
body>
html>
Conclusion
En combinant toutes ces parties, vous obtiendrez une application de raccourcissement d’URL fonctionnelle avec Flask. Vous pouvez continuer à l’améliorer en ajoutant des fonctionnalités telles que la gestion des utilisateurs, la personnalisation des URL raccourcies, les statistiques d’utilisation, etc. L’utilisation de tests unitaires et le déploiement sur des serveurs en ligne sont également des étapes importantes pour garantir la stabilité et la sécurité de votre application.