Un localizzatore uniforme di risorse (uniform resource locator, o, più comunemente, URL ) è l’indirizzo di un contenuto su Internet. Gli URL spesso contengono l’indirizzo di una pagina web seguito da una lunga stringa di caratteri apparentemente casuali. Questi possono essere sgradevoli e poco memorabili. Fortunatamente, esistono degli strumenti chiamati URL shortener, o accorciatori di URL che possono ridurli al minimo.

Accorciare un URL ha diversi vantaggi, tra cui quello di rendere l’indirizzo più facile da condividere e di ridurre le probabilità che gli utenti digitino in modo impreciso. Anche un solo carattere mancante in un URL può renderlo completamente inutile, indirizzando gli utenti alla pagina sbagliata o a una risorsa che non esiste nemmeno.

Prendiamo l’esempio di https://example.com/blog-url-shorteners/48bfefiahl9adik abbreviato in https://example.com/url-shorteners. Non è difficile capire quale sia l’URL che un utente sarebbe più propenso a condividere o quale potrebbe essere più soggetto a errori di digitazione.

I vantaggi di un accorciatore di URL non si limitano a riordinare gli URL lunghi. Può essere utile anche per i seguenti aspetti:

  • Migliorare il posizionamento nei motori di ricerca: i creatori di contenuti, le aziende e le start-up hanno tutti dei contenuti sui loro siti web, blog o social media. I motori di ricerca preferiscono i link con parole chiave specifiche, in modo che possano essere classificati di conseguenza e generare buoni risultati. Un URL breve generato da una piattaforma conosciuta può aiutare a posizionare il vostro URL più in alto.
  • Tracciare il traffico sui link: i servizi di accorciatori di URL a pagamento come Bitly vi aiutano a tracciare gli utenti che cliccano sui vostri link, in modo da poter analizzare il traffico in entrata e personalizzare i vostri contenuti di conseguenza.

Due approcci per un accorciatore di URL: Una libreria Python e un’API

Seguendo le istruzioni di questo tutorial, costruiremo un’applicazione web per accorciare gli URL con Python utilizzando due metodi diversi:

Il modulo pyshorteners viene utilizzato dagli sviluppatori per generare URL brevi, mentre il modulo Bitly API genera URL brevi e fornisce funzioni più robuste come i clic per URL, le posizioni degli URL cliccati, la personalizzazione degli URL e altro ancora.

Per completare il tutorial, è necessario avere una conoscenza di base di Python e Python deve essere installato sul sistema.

Impostazione dell’ambiente del progetto

Prima di creare la nostra web app per accorciare gli URL, dobbiamo impostare l’ambiente del progetto, compresa l’installazione di Flask, un framework leggero che facilita lo sviluppo di web app in Python.

Iniziamo con questi passaggi:

  • Creiamo una cartella di progetto, magari con un nome come url-shortener.
  • Creiamo un file vuoto chiamato main.py all’interno della cartella.
  • Creiamo un ambiente virtuale per questo progetto in modo che l’installazione delle librerie Python sia indipendente dal sistema. Usiamo il comando python -m venv myenv nel terminale per creare questo ambiente. (In questo caso, i file dell’ambiente saranno collocati nella cartella myenv)
  • Attiviamo l’ambiente virtuale usando il comando corrispondente al sistema operativo (e dove <myenv> è il nome della directory creata nel passaggio precedente).
    • Windows: <myenv>Scriptsactivate.bat
    • Linux/macOS: source <myenv>/bin/activate
  • Installiamo Flask utilizzando il comando pip install flask.
  • Creiamo una cartella denominata templates nella cartella del progetto. (Flask recupererà i modelli HTML da questa cartella)

Il lavoro svolto finora nel terminale sarà simile a questo:

Commands entered in the terminal to create the Python project environment.
Il progetto Python in un terminale macOS.

Usare la libreria pyshorteners per creare un’app web di accorciatori di URL

Dopo aver configurato l’ambiente del progetto, creeremo il nostro primo accorciatore di URL utilizzando la libreria pyshorteners.

Installiamo la libreria pyshorteners con il seguente comando:

pip install pyshorteners

Creare un’interfaccia utente di base per l’applicazione web

Successivamente, creeremo un modulo di base in HTML con etichette e campi di input, in cui inserire un URL lungo e generarne uno più corto.

Creiamo un file form.html nella cartella templates, quindi inseriamo il seguente codice nel file e salviamolo:

<!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>

Il codice precedente crea un modulo con due etichette, due campi di input e un pulsante.

Il primo campo di input, chiamato url, serve per scrivere l’URL lungo, mentre l’altro campo serve per generare l’URL breve.

Il campo di input url ha i seguenti attributi:

  • name: per identificare l’elemento (ad esempio, l’URL)
  • placeholder: per mostrare un esempio di URL
  • pattern: per specificare il modello di un URL che è https://.*
  • required: per dare un input all’URL prima dell’invio
  • value: per visualizzare il vecchio URL

Il secondo campo di input ha un attributo value impostato su new_url. new_url è un URL breve generato dalla libreria pyshorteners dal file main.py (mostrato nella prossima sezione).

Il modulo di inserimento è rappresentato nella seguente schermata:

Schermata di un modulo web per l'accorciamento degli URL.
Un modulo web per l’accorciatore di URL.

Codice di abbreviazione URL con pyshorteners

Ora che abbiamo creato il modulo, possiamo aggiungervi alcune funzionalità utilizzando Python e pyshorteners.

Aggiungeremo il codice per trasformare l’URL lungo in uno breve ed eseguire l’applicazione web. Andiamo al file main.py creato in precedenza, inseriamo il seguente codice e salviamolo:

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()

Il codice precedente importa la libreria pyshorteners e i seguenti moduli dal framework Flask, tutti necessari per accorciare gli URL:

  • Flask: il framework Flask stesso, che è stato introdotto in precedenza.
  • render_template: un pacchetto per il rendering dei template utilizzato per generare l’output dei file HTML dalla cartella templates.
  • request: un oggetto del framework Flask che contiene tutti i dati che un utente invia dal frontend al backend come parte di una richiesta HTTP.

Quindi, creiamo una funzione chiamata home() che prende un URL inviato nel modulo e produce un URL breve. Il decoratore app.route() viene utilizzato per legare la funzione alla route URL specifica per l’esecuzione dell’applicazione e i metodi POST/GET gestiscono le richieste.

Nella funzione home() c’è un’istruzione condizionale if-else.

Per l’istruzione if, se request.method=="POST", una variabile chiamata url_received viene impostata su request.form["url"], che è l’URL inviato nel modulo. Qui, url è il nome del campo di input definito nel modulo HTML creato in precedenza.

Poi, una variabile chiamata short_url viene impostata su pyshorteners.Shortener().tinyurl.short(url_received).
In questo caso, vengono utilizzati due metodi della libreria pyshorteners: .Shortener() e .short(). La funzione .Shortener() crea un’istanza della classe pyshorteners e la funzione .short() riceve l’URL come argomento e lo accorcia.

La funzione short(), tinyurl.short(), è una delle numerose API della libreria pyshorteners. osdb.short() è un’altra API che può essere utilizzata per lo stesso scopo.

La funzione render_template() viene utilizzata per eseguire il rendering del file HTML template form.html e per inviare URL al form tramite argomenti. L’argomento new_url è impostato a short_url e old_url è impostato a url_received L’ambito dell’istruzione if termina qui.

Per l’istruzione else, se il metodo di richiesta è diverso da POST, verrà reso solo il modello HTML form.html.

Dimostrazione dell’app web per accorciare URL realizzata con la libreria pyshorteners

Per dimostrare l’applicazione accorciatore di URL di pyshorteners, dopo aver eseguito l’applicazione, andiamo alla route predefinita per l’applicazione, http://127.0.0.1:5000/.

Incolliamo un link a nostra scelta nel primo campo del modulo web:

Schermata dell'URL da abbreviare incollata nel modulo web.
Prova dell’accorciatore di URL con la libreria pyshorteners.

Clicchiamo sul pulsante Submit per visualizzare un URL breve con tinyurl come dominio nel campo URL generato:

Schermata che mostra l'URL abbreviato restituito nel modulo web.
Risultato dell’abbreviazione dell’URL con la libreria pyshorteners.

Usare il modulo API di Bitly per creare un’applicazione web per accorciare gli URL

In questa sezione svilupperemo un’applicazione per accorciare gli URL utilizzando l’API di Bitly. Come abbiamo detto, il modulo API di Bitly è un altro metodo per accorciare gli URL e fornisce anche analisi dettagliate sui clic, sulla posizione e sul tipo di dispositivo utilizzato (ad esempio desktop o mobile).

Installiamo l’API Bitly utilizzando il seguente comando:

pip install bitly-api-py3

Per utilizzare l’API di Bitly abbiamo bisogno di un token di accesso, che possiamo ottenere iscrivendoci a Bitly.

Dopo aver completato la procedura di registrazione, accediamo a Bitly per visualizzare la nostra dashboard:

Schermata della dashboard di Bitly.

Clicchiamo su Settings nella barra laterale di sinistra, poi clicchiamo sulla sezione API che si trova sotto Developer settings.

Generiamo un token di accesso inserendo la nostra password nel campo sopra il pulsante Generate token, come mostrato nell’immagine sottostante, e conserviamo il token da utilizzare nel codice dell’applicazione:

Screenshot of access token generation for the Bitly API/
Generare un token di accesso per l’API di Bitly.

Codice per accorciare gli URL utilizzando l’API di Bitly

Ora che abbiamo ottenuto il token da Bitly, possiamo creare il codice dell’applicazione web per accorciare l’URL utilizzando l’API di Bitly.

Utilizzeremo lo stesso modulo creato per la sezione pyshorteners ma con alcune modifiche al file 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()

Come possiamo vedere dal codice qui sopra, bitly_api viene importato utilizzando import bitly_api. Il token di accesso viene poi salvato in una variabile chiamata bity_access_token, come in bitly_access_token = "37b1xxxxxxxxxxxxxxxxxxxxxxxx".

La funzione home() accorcia l’URL e contiene una dichiarazione condizionale if-else.

Per quanto riguarda l’istruzione if, se il metodo o la richiesta è POST, allora l’URL inviato nel modulo viene impostato nella variabile url_received.

La funzione bitly_api.Connection(access_token=bitly_access_token) si collega all’API di Bitly e le passa come argomento il token di accesso che abbiamo salvato in precedenza.

Per accorciare l’URL, si utilizza la funzione bitly.shorten() passando la variabile url_received come argomento e salvandola in una variabile chiamata short_url.

Infine, il modulo creato viene renderizzato e gli URL vengono inviati per essere mostrati nel modulo utilizzando la funzione render_template(). L’istruzione if si conclude qui.

Per l’istruzione else, il modulo viene renderizzato utilizzando la funzione render_template().

Dimostrazione dell’app web per accorciare URL realizzata con l’API Bitly

Per dimostrare l’applicazione per accorciare URL dell’API Bitly, dopo aver eseguito l’applicazione, navighiamo nella route predefinita dell’applicazione, http://127.0.0.1:5000/.

Incolliamo un link a nostra scelta nel primo campo del modulo web:

Schermata del modulo web per l'accorciatore di URL Bitly API.
Prova dell’accorciatore di URL con l’API di Bitly.

Clicchiamo su Invia per generare un URL abbreviato con bit.ly come dominio nel secondo campo del modulo web:

Schermata dell'URL accorciato restituito dall'API di Bitly.
Risultato dell’abbreviazione dell’URL utilizzando l’API di Bitly.

Utilizzare l’API Bitly per accorciare gli URL nella nostra applicazione Python è semplicissimo.

Riepilogo

Gli accorciatori di URL permettono di avere URL brevi, facili da condividere, dall’aspetto più pulito e che occupano meno spazio. In questo articolo abbiamo imparato a conoscere gli accorciatori di URL e i loro vantaggi, nonché a creare un’applicazione web di accorciatori di URL con Python utilizzando pyshorteners e l’API Bitly. La libreria pyshorteners fornisce URL brevi, mentre l’API Bitly fornisce analisi dettagliate e URL brevi.

Dato che avete già creato un’applicazione fantastica, perché non passare al livello successivo e ospitarla sul servizio Hosting di Applicazioni Web di Kinsta? Per rendere operativa un’applicazione Python come questa sulla nostra piattaforma, date un’occhiata al nostro tutorial per l’avvio rapido di Flask.

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.