Eine Uniform Resource Locator – oder besser gesagt eine URL – ist die Adresse von Inhalten im Internet. URLs enthalten oft die Adresse einer Webseite, gefolgt von einer langen Kette scheinbar zufälliger Zeichen. Diese können unschön und schwer zu merken sein. Zum Glück gibt es Tools, die URL-Verkürzer, die diese Zeichen minimieren können.

Das Kürzen einer URL hat mehrere Vorteile: Die Adresse lässt sich leichter weitergeben und die Wahrscheinlichkeit, dass sie von den Nutzern falsch getippt wird, ist geringer. Schon ein einziges fehlendes Zeichen in einer URL kann dazu führen, dass sie völlig unbrauchbar ist und die Nutzer/innen auf die falsche Seite oder zu einer Ressource leitet, die gar nicht existiert.

Nehmen wir das Beispiel von https://example.com/blog-url-shorteners/48bfefiahl9adik, das zu https://example.com/url-shorteners verkürzt wurde. Es ist nicht schwer zu erkennen, welche Adresse ein Nutzer eher weitergeben würde oder welche eher zu Tippfehlern führen würde.

Die Vorteile eines URL-Kürzers gehen über das Aufräumen von langen URLs hinaus. Sie können auch bei Folgendem helfen:

  • Verbesserung des Rankings in Suchmaschinen: Content-Ersteller/innen, Unternehmen und Start-ups haben alle Inhalte auf ihren Websites, Blogs oder sozialen Medien. Suchmaschinen bevorzugen Links mit bestimmten Schlüsselwörtern, damit sie entsprechend gerankt werden und gute Ergebnisse erzielen. Eine Kurz-URL, die von einer bekannten Plattform generiert wird, kann dazu beitragen, dass deine URL höher gerankt wird.
  • Verfolge den Verkehr auf deinen Links: Kostenpflichtige URL-Verkürzungsdienste wie Bitly helfen dir, die Nutzer/innen zu verfolgen, die auf deine Links klicken, damit du deinen eingehenden Traffic analysieren und deine Inhalte entsprechend anpassen kannst.

Zwei Ansätze für einen URL-Verkürzer: Eine Python-Bibliothek und eine API

Wenn du den Anweisungen in diesem Lernprogramm folgst, baust du mit Python eine URL-Verkürzungs-Web-Anwendung mit zwei verschiedenen Methoden:

Das pyshorteners-Modul wird von Entwicklern verwendet, um kurze URLs zu generieren, während das Bitly-API-Modul kurze URLs generiert und robustere Funktionen wie Klicks pro URL, Standorte der angeklickten URLs, die Anpassung von URLs und mehr bietet.

Für die Durchführung des Tutorials benötigst du Grundkenntnisse in Python, und Python muss auf deinem System installiert sein.

Einrichten der Projektumgebung

Bevor du deine URL-Verkürzer-Webapplikation erstellst, musst du die Projektumgebung einrichten. Dazu gehört auch die Installation von Flask, einem leichtgewichtigen Framework, das die Entwicklung von Python-Webapplikationen erleichtert.

Beginne mit diesen Schritten:

  • Erstelle einen Projektordner, vielleicht mit einem Namen wie url-shortener.
  • Erstelle eine leere Datei namens main.py in diesem Ordner.
  • Erstelle eine virtuelle Umgebung für dieses Projekt, damit die Installation der Python-Bibliotheken unabhängig von deinem System bleibt. Verwende den Befehl python -m venv myenv in deinem Terminal, um diese Umgebung zu erstellen. (In diesem Fall werden die Umgebungsdateien im Verzeichnis myenv abgelegt.)
  • Aktiviere die virtuelle Umgebung mit dem entsprechenden Befehl für dein Betriebssystem (wobei <myenv> der Name des Verzeichnisses ist, das du im vorherigen Schritt erstellt hast).
    • Windows: <myenv>Scriptsactivate.bat
    • Linux/macOS: source <myenv>/bin/activate
  • Installiere Flask mit dem Befehl pip install flask.
  • Erstelle im Projektordner einen Ordner namens templates. (Flask holt sich die HTML-Vorlagen aus diesem Verzeichnis.)

Deine bisherige Arbeit im Terminal wird ungefähr so aussehen:

Befehle, die in das Terminal eingegeben werden, um die Python-Projektumgebung zu erstellen.
Das bisherige Python-Projekt in einem macOS-Terminal

Mit der pyshorteners-Bibliothek eine URL-Verkürzungs-Web-Anwendung erstellen

Nachdem du deine Projektumgebung eingerichtet hast, erstellst du nun deinen ersten URL-Verkürzer mithilfe der pyshorteners-Bibliothek.

Installiere die pyshorteners-Bibliothek mit dem folgenden Befehl:

pip install pyshorteners

Erstellen einer einfachen Benutzeroberfläche für die Webanwendung

Als Nächstes erstellst du ein einfaches Formular in HTML mit Beschriftungen und Eingabefeldern, in das du eine lange URL eingibst und eine kürzere generierst.

Erstelle eine form.html-Datei im Ordner templates, gib den folgenden Code in diese Datei ein und speichere sie:

<!DOCTYPE html>
<html lang="en">
<head>
  <title>URL Shortener</title>
</head>
<body>
  <h1>URL Shortener</h1>
  <form method="post" action="/">
    <label for="url">Enter an https:// URL:</label>
    <input type="url"
      name="url"
      id="url"
      placeholder="https://www.xyz.com"
      pattern="https://.*" size="50"
        value="{{old_url}}"
      required  
    >
    <button type="submit" value="submit">Submit</button>
    <br>
    <label>Generated URL: </label>
    <input name="generated_url" value="{{new_url}}" style="margin-top: 10px; margin-left:35px" size="50"></input>
  </form>
</body>
</html>

Der obige Code erstellt ein Formular mit zwei Beschriftungen, zwei Eingabefeldern und einer Schaltfläche.

Das erste Eingabefeld mit der Bezeichnung url dient zum Schreiben der langen URL, das andere Feld zum Generieren der kurzen URL.

Das Eingabefeld url hat die folgenden Attribute:

  • name: Zur Identifizierung des Elements (z. B. URL)
  • placeholder: Um ein URL-Beispiel anzuzeigen
  • pattern: Um das Muster einer URL anzugeben, das lautet https://.*
  • required: Um eine URL-Eingabe vor dem Absenden zu machen
  • value: Um die alte URL anzuzeigen

Das zweite Eingabefeld hat ein value -Attribut, das auf new_url gesetzt ist. new_url ist eine Kurz-URL, die von der pyshorteners-Bibliothek aus der Datei main.py generiert wird (im nächsten Abschnitt gezeigt).

Das Eingabeformular ist im folgenden Screenshot dargestellt:

Ein Webformular für den URL-Verkürzer
Ein Webformular für den URL-Verkürzer

URL-Verkürzungscode mit pyshorteners

Nachdem du das Formular erstellt hast, kannst du es mit Python und pyshorteners um einige Funktionen erweitern.

Du fügst Code hinzu, um die lange URL in eine kurze zu verwandeln und die Webanwendung zu starten. Navigiere zu der Datei main.py, die du zuvor erstellt hast, gib den folgenden Code ein und speichere ihn:

from flask import Flask, render_template, request
import pyshorteners
app = Flask(__name__)
 
@app.route("/", methods=['POST', 'GET'])
def home():
  if request.method=="POST":
    url_received = request.form["url"]
    short_url = pyshorteners.Shortener().tinyurl.short(url_received)
    return render_template("form.html", new_url=short_url, old_url=url_received)
  else:
    return render_template('form.html')
 
if __name__ == "__main__":
 app.run()

Der obige Code importiert die pyshorteners-Bibliothek und die folgenden Module aus dem Flask-Framework, die du zum Kürzen von URLs brauchst:

  • Flask: Das Flask-Framework selbst, das wir bereits vorgestellt haben.
  • render_template: Ein Template-Rendering-Paket, das verwendet wird, um die Ausgabe von HTML-Dateien aus dem Ordner templates zu generieren.
  • request: Ein Objekt aus dem Flask-Framework, das alle Daten enthält, die ein Nutzer als Teil einer HTTP-Anfrage vom Frontend an das Backend sendet.

Als Nächstes wird eine Funktion namens home() erstellt, die eine im Formular eingegebene URL annimmt und eine verkürzte URL ausgibt. Der app.route() Dekorator wird verwendet, um die Funktion an die spezifische URL-Route für die Ausführung der Anwendung zu binden, und die POST/GET-Methoden verarbeiten die Anfragen.

In der Funktion home() gibt es eine if-else Bedingungsanweisung.

Bei der Anweisung if wird, wenn request.method=="POST", eine Variable namens url_received auf request.form["url"] gesetzt, die die im Formular eingegebene URL ist. Hier ist url der Name des Eingabefeldes, das in dem zuvor erstellten HTML-Formular definiert wurde.

Dann wird eine Variable namens short_url auf pyshorteners.Shortener().tinyurl.short(url_received) gesetzt.
Hier werden zwei Methoden aus der pyshorteners-Bibliothek verwendet: .Shortener() und .short(). Die Funktion .Shortener() erstellt eine Instanz der Klasse pyshorteners und die Funktion .short() nimmt die URL als Argument auf und kürzt sie.

Die Funktion short(), tinyurl.short(), ist eine der vielen APIs der pyshorteners-Bibliothek. osdb.short() ist eine weitere API, die ebenfalls für denselben Zweck verwendet werden kann.

Die Funktion render_template() wird verwendet, um die HTML-Datei Vorlage form.html zu rendern und URLs über Argumente an das Formular zurückzusenden. Das Argument new_url wird auf und old_url auf url_received gesetzt. Der Geltungsbereich der Anweisung if endet hier.

Für die Anweisung else gilt: Wenn die Anfragemethode nicht POST ist, wird nur die HTML-Vorlage form.html gerendert.

Demonstration der URL-Verkürzungs-Web-Anwendung, die mit der pyshorteners-Bibliothek erstellt wurde

Um die URL-Verkürzungsanwendung von pyshorteners zu demonstrieren, navigiere nach dem Ausführen der Anwendung zur Standardroute für die Anwendung, http://127.0.0.1:5000/.

Füge einen Link deiner Wahl in das erste Feld des Webformulars ein:

Testen des URL-Verkürzers mit der pyshorteners-Bibliothek
Testen des URL-Verkürzers mit der pyshorteners-Bibliothek

Klicke auf die Schaltfläche Senden, um eine verkürzte URL mit tinyurl als Domain im Feld Generierte URL auszugeben:

Ergebnis der URL-Verkürzung mit der pyshorteners-Bibliothek
Ergebnis der URL-Verkürzung mit der pyshorteners-Bibliothek

Verwendung des Bitly API-Moduls zur Erstellung einer URL-Verkürzungs-Web-Anwendung

In diesem Abschnitt entwickelst du eine URL-Verkürzungsanwendung mit Hilfe der Bitly-API. Wie bereits erwähnt, ist das Bitly-API-Modul eine weitere Methode zum Verkürzen von URLs und bietet außerdem detaillierte Analysen zu Klicks, Standort und verwendetem Gerätetyp (z. B. Desktop oder Mobile).

Installiere die Bitly API mit dem folgenden Befehl:

pip install bitly-api-py3

Um die Bitly-API zu nutzen, brauchst du ein Zugriffstoken, das du bekommst, wenn du dich bei Bitly anmeldest.

Nachdem du die Anmeldung abgeschlossen hast, logge dich bei Bitly ein, um dein Dashboard zu sehen:

Screenshot des Bitly Dashboards
Screenshot des Bitly Dashboards

Klicke in der linken Seitenleiste auf Einstellungen und dann auf den Abschnitt API unter Entwicklereinstellungen.

Erstelle ein Zugriffstoken, indem du dein Passwort in das Feld über der Schaltfläche Token generieren eingibst (siehe Abbildung unten) und behalte das Token, um es im Code für deine Anwendung zu verwenden:

Generierung eines Zugangstokens für die Bitly-API
Generierung eines Zugangstokens für die Bitly-API

URL-Verkürzungscode mit der Bitly-API

Jetzt, wo du den Token von Bitly hast, kannst du die Web-Anwendung so programmieren, dass sie die URL mithilfe der Bitly-API verkürzt.

Dazu verwendest du dasselbe Formular, das du für den Abschnitt pyshorteners erstellt hast, allerdings mit einigen Änderungen in der Datei main.py:

from flask import Flask, render_template, request
import bitly_api
app = Flask(__name__)
 
bitly_access_token = "37b1xxxxxxxxxxxxxxxxxxxxxxxxxx"
 
@app.route("/", methods=['POST', 'GET'])
def home():
  if request.method=="POST":
    url_received = request.form["url"]
    bitly = bitly_api.Connection(access_token=bitly_access_token)
    short_url = bitly.shorten(url_received)
    return render_template("form.html", new_url=short_url.get('url'), old_url=url_received)
  else:
    return render_template('form.html')
 
if __name__ == "__main__":
 app.run()

Wie du im obigen Code sehen kannst, wird bitly_api mit import bitly_api importiert. Das Zugriffstoken wird dann in einer Variablen namens bity_access_token gespeichert, wie in bitly_access_token = "37b1xxxxxxxxxxxxxxxxxxxxxxxx".

Die Funktion home() verkürzt die URL und enthält eine if-else bedingte Anweisung.

Bei der Anweisung if wird die im Formular übermittelte URL auf die Variable url_received gesetzt, wenn die Methode oder Anfrage POST lautet.

Die Funktion bitly_api.Connection(access_token=bitly_access_token) verbindet sich mit der Bitly-API und übergibt ihr das zuvor gespeicherte Zugriffstoken als Argument.

Um die URL zu kürzen, wird die Funktion bitly.shorten() verwendet, indem die Variable url_received als Argument übergeben und in einer Variable namens short_url gespeichert wird.

Zum Schluss wird das erstellte Formular gerendert und die URLs werden zurückgeschickt, um mit der Funktion render_template() im Formular angezeigt zu werden. Die Anweisung if wird hier abgeschlossen.

Für die Anweisung else wird das Formular mit der Funktion render_template() gerendert.

Demonstration der mit der Bitly-API erstellten URL-Verkürzungs-Web-Anwendung

Um die Bitly-API-URL-Verkürzungsanwendung zu demonstrieren, navigiere zur Standardroute für die Anwendung, http://127.0.0.1:5000/, nachdem du die Anwendung gestartet hast.

Füge einen Link deiner Wahl in das erste Feld des Webformulars ein:

Testen des URL-Verkürzers mit der Bitly-API
Testen des URL-Verkürzers mit der Bitly-API

Klicke auf Absenden, um eine Kurz-URL mit bit.ly als Domain im zweiten Feld der Webanwendung zu erzeugen:

Ergebnis der URL-Verkürzung mit der Bitly-API
Ergebnis der URL-Verkürzung mit der Bitly-API

So einfach ist es, die Bitly-API zum Verkürzen von URLs in deiner Python-Anwendung zu nutzen.

Zusammenfassung

Mit URL-Verkürzern erhältst du kurze URLs, die leicht weitergegeben werden können, sauberer aussehen und weniger Platz benötigen. In diesem Artikel hast du etwas über URL-Verkürzer und ihre Vorteile erfahren. Außerdem hast du gelernt, wie du mit pyshorteners und der Bitly-API eine URL-Verkürzer-Webanwendung mit Python erstellen kannst. Die pyshorteners-Bibliothek liefert kurze URLs, während die Bitly-API neben kurzen URLs auch detaillierte Analysen liefert.

Wenn du schon eine tolle Anwendung entwickelt hast, warum gehst du nicht noch einen Schritt weiter und hostest sie bei Kinstas Anwendungs-Hosting Service? Wie du eine Python-Anwendung wie diese auf unserer Plattform zum Laufen bringst, erfährst du in unserem Flask-Schnellstart-Tutorial.

Adarsh Chimnani

Adarsh is a web developer (MERN stack), passionate about game-level designing (Unity3D), and an anime enthusiast. He enjoys absorbing knowledge just out of curiosity, implementing what he has learned in the real world, and sharing that knowledge with others.