Comment créer un raccourcisseur d’URL (PHP, MySQL, .htaccess)

Avec tant de temps URL Encombrant le Web, avoir votre propre raccourcisseur d’URL peut vous aider à créer des liens clairs et courts, parfaits pour les campagnes marketing, les réseaux sociaux ou les projets personnels. D’un point de vue marketing, Raccourcisseurs d’URL sont critiques pour plusieurs raisons :

• Suivi de campagne : Vous devez toujours ajouter vos analyses Paramètres UTM pour savoir d’où vient chaque visite. Cependant, ces paramètres prennent souvent une URL typique, la rendant longue et ingérable.
• Codes QR: lancez une longue URL dans un Code QRet vous obtenez un énorme QR Code. Les URL raccourcies rendent les codes QR beaucoup plus simples, ce qui peut étendre leur visibilité de plus loin.

Pour cette raison, vous pourriez être tenté d’acheter une licence pour un raccourcisseur d’URL… mais vous seriez étonné de voir à quel point ils sont simples à construire. Dans ce guide étape par étape, vous apprendrez à créer un raccourcisseur d’URL à l’aide de PHP, MySQLet .htaccess pour des URL propres et raccourcies comme http://yourdomain.com/abc123.

Dans ce guide, nous expliquerons comment créer un raccourcisseur d’URL à l’aide de PHP, MySQL et .htaccesset nous intégrerons les critiques améliorations de la sécurité, optimisations de base de donnéeset améliorations des performances. Nous verrons comment :

• Utiliser PHP pour gérer le raccourcissement et la redirection d’URL.
• Mettre en place un Base de données MySQL avec une structure et des fonctionnalités de sécurité optimisées.
• Mettre en œuvre .htaccess pour des URL raccourcies propres et conviviales.
• Améliorez la sécurité de l’ensemble du système, évitez les devinettes d’URL et améliorez les performances.

Étape 1 : configurer une base de données MySQL sécurisée

Une structure de base de données robuste est cruciale pour un stockage et une redirection efficaces des URL. Suivez ces étapes pour configurer votre base de données MySQL en toute sécurité.

1. Créer une base de données MySQL (si vous n’en avez pas déjà un) et créez un utilisateur avec des privilèges limités pour minimiser les risques de sécurité :

CREATE USER 'url_shortener_user'@'localhost' IDENTIFIED BY 'strongpassword';
GRANT INSERT, SELECT, UPDATE ON your_database.urls TO 'url_shortener_user'@'localhost';

2. Créer le tableau des URL:

CREATE TABLE urls (
    id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    original_url TEXT NOT NULL,
    short_code VARCHAR(10) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    clicks INT DEFAULT 0,
    last_visited TIMESTAMP NULL,
    expiry_date TIMESTAMP NULL
);

• identifiant: Un identifiant unique pour chaque URL.
• URL_originale: stocke l’URL d’origine.
• code_court: Le code raccourci.
• clics: suit le nombre de fois où l’URL a été consultée.
• dernière_visite: La dernière fois que l’URL courte a été cliquée.
• date_expiration: Définit éventuellement la date d’expiration de l’URL.
• Index: Ajouter un index au short_code colonne pour optimiser les recherches :

CREATE INDEX idx_short_code ON urls (short_code);

Cela rend la récupération des URL plus rapide, surtout à mesure que le tableau s’agrandit.

Étape 2 : Créez le script PHP avec des fonctionnalités de sécurité et de performances

Créer un shortener.php déposer que :

1. Génère des codes courts.
2. Stocke les URL en toute sécurité dans la base de données.
3. Redirige les utilisateurs lorsqu’ils visitent une URL courte.
4. Suit les clics et gère les URL expirées.

<?php
// Database connection details
$host = getenv('DB_HOST');
$dbname = getenv('DB_NAME');
$username = getenv('DB_USER');
$password = getenv('DB_PASSWORD');

try {
    $pdo = new PDO("mysql:host=$host;dbname=$dbname", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Could not connect to the database: " . $e->getMessage());
}

// Validate the URL before storing it
function validateURL($url) {
    return filter_var($url, FILTER_VALIDATE_URL) && strlen($url) <= 2048;
}

// Generate a unique short code
function generateUniqueShortCode($pdo, $length = 6) {
    do {
        $shortCode = generateShortCode($length);
        $stmt = $pdo->prepare("SELECT COUNT(*) FROM urls WHERE short_code = :code");
        $stmt->execute(['code' => $shortCode]);
    } while ($stmt->fetchColumn() > 0);

    return $shortCode;
}

// Generate a random short code
function generateShortCode($length = 6) {
    return substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), 0, $length);
}

// Shorten a URL and return the short code
function shortenURL($pdo, $url) {
    if (!validateURL($url)) {
        die("Invalid URL provided.");
    }

    // Check if the URL already exists
    $stmt = $pdo->prepare("SELECT short_code FROM urls WHERE original_url = :url LIMIT 1");
    $stmt->execute(['url' => $url]);
    $result = $stmt->fetch(PDO::FETCH_ASSOC);

    if ($result) {
        return $result['short_code'];
    }

    // Generate a unique short code and store the URL
    $shortCode = generateUniqueShortCode($pdo);
    $stmt = $pdo->prepare("INSERT INTO urls (original_url, short_code) VALUES (:url, :code)");
    $stmt->execute(['url' => $url, 'code' => $shortCode]);

    return $shortCode;
}

// Handle URL redirection, clicks, and expiry
if (isset($_GET['code'])) {
    $shortCode = $_GET['code'];

    // Find the original URL
    $stmt = $pdo->prepare("SELECT original_url, clicks, expiry_date FROM urls WHERE short_code = :code LIMIT 1");
    $stmt->execute(['code' => $shortCode]);
    $result = $stmt->fetch(PDO::FETCH_ASSOC);

    if ($result) {
        // Check if the URL has expired
        if ($result['expiry_date'] && strtotime($result['expiry_date']) < time()) {
            die("This URL has expired.");
        }

        // Update the click count and last visited time
        $stmt = $pdo->prepare("UPDATE urls SET clicks = clicks + 1, last_visited = NOW() WHERE short_code = :code");
        $stmt->execute(['code' => $shortCode]);

        // Redirect to the original URL
        header("Location: " . $result['original_url']);
        exit();
    } else {
        die("URL not found.");
    }
}

// Handle URL shortening form submission
if ($_SERVER['REQUEST_METHOD'] == 'POST' && !empty($_POST['url'])) {
    $url = $_POST['url'];
    $shortCode = shortenURL($pdo, $url);
    $shortURL = "http://yourdomain.com/" . $shortCode;
    echo "Shortened URL: <a href="https://martech.zone/how-to-build-a-url-shortener-php-mysql-htaccess/$shortURL">$shortURL</a>";
}
?>

Principales améliorations de sécurité dans le code :

1. Validation d’URL: garantit que seules les URL valides sont raccourcies.
2. Limitation de débit et reCAPTCHA (facultatif) : pour éviter les abus, mettez en œuvre une limitation du débit à l’aide d’outils tels que mod_evasive ou utiliser Google reCAPTCHA sous la forme.
3. Application du HTTPS: Assurez-vous que HTTPS est appliqué à l’aide de .htaccess.

Étape 3 : utilisez .htaccess pour créer des URL propres

Pour réécrire les URL afin que les utilisateurs ne voient que le code raccourci (http://yourdomain.com/abc123), créer un .htaccess fichier dans le répertoire racine :

RewriteEngine On
RewriteCond %{HTTPS} !=on
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

RewriteRule ^([a-zA-Z0-9]{6})$ shortener.php?code=$1 [L]

• Redirection HTTPS: garantit que tout le trafic est chiffré en redirigeant les requêtes HTTP vers HTTPS.
• Réécriture d’URL: Convertit n’importe quel code court alphanumérique de 6 caractères en un paramètre pour shortener.php.

Étape 4 : Améliorez les performances grâce à la mise en cache et à l’optimisation

1. Mise en cache du navigateur: Ajoutez des en-têtes pour mettre en cache la redirection dans le navigateur de l’utilisateur pendant une durée définie :

header("Cache-Control: max-age=3600"); // Cache for 1 hour

2. Indexation de base de données: Assurez-vous que short_code La colonne est indexée pour des recherches plus rapides.
3. Suivre les clics: Mettez à jour le nombre de clics et last_visited à chaque fois qu’une URL est consultée.

$stmt = $pdo->prepare("UPDATE urls SET clicks = clicks + 1, last_visited = NOW() WHERE short_code = :code");
$stmt->execute(['code' => $shortCode]);

4. Mise en cache facultative avec Memcached ou Redis: Mettez en cache les URL courtes fréquemment consultées pour minimiser les accès à la base de données.

Étape 5 : Suivez et gérez les URL expirées

Pour ajouter une fonctionnalité d’expiration, assurez-vous que expiry_date La colonne est utilisée pour définir les dates d’expiration des URL. Vérifiez si l’URL a expiré lors de la redirection :

if ($result['expiry_date'] && strtotime($result['expiry_date']) < time()) {
    die("This URL has expired.");
}

Combien d’URL puis-je stocker ?

Le nombre d’URL que vous pouvez stocker dans ce raccourcisseur d’URL dépend principalement de deux facteurs :

1. La longueur du code court: Dans l’exemple fourni, le code court comporte six caractères et utilise une combinaison de 62 caractères (AZ majuscule, az minuscule et chiffres 0 à 9). En utilisant la formule des combinaisons possibles :[[

2. Avec un code à 6 caractères, vous pouvez théoriquement stocker 56,8 milliards d’URL uniques.
3. TL’autre facteur limitant est taille de la base de données. Chaque URL occupe de l’espace dans votre base de données MySQL. Étant donné que la longueur des URL peut varier, l’espace de stockage total nécessaire dépend de la longueur des URL d’origine..
   • Le code court lui-même (6 caractères) prendra un espace négligeable.
   • Le URL d’origine stocké comme TEXT peut contenir jusqu’à 65 535 octets (environ 65 Ko), ce qui est suffisant pour presque toutes les URL.
   • Le limite de taille de base de données dépend de votre configuration MySQL et de votre environnement d’hébergement. Par exemple, les bases de données MySQL peuvent gérer des tables jusqu’à plusieurs téraoctets, selon le moteur de stockage et le système de fichiers.
   • Si vous avez des URL en moyenne 100 octets de longueur (environ 100 caractères par URL) et vous souhaitez stocker 1 million d’URLil vous faudrait environ 100 Mo d’espace (sans compter la surcharge de la base de données). Si votre base de données a 1 Go de stockage gratuit, vous pourriez stocker environ 10 millions d’URLen supposant une longueur moyenne d’URL de 100 caractères.

Avec un code à 6 caractères, vous pourriez théoriquement stocker jusqu’à 56,8 milliards d’URL uniquesdépassant de loin ce dont la plupart des raccourcisseurs d’URL ont besoin. La capacité de stockage de votre base de données limiterait probablement la limite réelle. Avez-vous besoin de plus ou moins de capacité ?

• Codes plus courts: Si vous utilisez des codes plus courts, comme 5 caractères, le total des combinaisons tomberait à ( 62^5 = 916 132 832 ), vous limitant à environ 916 millions d’URL.
• Codes plus longs: Si vous utilisez des codes courts plus longs (par exemple, 7 ou 8 caractères), le nombre de combinaisons possibles augmente considérablement :
  • 7 caractères : ( 62^7 = 3,52 \times 10^{10} ) (~ 35 000 milliards d’URL)
  • 8 caractères : ( 62^8 = 218,34 \times 10^{12} ) (~218 000 milliards d’URL)

Vous avez construit un sécurisé, optimisé, évolutif Raccourcisseur d’URL capable de résister aux attaques, de gérer une utilisation à grande échelle et d’offrir une expérience utilisateur propre. Avec Application du HTTPS, limitation de débit, suivi des clicset URL expiréesce raccourcisseur est prêt pour un déploiement dans le monde réel.