Tag: apache mod_rewrite

Apache mod_rewrite, esempi pratici

Un modo per approcciare l’utilizzo delle regole del mod_rewrite è quello di sperimentare semplici esempi pratici nel file .htaccess. Assicurati che il modulo mod_rewrite sia abilitato sul tuo server
Apache prima di provare questi esempi.

1. Abilitare mod_rewrite
e Configurare il File

Assicurati di includere queste righe all’inizio del file
.htaccess: 


RewriteEngine On

2. Reindirizzare una Pagina Specifica

Reindirizza una vecchia pagina a una nuova URL.


RewriteRule ^old-page.html$ /new-page.html [R=301,L]

  • Significato:

    • ^old-page.html$:
      Corrisponde alla richiesta per old-page.html.

    • /new-page.html:
      URL di destinazione.

    • [R=301,L]: Effettua un redirect
      permanente (301) e termina le altre regole.

3. Rimuovere "www" dall’URL

Forza la rimozione di www dai tuoi
URL. 


RewriteCond %{HTTP_HOST} ^www\.(.*)$ [NC]
RewriteRule ^(.*)$ https://%1/$1 [R=301,L]

  • Significato:

    • RewriteCond
      %{HTTP_HOST} ^www\.(.*)$: Corrisponde agli URL che iniziano
      con www.

    • %1:
      Cattura il dominio senza www.

    • [R=301,L]: Effettua un redirect
      permanente.

4. Aggiungere "www" all’URL

Forza l’aggiunta di www agli URL.


RewriteCond %{HTTP_HOST} !^www\. [NC]
RewriteRule ^(.*)$ https://www.%{HTTP_HOST}/$1 [R=301,L]

  • Significato:

    • RewriteCond
      %{HTTP_HOST} !^www\.: Corrisponde agli URL senza www.

    • %{HTTP_HOST}: Utilizza il
      dominio corrente.

5. Creare URL SEO-Friendly

Trasforma un URL con query string in un URL più leggibile.


RewriteRule ^product/([0-9]+)$ /product.php?id=$1 [L]

  • Esempio:

    • URL richiesto: /product/123

    • URL effettivo: /product.php?id=123

6. Reindirizzare Tutte le Richieste HTTPS

Forza tutte le richieste a utilizzare HTTPS.


RewriteCond %{HTTPS} !=on
RewriteRule ^(.*)$ https://%{HTTP_HOST}/$1 [R=301,L]

  • Significato:

    • RewriteCond
      %{HTTPS} !=on: Corrisponde alle richieste non HTTPS.

    • %{HTTP_HOST}: Inserisce il
      dominio corrente.

7. Reindirizzare una Directory Specifica

Reindirizza tutte le richieste a una directory verso una nuova
destinazione. 


RewriteRule ^old-directory/(.*)$ /new-directory/$1 [R=301,L]

  • Significato:

    • ^old-directory/(.*)$:
      Corrisponde a tutti i file all’interno di old-directory.

    • $1: Cattura il percorso del
      file e lo utilizza nella nuova directory.

8. Bloccare l’Accesso a una Specifica IP

Blocca l’accesso da un indirizzo IP specifico.


RewriteCond %{REMOTE_ADDR} ^192\.168\.1\.1$
RewriteRule ^ - [F]

  • Significato:

    • RewriteCond
      %{REMOTE_ADDR} ^192\.168\.1\.1$: Corrisponde all’indirizzo
      IP 192.168.1.1.

    • [F]: Restituisce un errore 403
      Forbidden.

9. Riscrivere la Homepage

Riscrivi una richiesta alla homepage per utilizzare un file
diverso. 


RewriteRule ^$ /index.php [L]

  • Significato:

    • ^$:
      Corrisponde alla radice del sito (homepage).

    • /index.php: Reindirizza tutte
      le richieste alla homepage al file index.php.

10. Riscrivere URL Statici a Dinamici

Trasforma un URL statico in uno dinamico.


RewriteRule ^blog/([a-zA-Z0-9-]+)/([0-9]+)$ /blog.php?slug=$1&id=$2 [L]

  • Esempio:

    • URL richiesto:
      /blog/my-article/123

    • URL effettivo: /blog.php?slug=my-article&id=123

11. Limitare l’Accesso a File Specifici

Blocca l’accesso diretto a file .ini
o .env. 


RewriteRule \.(ini|env)$ - [F]

  • Significato:

    • \.(ini|env)$:
      Corrisponde a file con estensione .ini
      o .env.

    • [F]: Restituisce un errore 403
      Forbidden.

12. Pagine di Errore Personalizzate

Reindirizza gli errori 404 a una pagina personalizzata.


RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^ /error-page.html [L]

  • Significato:

    • !
      indica "non esiste".

    • Reindirizza le richieste a /error-page.html.

Come Provare e Testare

  1. Crea il file .htaccess
    nella webroot del tuo sito    .

  2. Inserisci una delle regole sopra.

  3. Testa le regole nel browser o con uno strumento come curl:

    
curl -I http://localhost/old-page.html

  4. Controlla i log di Apache per verificare eventuali errori:

    
tail -f /var/log/apache2/error.log

Esaminiamo queste direttive nel file .htaccess 



   RewriteEngine On
   RewriteCond %{REQUEST_FILENAME} !-f
   RewriteCond %{REQUEST_FILENAME} !-d
   RewriteCond %{REQUEST_URI} !/contents
   RewriteRule ^(.*?)$ pagina2.php?url=$1 [L,QSA]

Questa configurazione del file .htaccess
utilizza il modulo mod_rewrite di Apache per
riscrivere gli URL in modo dinamico. Analizziamo ciascuna direttiva:

1. RewriteEngine On

  • Cosa fa:
    Attiva il modulo mod_rewrite
    per abilitare la riscrittura degli URL.

2. RewriteCond

Le direttive RewriteCond sono
condizioni che devono essere soddisfatte prima che venga applicata la
regola RewriteRule. Analizziamo ogni
condizione:

RewriteCond %{REQUEST_FILENAME} !-f

  • Significato:
    Verifica che il file
    richiesto non esista fisicamente nel filesystem.

    • %{REQUEST_FILENAME}
      rappresenta il percorso completo del file richiesto.

    • !-f
      significa "non è un file".

  • Effetto:
    La regola successiva verrà
    applicata solo se il file richiesto non esiste.

RewriteCond %{REQUEST_FILENAME} !-d

  • Significato:
    Verifica che la directory
    richiesta non esista fisicamente.

    • !-d
      significa "non è una directory".

  • Effetto:
    La regola successiva verrà
    applicata solo se la directory richiesta non esiste.

RewriteCond %{REQUEST_URI} !/contents

  • Significato:
    Verifica che l’URL
    richiesto non contenga la stringa /contents.

    • %{REQUEST_URI}
      rappresenta il percorso richiesto nell’URL.

  • Effetto:
    La regola successiva non si
    applica alle richieste che contengono /contents.

3. RewriteRule

Sintassi:


RewriteRule ^(.*?)$ pagina2.php?url=$1 [L,QSA]

  • Cosa fa:
    Applica una riscrittura
    dell’URL alle richieste che soddisfano tutte le condizioni sopra.

Componenti:

  1. ^(.*?)$

    • Questo è un’espressione regolare
      che corrisponde a qualsiasi stringa nell’URL.

    • (.*?)
      cattura tutto il percorso richiesto (escluso il dominio).

    • L’intera stringa catturata viene
      salvata in $1.

  2. pagina2.php?url=$1

    • L’URL richiesto viene riscritto in modo che punti al file
      pagina2.php con un parametro url
      che contiene la stringa catturata ($1).

    Esempio:

    • Richiesta: /some/path

    • Riscrittura:
      /pagina2.php?url=some/path

  3. Flag [L,QSA]:

    • [L]:
      Indica che questa è l’ultima regola da applicare (terminate le
      elaborazioni successive).

    • [QSA]:
      Aggiunge i parametri della query string originale (se presenti)
      all’URL riscritto.

    Esempio con query string:

    • Richiesta: /some/path?key=value

    • Riscrittura: /pagina2.php?url=some/path&key=value

Comportamento Complessivo

  1. La regola viene applicata solo se:

    • Il file richiesto non esiste.

    • La directory richiesta non
      esiste.

    • L’URL richiesto non
      contiene       /blog.

  2. Se tutte le condizioni sono soddisfatte, l’URL viene
    riscritto per puntare a pagina2.php,
    passando il percorso originale come parametro url.

Esempi Pratici

  1. URL richiesto: /blog/article

    • File /blog/article
      non esiste.

    • Directory /blog
      non esiste.

    • L’URL non contiene /admin,
      /contents, o /include.

    • Risultato:
      /pagina2.php?url=blog/article

  2. URL richiesto: /contents/uploads

    • L’URL contiene /contents.

    • Risultato: La
      riscrittura non viene applicata.

  3. URL richiesto: /contents/images

    • L’URL contiene /contents.

    • Risultato: La riscrittura non viene
      applicata.

Esaminiamo queste direttive nel file .htaccess 



   RewriteEngine On
   RewriteCond %{REQUEST_FILENAME} !-f RewriteRule ^(.*)([^/])$ /$1$2/
   [L,R=301]

Questa configurazione del file .htaccess
utilizza il modulo mod_rewrite di Apache per
aggiungere una barra finale agli URL che non puntano a file
esistenti. Analizziamo le direttive in dettaglio.

1. RewriteEngine On

  • Cosa fa:
    Attiva il modulo mod_rewrite,
    necessario per utilizzare le regole di riscrittura degli URL.

2. RewriteCond %{REQUEST_FILENAME} !-f

  • Cosa fa:
    Verifica che il percorso
    richiesto non sia un file esistente.

    • %{REQUEST_FILENAME}
      rappresenta il percorso del file richiesto sul filesystem.

    • !-f
      significa "non è un file".

  • Effetto:
    La regola successiva
    (RewriteRule) verrà applicata solo se
    il file specificato nella richiesta non esiste.

3. RewriteRule

Sintassi:


RewriteRule ^(.*)([^/])$ /$1$2/ [L,R=301]

  • Espressione Regolare:

    • ^(.*)([^/])$:

      • ^(.*):
        Corrisponde a qualsiasi stringa (zero o più caratteri) e la
        cattura in $1.

      • ([^/]): Corrisponde all’ultimo
        carattere del percorso purché non sia una barra (/)
        e lo cattura in $2.

    Esempio di Corrispondenza:

    • URL: /example

      • $1 =
        "example"

      • $2 = "e"

    • URL: /folder/page

      • $1 =
        "folder/pag"

      • $2 = "e"

    Non Corrisponde:

    • URL: /folder/
      (Perché
      termina già con una barra /).

  • Riscrittura dell’URL:
    /
    viene aggiunto alla fine dell’URL catturato. Il risultato finale è
    $1$2/.

    Esempio di Riscrittura:

    • Richiesta: /example

      • Riscrittura: /example/

    • Richiesta: /folder/page

      • Riscrittura: /folder/page/

4. Flag [L,R=301]

  • [L]:
    Indica
    che questa è l’ultima regola da eseguire per la richiesta corrente.

    • Apache non controlla ulteriori
      regole dopo questa.

  • [R=301]:
    Effettua
    un redirect permanente (codice HTTP 301) verso
    l’URL riscritto.

    • Il browser viene informato che l’URL è stato spostato in
      modo permanente.

    Nota: I redirect permanenti possono essere
    memorizzati nella cache dal browser.

Comportamento Complessivo

  1. Condizione:
    La regola si applica solo
    se il file richiesto non esiste fisicamente (!-f).

  2. Azione:
    Se l’URL richiesto non
    termina con una barra    , Apache aggiunge una barra finale (/)
    utilizzando un redirect permanente (301).

Esempi Pratici

Caso 1: File Esistente

  • URL richiesto: /index.html

    • Il file /index.html
      esiste.

    • Risultato: La regola non viene applicata.

Caso 2: URL senza Barra

  • URL richiesto: /example

    • Il file /example
      non esiste.

    • L’URL non termina con /.

    • Risultato: Redirect permanente a /example/.

Caso 3: URL con Barra Finale

  • URL richiesto: /example/

    • L’URL termina già con /.

    • Risultato: La regola non viene applicata.

Quando Utilizzare Questa Configurazione

  • Questa configurazione è utile per
    garantire uniformità negli URL, specialmente nei siti web che
    utilizzano percorsi senza estensioni di file (ad esempio, /about
    invece di /about.html).

  • Può migliorare l’indicizzazione SEO, poiché previene
    contenuti duplicati tra URL con e senza barra finale.

Esaminiamo queste direttive nel file .htaccess 



   RewriteEngine On
   RewriteRule ^pagina$
   pagina.php [L]

Questa direttiva di riscrittura nel file .htaccess
è molto semplice e serve a mappare un URL "pulito" a un
file PHP sul server. Analizziamola in dettaglio:

Direttiva RewriteRule

Sintassi:


RewriteRule ^pagina$ pagina.php [L]

  1. ^pagina$
    (Espressione Regolare)

    • ^:
      Indica l’inizio dell’URL richiesto.

    • pagina:
      Corrisponde esattamente alla stringa pagina.

    • $: Indica la
      fine dell’URL richiesto.

    Esempio di corrispondenza:

    • URL richiesto:
      https://example.com/pagina
      Corrisponde.

    • URL richiesto:
      https://example.com/pagina/
      Non
      corrisponde       (a meno che non venga configurata un’ulteriore
      regola per gestire il carattere /
      finale).

  2. pagina.php
    (Target della Riscrittura)

    • Specifica che le richieste corrispondenti devono essere
      riscritte verso il file pagina.php
      presente nella directory del server.

    Esempio di Riscrittura:

    • URL richiesto:
      https://example.com/pagina

      • Riscrittura interna:
        https://example.com/pagina.php

  3. Flag [L]
    (Last)

    • Significato:
      Indica che questa è
      l’ultima regola da applicare alla richiesta corrente.
      Una
      volta che questa regola viene applicata, Apache non eseguirà altre
      regole di riscrittura per lo stesso URL.

Comportamento Complessivo

  • L’utente può accedere a
    pagina.php utilizzando l’URL "pulito"
    https://example.com/pagina.

  • Internamente, il server Apache reindirizza la richiesta a
    pagina.php senza cambiare l’URL
    visibile al cliente (riscrittura trasparente).

Esempi Pratici

Caso 1: URL corrispondente

  • Richiesta originale:
    https://example.com/pagina

  • Riscrittura interna:
    https://example.com/pagina.php

Caso 2: URL non corrispondente

  • Richiesta originale:
    https://example.com/pagina/

  • Risultato:
    La regola non si applica,
    poiché l’URL termina con /, che non
    corrisponde a ^pagina$.

  • Soluzione alternativa:
    Aggiungere una
    regola separata per gestire il carattere /
    finale: 

    
RewriteRule ^pagina/?$ pagina.php [L]

Quando Utilizzare Questa Configurazione

  • Per migliorare la leggibilità e
    la semantica degli URL, nascondendo l’estensione del file (.php)
    agli utenti.

  • Per creare URL più "amichevoli"
    e semplici da ricordare.

  • Per uniformare gli URL in un sito web, ad esempio come parte
    di una strategia SEO.

la direttiva RewriteRule si
applica alla parte dell’url successiva al l hostname: ^pagina$
la direttiva RewriteRule
nel contesto di un file .htaccess si
applica alla parte dell’URL che segue il nome di dominio (hostname),
ma non include né il protocollo (http://
o https://) né il dominio stesso
(example.com).

Vediamo in dettaglio come funziona e come viene applicata la
regular expression (espressione regolare):

Scope della RewriteRule

  1. In .htaccess:

    • La regular expression nella RewriteRule
      corrisponde alla parte dell’URL relativa alla webroot.
      Ad
      esempio, se il file .htaccess si trova
      nella directory root del sito (/), la
      RewriteRule considera tutto ciò che segue il dominio.

      Esempio:

      • Richiesta:
        https://example.com/pagina

      • La RewriteRule si applica a:
        pagina.

    • Se il file .htaccess si trova
      in una sottodirectory, ad esempio /subdir,
      l’URL passato alla RewriteRule sarà
      relativo alla sottodirectory. Esempio:

      • Richiesta:
        https://example.com/subdir/pagina

      • La RewriteRule vede: pagina.

  2. In configurazioni globali di Apache (httpd.conf
    o     virtualhost):

    • La RewriteRule può essere configurata per considerare
      l’intero URL, inclusi hostname e percorso completo. In questi casi,
      può essere necessario specificare l’intero schema.

Applicazione delle Regular Expressions
nella RewriteRule

La sintassi della RewriteRule segue
le convenzioni delle espressioni regolari di base (regex), applicate
alla porzione di URL relativa:

1. Ancora di inizio (^)

  • Specifica che la regex deve
    corrispondere dall’inizio della stringa URL.

  • Esempio:

    
RewriteRule ^pagina$ pagina.php

    • URL corrispondente: /pagina

    • URL non corrispondente: /subdir/pagina

2. Ancora di fine ($)

  • Specifica che la regex deve
    corrispondere fino alla fine della stringa URL.

  • Esempio:

    
RewriteRule ^pagina$ pagina.php

    • URL corrispondente: /pagina

    • URL non corrispondente: /pagina/
      o /pagina123.

3. Corrispondenza parziale o completa

  • Se non usi ^
    o $, la regex può corrispondere a
    qualsiasi parte dell’URL.

  • Esempio:

    
RewriteRule pagina pagina.php

    • URL corrispondenti: /pagina,
      /subdir/pagina, /about/pagina.

Hostname nella RewriteRule

Il file .htaccess non può
direttamente modificare l’hostname. la direttiva RewriteRule nel contesto di un file .htaccess si applica alla parte dell’URL che segue l’hostname.

  • Cosa non puoi fare:

    
RewriteRule ^https://example.com/pagina pagina.php

    Questo non funzionerà perché l’hostname non è incluso nella parte
    gestita dalla RewriteRule in .htaccess.

Gestione degli hostname (VirtualHost o
RewriteCond)

Se vuoi gestire l’hostname, devi utilizzare la direttiva
RewriteCond (condizione di riscrittura):

  • Esempio:

    
RewriteCond %{HTTP_HOST} ^example\.com$
RewriteRule ^pagina$ pagina.php

    • RewriteCond
      %{HTTP_HOST}      : Controlla se
      l’hostname richiesto è example.com.

    • RewriteRule:
      Si applica solo se la condizione precedente è vera.

Come Verificare il Comportamento della
Regex

Puoi provare la tua regex con alcuni strumenti online:

  • Regex101:
    Per testare e comprendere come funzionano le regex.

  • Apache mod_rewrite Debugging: Abilita il log
    di riscrittura di Apache per vedere come vengono applicate le
    regole: 

    
LogLevel alert rewrite:trace3