Benvenuto/a su www.classicistranieri.com, la Biblioteca Multimediale Libera

SCEGLI LA SEZIONE CHE PREFERISCI:

Se questi contenuti ti sono stati utili, prendi in considerazione la possibilità di effettuare una libera donazione alla biblioteca, in modo che possano continuare a essere gratuiti per tutti.

Appunti di informatica libera

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]

Capitolo 174. Cache proxy

Nella terminologia utilizzata per le reti, una cache proxy è un servizio di memorizzazione locale delle risorse della rete richieste più frequentemente. Con il termine «risorsa» si deve intendere un oggetto a cui si accede attraverso un URI.

L'utilizzo di un proxy offre due vantaggi principali: l'accesso rapido a risorse già accumulate nella memoria cache e la riduzione del traffico nella rete che precede il proxy stesso.

Un programma che offre un servizio del genere, tende a utilizzare un gran numero di file aperti in modo contemporaneo, tanto che si può arrivare facilmente a superare il limite previsto dal kernel, cosa che comporta una riduzione delle prestazioni nella gestione della memoria cache. Nel caso particolare di un kernel Linux attuale, il limite per ogni singolo processo dovrebbe essere di 1 024 file aperti simultaneamente; limite che non può essere modificato se non si interviene direttamente nel sorgente, come spiegato nel file Documentation/proc.txt dei sorgenti.

174.1 Schema essenziale

Il proxy si interpone nella rete agendo, idealmente, al di sopra del quinto livello del modello ISO-OSI, come si vede nella figura 174.1. Infatti, il cliente di un proxy intrattiene normalmente una connessione HTTP o FTP; così il proxy deve intrattenere lo stesso tipo di connessione, per conto proprio, con il servente a cui il cliente avrebbe voluto rivolgersi realmente, a meno di ottenere tali risorse dalla sua memoria cache.

Figura 174.1. Il proxy trasferisce PDU al di sopra del quinto livello; in pratica gestisce direttamente i protocolli a livello di sessione.

.-------------------.                                   .-------------------.
| Applicazione      |     .----------------------.      | Applicazione      |
|-------------------|     |        PROXY         |      |-------------------|
| Presentazione     |     `----------------------'      | Presentazione     |
|-------------------|   .-----------.  .-----------.    |-------------------|
| Sessione          |   | Sessione  |  | Sessione  |    | Sessione          |
|-------------------|   |-----------|  |-----------|    |-------------------|
| Trasporto         |   | Trasporto |  | Trasporto |    | Trasporto         |
|-------------------|   |-----------|  |-----------|    |-------------------|
| Rete              |   |   Rete    |  |   Rete    |    | Rete              |
|-------------------|   |-----------|  |-----------|    |-------------------|
| Collegamento dati |   |  C. dati  |  |  C. dati  |    | Collegamento dati |
|-------------------|   |-----------|  |-----------|    |-------------------|
| Fisico            |   |  Fisico   |  |  Fisico   |    | Fisico            |
`-------------------'   `-----------'  `-----------'    `-------------------'
         |                   |                |                   |
         `-------------------'                `-------------------'

Il servizio di cache proxy può essere collocato in posizioni differenti nella rete, a seconda delle esigenze o delle particolarità delle situazioni. Generalmente, lo scopo è quello di servire un segmento di rete, indifferentemente dal fatto che questo segmento utilizzi indirizzi privati o sia accessibile dall'esterno.

174.1.1 Servire un segmento di rete

Quando un proxy viene utilizzato per servire un segmento di rete rispetto alla rete esterna, senza fare altre considerazioni, è sufficiente che l'elaboratore su cui viene collocato il servizio sia accessibile da questo segmento di rete e che a sua volta sia in grado di accedere all'esterno.

Figura 174.2. In questa situazione, il servente proxy è collegato come tutti gli altri elaboratori al segmento di rete da servire.

Rete esterna <--------------.
                            |
                            |            segmento di rete da servire
- - - -*-------------*------*------*-------------*---- - - -
       |             |             |             |
  .---------.   .---------.   .---------.   .----------.
  | cliente |   | cliente |   | cliente |   | SERVENTE |
  |  proxy  |   |  proxy  |   |  proxy  |   |   proxy  |
  `---------'   `---------'   `---------'   `----------'

A questa situazione appartiene anche il caso limite in cui il proxy serve solo se stesso, quindi la stessa macchina è servente e anche cliente.

174.1.2 Proxy a più livelli

Un proxy potrebbe servirsi di altri proxy quando si tratta di accedere a reti determinate, alleggerendo in questo modo il carico della rete anche in altri punti, non solo nel tratto immediatamente precedente.

Figura 174.3. Ogni collegamento ha un proprio proxy locale che però si avvale di un proxy principale prima di raggiungere la rete esterna.

Rete esterna <-------//---.
                    (A)   |
                          |        .----------.
                          |        | SERVENTE |
      .------------.      |        |   proxy  |   .---------.
      |  SERVENTE  |      |        |  locale  |   | cliente | ...
      |   proxy    |------*        `----------'   `---------'
      | principale |      |  (B)        |              |                 
      `------------'      *---//--------*--------------*----------------- - - -
                          |                                segmento di rete
                          |
                          // (C)
                          |
                          |            segmento di rete
- - - -*-------------*----*--------*-------------*---- - - 
       |             |             |             |
  .---------.   .---------.   .---------.   .----------.
  | cliente |   | cliente |   | cliente |   | SERVENTE |
  `---------'   `---------'   `---------'   |   proxy  |
                                            |  locale  |
                                            `----------'

La figura 174.3 mostra il caso di un collegamento a una rete esterna, (A), condiviso da due segmenti di rete, che si collegano a questa attraverso i collegamenti B e C. A valle del collegamento A si trova un proxy il cui scopo è quello di ridurre il più possibile il traffico attraverso quel tratto; a valle dei collegamenti B e C si trovano altri proxy locali il cui scopo è quello di ridurre il traffico attraverso i collegamenti rispettivi. In questa situazione, i proxy locali utilizzano a loro volta il servente principale, mentre tutto quello che viene accumulato nei proxy locali, viene conservato anche in quello principale.

174.1.3 Proxy come filtro verso l'esterno

Il servente proxy, se si trova in un elaboratore che è connesso simultaneamente, attraverso interfacce di rete differenti, a una rete interna con indirizzi privati (cioè esclusi da Internet) e alla rete esterna, può essere utilizzato per permettere ai clienti della rete privata di avere accesso all'esterno attraverso il proxy stesso.

Questo accesso si limita ai protocolli gestiti dal proxy; spesso si tratta solo di HTTP e FTP.

Figura 174.4. Come caso estremo, il proxy può ricoprire anche un ruolo di filtro e inoltro di pacchetti tra una rete privata e la rete esterna.

Rete esterna <-------//---.
                          |
                    .------------.
                    |  SERVENTE  |
                    |   proxy    |
                    |   filtro   |
                    `------------'
                          |
                          |    rete con indirizzi IP privati
- - - -*-------------*----*--------*-------------*---- - - -
       |             |             |             |
  .---------.   .---------.   .---------.   .---------.
  | cliente |   | cliente |   | cliente |   | cliente |
  `---------'   `---------'   `---------'   `---------'

174.2 Dal lato del cliente

I clienti per la navigazione, vanno configurati per poter sfruttare il servizio della cache proxy. Per esempio, la figura 174.5 mostra la finestra di configurazione di un navigatore comune.

Figura 174.5. Esempio di configurazione di un navigatore comune per l'utilizzo della cache proxy. Si osservi il fatto che per usare la porta 8 080 occorre che il servente sia in ascolto sulla stessa.

figure/a2-web-client-conf-cache-proxy

È interessante anche la configurazione di Lynx per l'utilizzo di un servizio di cache proxy. È sufficiente definire alcune variabili di ambiente, come elencato nella tabella 174.1. Per esempio, per utilizzare il protocollo HTTP attraverso il proxy http://proxy.brot.dg nella porta 8 080, si potrebbe agire come si vede qui:

$ http_proxy="http://proxy.brot.dg:8080"[Invio]

$ export http_proxy[Invio]

$ lynx http://www.indirizzo.remoto"[Invio]

Tabella 174.1. Elenco delle variabili di ambiente per la configurazione dell'accesso a un proxy da parte di Lynx.

Variabile	Descrizione
http_proxy	Proxy per il protocollo HTTP.
ftp_proxy	Proxy per il protocollo FTP.
gopher_proxy	Proxy per il protocollo Gopher.
wais_proxy	Proxy per il protocollo WAIS.

Anche Links prevede una configurazione per l'utilizzo di proxy; si tratta di opzioni della riga di comando o di direttive di file di configurazione:

Opzione	Direttiva	Descrizione
`-ftp-proxy "nodo:n_porta"`	`ftp_proxy "nodo:n_porta"`	Proxy per il protocollo FTP.
`-http-proxy "nodo:n_porta"`	`http_proxy "nodo:n_porta"`	Proxy per il protocollo HTTP.

I programmi di navigazione offrono anche la possibilità di richiedere al proxy di prelevare una nuova copia della pagina, anche se non sono scaduti i tempi previsti. Nel caso di programmi grafici si tratta normalmente di selezionare pulsanti grafici del tipo <Reload>, <Ricarica> o simili. Per quanto riguarda il caso particolare di Lynx, si può usare l'opzione -reload, mentre con Links si può usare la combinazione di tasti [Ctrl+r].

Il proxy risponde alle richieste dei programmi clienti attraverso una porta particolare, che dipende dalla configurazione del servizio. Apparentemente, ogni tipo di proxy ha una sua impostazione predefinita differente, mentre la tendenza generale è quella di utilizzare la porta 8 080. È necessario fare attenzione a questo particolare quando si configura il proxy, per non creare confusione inutile agli utenti del servizio.

Se si vuole sfruttare un proxy nel modo indicato nella sezione 174.1.3, si possono usare solo programmi che prevedono espressamente la presenza di questo, attraverso i protocolli serviti effettivamente dal proxy stesso.

174.3 Caratteristiche comuni ai cache proxy da considerare

Prima di affrontare lo studio di un tipo particolare di cache proxy, vale la pena di riordinare le idee sulle esigenze tipiche di un servizio del genere, che poi si riflettono conseguentemente nella configurazione relativa. In breve i problemi riguardano essenzialmente i punti seguenti:

amministrazione della memoria cache
- collocazione dei file utilizzati dalla memoria cache
- utente e gruppo proprietari di questi file
- dimensione massima della memoria cache
- dimensione massima di una singola risorsa accumulabile
- scadenza massima per la validità delle informazioni accumulate nella memoria cache
- Indirizzi esclusi dall'accumulo nella memoria (solitamente quelli che contengono le stringhe ? e cgi-bin, perché riguardano probabilmente delle interazioni con programmi CGI)
utenze
- individuazione degli indirizzi che possono accedere per utilizzare il servizio
- utente fittizio mostrato all'esterno (di solito per l'accesso a un servizio FTP anonimo)
connessione
- porta o porte attraverso cui resta in ascolto per le richieste di connessione (di solito si usa la porta 8 080)
- indirizzi e porte di altri servizi del genere da interpellare se disponibili (per non sovraccaricare la rete)

174.4 Apache

Il servente HTTP Apache incorpora delle funzionalità di proxy elementare. In queste sezioni viene valutato solo ciò che è necessario fare per configurare il servizio attraverso il file httpd.conf (collocato normalmente nella directory /etc/apache/). Per il resto che riguarda Apache conviene consultare i capitoli 158 e 159.

In generale, Apache non è il software migliore per svolgere anche questo compito. Se possibile è meglio usare Squid.

Per poter utilizzare la funzionalità di cache proxy di Apache è necessario attivare il modulo relativo, a meno che questo sia stato incorporato nell'eseguibile principale in base alla configurazione stabilita al momento della compilazione. Questa attivazione si fa con la direttiva seguente nel file httpd.conf:

LoadModule proxy_module directory/libproxy.so

La direttiva in questione dovrebbe essere già stata predisposta, commentata in modo da non essere presa in considerazione. In tal modo non ci si deve preoccupare di trovare la directory giusta per la libreria indicata.

174.4.1 Attivazione e collocazione

La configurazione predefinita di Apache non prevede la gestione del proxy. Di solito sono presenti alcune direttive di esempio, debitamente commentate, in modo da facilitare il lavoro dell'amministratore.

ProxyRequests {on|off}

La direttiva ProxyRequests permette di attivare o meno la gestione della cache proxy. L'esempio seguente mostra la sua attivazione.
ProxyRequests on
CacheRoot directory_cache

La direttiva CacheRoot permette di definire la directory da utilizzare per contenere la memoria cache. La directory in questione deve risultare accessibile in scrittura all'utente e gruppo specificati con le direttive User e Group (potrebbe trattarsi di nobody, www-data o qualcosa di simile).
CacheRoot /var/cache/httpd/proxy

174.4.2 Caratteristiche della memoria cache

CacheSize n_Kibyte

La direttiva CacheSize specifica la dimensione in kibibyte (simbolo: Kibyte) dello spazio su disco da utilizzare per la memoria cache. Questo valore può essere superato, ma periodicamente viene eseguito un controllo con l'eliminazione dei file più vecchi che eccedono tale limite. L'esempio mostra la dichiarazione di una memoria cache di 500 000 Kibyte.
CacheSize 500000
CacheGcInterval n_ore

In questo modo può essere definito l'intervallo tra una ripulitura e l'altra della memoria cache, alla ricerca di file troppo vecchi e di quelli che eccedono il limite di dimensione stabilita. L'esempio mostra la dichiarazione di un intervallo di controllo orario (una sola ora).
CacheGcInterval 1
CacheMaxExpire n_ore

I documenti HTTP vengono conservati per un massimo di ore stabilito con questa direttiva. Superato tale tempo, alla richiesta di un cliente, viene fatta una verifica dall'origine. Questo limite di tempo è imposto anche se il documento originale indica una data di scadenza superiore. L'esempio mostra una scadenza massima di 24 ore.
CacheMaxExpire 24
CacheDefaultExpire n_ore

Quando il tipo di protocollo non prevede l'indicazione di una scadenza, si utilizza il tempo indicato attraverso la direttiva CacheDefaultExpire.
CacheLastModifiedFactor fattore

Questa direttiva definisce un «fattore» utilizzato per calcolare un tempo di scadenza quando il documento originale non lo fornisce. In pratica si applica la formula x=t*f, dove f è il fattore, t è il tempo trascorso dall'ultima modifica, e x è il tempo di scadenza (il periodo di validità).

La logica sta nel fatto che è più probabile che una pagina venga modificata ancora entro breve tempo se la sua data di modifica è recente. Infatti, minore è il tempo trascorso dall'ultima modifica, minore sarà la durata di validità risultante dalla formula. L'esempio mostra un fattore di 0,1, pari al 10 % del tempo trascorso dall'ultima modifica.
CacheLastModifiedFactor 0.1

174.4.3 Esclusione dalla memoria cache

Ci sono situazioni in cui non è opportuno che il proxy accumuli nella sua memoria cache informazioni riferite a determinati domini o sottoreti. Di sicuro non è conveniente farlo per la propria rete locale, a meno che non ci siano delle buone ragioni.

NoCache {dominio|parola}...

Per escludere alcuni nodi o domini interi dalla memoria cache basta elencare i nomi, separati da uno spazio, con la direttiva NoCache. In generale verranno esclusi tutti gli indirizzi che contengono in qualche modo le «parole» indicate, per cui continuano a essere presi in considerazione gli indirizzi IP equivalenti.
NoCache roggen.brot.dg mehl.dg
L'esempio esclude dalla memoria cache il nodo roggen.brot.dg e il dominio mehl.dg.
NoProxy {nome|dominio|indirizzo-ip|sottorete}...

Questa direttiva consente di dichiarare in modo più preciso cosa escludere dalla cache rispetto alla direttiva simile NoCache. L'esempio seguente esclude tutto il dominio escluso.dg:
NoProxy escluso.dg

174.4.4 In pratica

Per attivare effettivamente il servizio, oltre alla configurazione del file httpd.conf, occorre predisporre la directory utilizzata per la memoria cache. Questa deve essere accessibile in scrittura da httpd, nelle condizioni in cui si trova normalmente; in altri termini, deve essere accessibile all'utente secondo la cui identità è in funzione il demone. In generale potrebbe trattarsi di nobody, di www-data o di qualcosa di simile.

L'esempio seguente mostra le direttive del file httpd.conf per una configurazione tipica. Ciò che può valere la pena di modificare è la dimensione della memoria cache.

ProxyRequests On

CacheRoot /var/cache/httpd/proxy
CacheSize 500000
CacheGcInterval 1
CacheMaxExpire 24
CacheLastModifiedFactor 0.1
CacheDefaultExpire 1
Listen 80
Listen 8080

L'esempio mostra in particolare la direttiva Listen, usata per fare in modo che httpd stia in ascolto sia della porta 80 che della porta 8 080. Infatti, la porta 8 080 è quella utilizzata convenzionalmente dai clienti per interpellare un servente proxy, mentre la porta 80 serve a consentire l'accesso normale al servizio HTTP.

174.4.5 Protezione contro l'utilizzo indesiderato

In generale, un servizio proxy dovrebbe essere accessibile solo dalla rete (o sottorete) per la quale è stato attivato. Qualunque altro utente non ne potrebbe trarre vantaggio, mentre un utilizzo improprio servirebbe solo a intasare inutilmente il collegamento che invece si vuole alleggerire.

Per la protezione del servizio di cache proxy si può utilizzare una sezione Directory nel file access.conf, come nell'esempio seguente:

<Directory proxy:*>
        order deny,allow
        deny from all
        allow from .brot.dg
</Directory>

In questo caso si concede solo al dominio brot.dg di accedere.

174.5 Squid

Squid ⁽¹⁾ è un programma specifico, molto potente, per la gestione di una cache proxy. Tuttavia, il suo difetto è la carenza di documentazione.

174.5.1 Avvio

squid [opzioni]

Squid viene avviato normalmente attraverso la procedura di inizializzazione del sistema, in uno script, attraverso un comando che lo mette esplicitamente sullo sfondo, per esempio come nel modo seguente:

# squid &

Le prime volte, l'avvio di Squid può riservare delle sorprese. È importante sapere che all'avvio Squid tenta di risolvere l'indirizzo di alcuni nodi, attraverso il DNS. Nella maggior parte dei casi, se Squid viene avviato in una rete chiusa, il servizio non parte perché questa richiesta fallisce.

Pertanto, se si avvia Squid quando si è isolati dall'esterno, occorre evitare che venga eseguito il controllo; per questo si utilizza l'opzione -D della riga di comando.

Le distribuzioni GNU/Linux che prevedono Squid tra i pacchetti standard, dovrebbero avere organizzato uno script per il suo avvio automatico attraverso la procedura di inizializzazione del sistema; come già accennato. Se si intende avviare Squid quando non è presente uno sbocco verso Internet, potrebbe essere necessario modificare tale script in modo da inserire l'opzione -D, se questa non è già presente. Nel caso della distribuzione Red Hat, questo script si trova nella directory /etc/rc.d/init.d/, mentre nel caso di Debian, si tratta della directory /etc/init.d/.

squid -D &

Per verificare che Squid funzioni correttamente, può essere sufficiente osservare l'albero dei processi attivi attraverso pstree. Si dovrebbe ottenere qualcosa come il pezzo seguente:

squid---squid-+-5[dnsserver] \|-pinger `-squid---16[squid]

Come si può osservare, il binario squid pilota altri programmi che fanno parte dello stesso pacchetto.

Le opzioni, quando si riferiscono a elementi che possono essere definiti attraverso il file di configurazione, prendono il sopravvento su questa.

Opzione	Descrizione
`-a n_porta`	Permette di specificare il numero della porta attraverso la quale i clienti devono connettersi per accedere al servizio. Il valore predefinito, salvo altra indicazione nel file di configurazione, è 3 128.
`-f file_di_configurazione`	Permette di definire un file di configurazione alternativo a `/etc/squid.conf`.
`-k {reconfigure\|rotate`_<-' ^`->`\|shutdown\|interrupt`_<-' ^`->`\|kill\|debug\|check}`	Permette di inviare un segnale al servente Squid attivo. La parola chiave utilizzata come argomento dell'opzione determina l'effetto che si ottiene. In particolare vanno considerate quelle seguenti.
`-k reconfigure`	Fa in modo che venga riletta la configurazione.
`-k rotate`	Ruota i file delle registrazioni contenuti nella directory `/var/log/squid/`.
`-k shutdown`	Chiude correttamente l'attività di Squid.
`-k check`	Verifica il funzionamento di Squid, controllando in particolare la correttezza formale del file di configurazione.
`-s`	Abilita l'inserimento di informazioni nel registro del sistema.
`-u porta_icp`	Specifica la porta ICP, cioè quella utilizzata per comunicare con gli altri proxy.
`-z`	Svuota la memoria cache.
`-D`	Disabilita il controllo iniziale del DNS, attraverso il tentativo di risoluzione di alcuni indirizzi.
`-F`	Ricostruisce il sistema di directory in cui si articola quella che deve contenere la memoria cache. Di solito, si utilizza assieme a `-z`, per essere sicuri che vengano cancellate eventuali tracce precedenti.

# squid -z -F

Avvia squid in primo piano per azzerare e rigenerare le directory che compongono la memoria cache.
# squid -D &

Avvia squid sullo sfondo, in modo da attivare il servizio di proxy, senza però eseguire il controllo DNS.
# squid -k check

Verifica il funzionamento di Squid, in particolare anche la correttezza della configurazione attraverso il file /etc/squid.conf.
# squid -k shutdown

Invia un segnale di spegnimento al servente Squid già attivo.

174.5.2 RunCache

RunCache è uno script aggiuntivo usato per avviare Squid e per controllare che non «muoia» accidentalmente. In pratica, serve a garantirne il funzionamento. Vale la pena di citarne la sua esistenza, anche se non è necessario il suo utilizzo, perché può capitare che la distribuzione GNU/Linux di cui si dispone sia organizzata in modo da avviare Squid attraverso questo meccanismo. Lo script potrebbe trovarsi nella directory /usr/lib/squid/.

174.5.3 Registrazione degli eventi

Squid utilizza file specifici per la registrazione degli eventi, anche quando si utilizza l'opzione -s per inviare informazioni al registro del sistema. Questi file si trovano nella directory /var/log/squid/. Quando si invia al servente il segnale rotate (attraverso l'opzione -k), si ottiene l'archiviazione dei file, aggiungendo loro un'estensione numerica che ne indica il livello. Per esempio, cache.log.0 rappresenta l'archivio più recente di cache.log.

174.5.4 Configurazione

La configurazione di Squid avviene attraverso il file /etc/squid.conf, o un altro file se viene usata l'opzione -f. Questo file è già configurato in modo da permettere a Squid di funzionare in quasi tutte le situazioni, tuttavia sarebbe bene ritoccare qualcosa; per esempio il numero di porta del servizio e il dominio o il gruppo di indirizzi a cui concedere di poterlo utilizzare.

La sintassi del file è molto semplice: ciò che è preceduto dal simbolo #, viene trattato come un commento fino alla fine della riga; le righe bianche e le righe vuote sono ignorate; il resto sono le direttive, composte nel modo seguente:

direttiva [argomenti]

Direttiva	Descrizione
`http_port n_porta...`	Permette di modificare la porta predefinita per l'ascolto delle richieste dei clienti. La porta predefinita è 3 128. La porta predefinita, oppure quella che viene indicata in questo modo nel file di configurazione, può essere modificata ulteriormente attraverso l'opzione `-a`, che prende il sopravvento su tutto. Come si vede dal modello sintattico, si può indicare anche più di una porta.
`icp_port n_porta`	Definisce il numero di porta attraverso cui Squid riceve e invia le richieste ICP da e verso i cache proxy prossimi. Il valore predefinito è 3 130.
`cache_peer nodo tipo porta_proxy porta_icp [opzioni]`	Permette di definire l'indirizzo e le caratteristiche di un altro proxy. Il tipo e le opzioni sono rappresentati da diverse parole chiave che permettono di regolare situazioni diverse, ma non ben descritte nella poca documentazione. In generale, dovrebbe andare bene una forma semplificata come quella seguente:
`cache_peer nodo parent porta_proxy porta_icp`	Il numero di porta proxy è lo stesso usato dai clienti per connettersi a quel servente. Trattandosi di Squid potrebbe essere il numero 3 128, ma se questo valore è stato modificato nella configurazione di quel servente, occorre ricordarsene anche qui. Il numero della porta ICP è solitamente 3 130 (sempre se si tratta di Squid).
`hierarchy_stoplist parola...`	Permette di indicare un elenco di parole (stringhe) che potrebbero essere contenute in un URI. In presenza di tali URI, non vengono interpellati i proxy vicini. Questa direttiva viene proposta nel file di configurazione predefinito nella forma `hierarchy_stoplist cgi-bin ?`, per escludere tutti gli URI che potrebbero essere riferiti a programmi CGI.
`no_cache deny nome_acl...`	Permette di indicare una serie di casi in cui, gli oggetti riferiti a URI identificati dai nomi posti come argomento non vengono salvati nella memoria cache. Questa direttiva si affianca a `hierarchy_stoplist`, tanto che solitamente vengono usate entrambe con gli stessi argomenti. I nomi indicati come argomenti di questo comando sono definiti attraverso la direttiva `acl` (Access list). Generalmente si utilizzano le due direttive seguenti per impedire la memorizzazione di oggetti che contengono nel percorso dell'URI le stringhe `cgi-bin` e `?`: `acl INTERROGAZIONE urlpath_regex cgi-bin \?` `no_cache deny INTERROGAZIONE`
`cache_mem memoria_ram`	Definisce la quantità di memoria RAM ideale (espressa in mebibyte, corrispondente al simbolo Mibyte) che deve essere riservata per la parte di memoria cache utilizzata più frequentemente. Questa direttiva non definisce il valore massimo; dà solo un'indicazione a Squid, il quale ne può utilizzare in pratica molta di più. Il valore predefinito è di 8 Mibyte.
`maximum_object_size dimensione unità_di_misura`	Permette di definire la dimensione massima, espressa secondo l'unità di misura indicata, di ogni oggetto che viene conservato nella memoria cache. Gli oggetti di dimensione maggiore, non vengono accumulati. Le sigle che si possono usare sono: `KB` per indicare kibibyte (simbolo: Kibyte) e `MB` per indicare mebibyte (simbolo: Mibyte).
`cache_dir directory_cache [dimensione primo_livello` _<-' ^`->`secondo_livello]`	Permette di dichiarare una directory da utilizzare per la conservazione della memoria cache (ne possono essere dichiarate anche più di una). La dimensione è un numero che esprime una quantità in mebibyte (simbolo: Mibyte); il primo e il secondo livello sono la quantità di directory e sottodirectory in cui deve articolarsi la memoria cache. Se non viene specificata alcuna direttiva `cache_dir`, ne viene definita una in modo predefinito, che dovrebbe corrispondere a `/var/spool/squid/`.
`cache_access_log registro_degli_accessi`	Permette di definire il percorso assoluto del file utilizzato per accumulare le registrazioni degli accessi. Di solito si tratta di `/var/log/squid/access.log`.
`cache_store_log registro_dell'accumulo`	Permette di definire il percorso assoluto del file utilizzato per accumulare le registrazioni delle operazioni di accumulo e di eliminazione di oggetti della memoria cache. Di solito si tratta di `/var/log/squid/store.log`.
`cache_log registro_della_cache`	Accumula informazioni diagnostiche in base al livello stabilito attraverso la direttiva `debug_options`.
`debug_options sezione,livello`	Permette di definire il tipo e la quantità di informazioni diagnostiche da annotare. In generale, si utilizza l'argomento `ALL,1`, dove il numero uno rappresenta il livello minimo, che potrebbe arrivare a un massimo di nove.
`acl nome tipo stringa` `acl nome tipo "file"`	Questa direttiva permette di definire un nome attraverso cui identificare un «controllo di accesso». La cosa si può articolare in modo molto complesso e inizialmente è meglio concentrarsi su alcuni tipi di utilizzo.
`acl nome src indirizzo_ip/maschera_ip`	Il tipo `src` permette di identificare un gruppo di indirizzi IP, attraverso la coppia `indirizzo`/`maschera`. A questo gruppo viene attribuito un nome che può essere usato con la direttiva `http_access`, per controllare l'accesso da parte di quel gruppo di indirizzi.
`http_access {deny\|allow} [!]nome...`	Permette o vieta l'accesso al servizio da parte dei clienti identificati attraverso i nomi indicati come argomento; nomi che si riferiscono a quanto dichiarato con la direttiva `acl`. La parola chiave `deny` vieta l'accesso, mentre `allow` lo consente. Se un nome viene indicato preceduto immediatamente da un punto esclamativo, allora si intende esprimere il gruppo corrispondente a tutto ciò che non rientra nella classificazione di quel nome. Nella configurazione standard di Squid si concede a qualunque indirizzo di utilizzare il servizio di proxy, mentre sarebbe opportuno fare in modo che questo fosse accessibile solo al segmento di rete per il quale viene attivato.
`cache_effective_users utente gruppo`	Permette di definire per nome l'utente e il gruppo che vengono utilizzati dal processo che gestisce i file della memoria cache. Di conseguenza, tali file saranno di proprietà di questo utente e gruppo. Di solito si tratta di `nobody` e del gruppo relativo; in alternativa, viene usato anche l'utente e il gruppo `proxy`.
`dns_testnames nome...`	Permette di indicare i nomi di nodi da verificare attraverso un'interrogazione DNS prima di attivare il servizio. Per disattivare questo comportamento, si utilizza l'opzione `-D`.

Segue la descrizione di alcuni esempi.

http_port 8080
Definisce la porta 8 080 per l'accesso al servizio.
http_port 3128 8080
Definisce sia la porta 3 128, sia la porta 8 080 per l'accesso al servizio.
icp_port 3130
Definisce la porta 3 130 per le comunicazioni ICP con i cache proxy vicini.
cache_peer 192.168.77.7 parent 8080 3130
Indica un nodo da trattare come «vicino» ai fini della funzione di cache proxy (potrebbe essere la cache proxy del proprio ISP). In questo caso viene indicato il numero IP 192.168.7.7, a cui si accede attraverso la porta 8 080 e si comunicano i messaggi ICP tramite la porta 3 130.
cache_mem 4
Riduce a 4 Mibyte la dimensione ottimale per la RAM utilizzata come memoria cache (altrimenti verrebbero usati 8 Mibyte in modo predefinito).
cache_dir /var/spool/squid 200 16 256
Indica la directory da usare per lo scambio su disco, specificando che possono essere usati al massimo 200 Mibyte, strutturando la directory in 16 livelli che si suddividono ulteriormente in 256 sottolivelli.
maximum_object_size 2048 KB
Riduce a 2 Mibyte la dimensione massima degli oggetti accumulati nella memoria cache (altrimenti questa sarebbe di 4 Mibyte in modo predefinito).

#Defaults:
acl all src 0.0.0.0/0.0.0.0
acl manager proto cache_object
acl localhost src 127.0.0.1/255.255.255.255
acl SSL_ports port 443 563
acl Safe_ports port 80 21 443 563 70 210 1025-65535
acl purge method PURGE
acl CONNECT method CONNECT

Quelle che si vedono nell'esempio sono le direttive acl che appaiono nel file /etc/squid.conf standard. In generale conviene lasciarle come sono. Vengono riportate qui per permettere la comprensione degli esempi che verranno mostrati successivamente.

#Default configuration:
http_access allow manager localhost
http_access deny manager
http_access allow purge localhost
http_access deny purge
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports

Anche queste direttive sono standard, concedendo poche funzionalità solo agli accessi locali.

acl localnet src 192.168.0.0/255.255.0.0
http_access allow localnet
http_access allow localhost
http_access deny all

icp_access allow localnet
icp_access allow localhost
icp_access deny all

miss_access allow localnet
miss_access allow localhost
miss_access deny all

Dopo le direttive standard già mostrate in precedenza, questo dovrebbe essere il modo più conveniente di intervenire per limitare l'accesso al servizio, avendo definito il nome localnet per individuare la rete locale a cui concedere l'accesso (in questo caso 192.168.0.0/16), oltre all'elaboratore locale stesso.

Si può osservare in particolare che il nome all viene usato per impedire gli accessi da parte di nodi che non ricadano nel gruppo fissato dal nome localnet o dal nome localhost.

Squid può essere configurato in modo da impedire il prelievo di file con estensione particolare; per esempio per evitare che si possano scaricare file musicali, o semplicemente archivi compressi di qualunque genere, nel timore che questo possa comportare la violazione del diritto di autore. Inoltre, si può realizzare un elenco di indirizzi a cui impedire l'accesso, per qualunque ragione morale o legale. A questo proposito, viene mostrato un esempio completo della configurazione di Squid, in cui si annullano le funzionalità di accumulo nella memoria cache, concentrando l'attenzione sulle possibilità di filtro:


# Indica la porta da cui ricevere le richieste da parte dei clienti.

http_port 8080


# Individua i percorsi da non prendere in considerazione per la memoria
# cache (standard).

hierarchy_stoplist cgi-bin ?
acl QUERY urlpath_regex .*
no_cache deny QUERY


# Viene annullata la memoria cache.

cache_mem 0 MB
maximum_object_size 0 KB


# Non utilizza il proprio sistema di accumulo dei nomi ottenuti dal DNS.

negative_dns_ttl 0 minutes


# Definisce alcune direttive ACL per individuare dei file in base
# all'estensione. In seguito, le richieste che coincidono con queste
# direttive ACL verranno bloccate.

acl ban_mp3     url_regex -i \.mp3$
acl ban_ogg     url_regex -i \.ogg$
acl ban_mpeg    url_regex -i \.mpeg$
acl ban_mpg     url_regex -i \.mpg$
acl ban_tar_gz  url_regex -i \.tar\.gz$
acl ban_zip     url_regex -i \.zip$
acl ban_exe     url_regex -i \.exe$
acl ban_vfw     url_regex -i \.vfw$
acl ban_avi     url_regex -i \.avi$
acl ban_asx     url_regex -i \.asx$
acl ban_qt      url_regex -i \.qt$
acl ban_ram     url_regex -i \.ram$
acl ban_rm      url_regex -i \.rm$


# Definisce una direttiva ACL per individuare una serie di
# indirizzi (URI), completi o parziali, a cui successivamente
# si vuole bloccare l'accesso. Il file /etc/squid-banlist è un
# file di testo puro contenente questo elenco di indirizzi.

acl banlist   url_regex "/etc/squid-banlist"


# Definisce delle direttive ACL per individuare gli accessi in base
# agli indirizzi IPv4 di origine e in base alla funzione amministrativa
# (standard, a parte la definizione delle reti locali).

acl all src 0.0.0.0/0.0.0.0
acl manager proto cache_object
acl localhost src 127.0.0.1/255.255.255.255
acl localnets src 10.0.0.0/255.0.0.0
acl localnets src 172.16.0.0/255.240.0.0
acl localnets src 192.168.0.0/255.255.0.0


# Definisce delle direttive ACL per individuare gli accessi in base
# alla porta TCP di destinazione (standard).

acl SSL_ports port 443 563

acl Safe_ports port 80          # http
acl Safe_ports port 21          # ftp
acl Safe_ports port 443 563     # https, snews
acl Safe_ports port 70          # gopher
acl Safe_ports port 210         # wais
acl Safe_ports port 1025-65535  # unregistered ports
acl Safe_ports port 280         # http-mgmt
acl Safe_ports port 488         # gss-http
acl Safe_ports port 591         # filemaker
acl Safe_ports port 777         # multilink http
acl Safe_ports port 901         # SWAT


# Definisce delle direttive ACL per individuare degli accessi
# con richieste particolari (standard).

acl purge method PURGE
acl CONNECT method CONNECT


# Consente l'accesso alla funzionalità amministrativa solo dal nodo
# locale (standard).

http_access allow manager localhost
http_access deny manager


# Consente l'accesso alla funzionalità «PURGE» solo dal nodo
# locale (standard).

http_access allow purge localhost
http_access deny purge


# Impedisce l'accesso a porte che si ritiene facciano riferimento
# a servizi che non sono gestibili (standard).

http_access deny !Safe_ports


# Consente il metodo «CONNECT» solo verso porte adatte (standard).

http_access deny CONNECT !SSL_ports


# Blocca l'accesso a risorse che corrispondono a file con estensioni
# particolari, come definito in precedenza con le direttive ACL.

http_access deny ban_mp3
http_access deny ban_ogg
http_access deny ban_mpeg
http_access deny ban_mpg
http_access deny ban_tar_gz
http_access deny ban_zip
http_access deny ban_vfw
http_access deny ban_avi
http_access deny ban_asx
http_access deny ban_qt
http_access deny ban_ram
http_access deny ban_rm

http_access deny banlist


# Consente l'accesso al proxy soltanto al nodo locale e a tutti i nodi
# delle reti locali (con indirizzi privati).

http_access allow localhost
http_access allow localnets
http_access deny all

Il file /etc/squid-banlist potrebbe contenere righe simili all'estratto seguente:

192.168.1.96
supersesso.dg
dinkel.brot.dg/~tizio/sesso

Un elenco più consistente di indirizzi da evitare, diviso per categoria, può essere ottenuto presso <http://ftp.teledanmark.no/pub/www/proxy/squidGuard/contrib/blacklists.tar.gz>.

Se si vuole realizzare un proxy trasparente (capitolo 177, occorre è necessario ridirigere il traffico che sarebbe destinato alla porta 80, alla porta presso la quale Squid è in ascolto localmente (negli esempi è sempre stata usata la porta 8 080 per questo scopo). Con un kernel Linux si può usare Iptables con un comando simile a quello seguente, dove si suppone che l'interfaccia eth1 sia quella rivolta verso la rete locale che si intende servire:

# iptables -t nat -A PREROUTING -p tcp --dport 80 -i eth1 _<-'
^`->-j REDIRECT --to-port 8080

Inoltre, Squid deve contenere le direttive seguenti nel file di configurazione:

httpd_accel_host virtual
httpd_accel_port 80
httpd_accel_with_proxy on
httpd_accel_uses_host_header on

174.5.5 Binari accessori

Squid si compone del binario squid e di altri accessori, con funzioni specifiche, avviati da questo. Si tratta di dnsserver, pinger e unlinkd, che potrebbero trovarsi nella directory /usr/lib/squid/, proprio perché non sono fatti per essere usati direttamente.

dnsserver viene usato per le interrogazioni DNS e solitamente ne vengono avviate diverse copie per accelerare le operazioni.

pinger viene usato per il protocollo ICMP; in particolare deve funzionare con i privilegi dell'utente root. Per questo motivo, è normale che appartenga a root è che abbia il bit SUID attivato (SUID-root).

unlinkd è un programma molto semplice che serve a cancellare file: cancella di volta in volta i file i cui nomi gli vengono forniti attraverso lo standard input. L'utilità di un tale programma sta nel non dover avviare ogni volta un nuovo processo per la cancellazione di ogni singolo file.

174.5.6 Interrogazione CGI

Squid fornisce un programma CGI per l'interrogazione del servizio proxy da parte dell'amministratore. Se viene installato correttamente, vi si dovrebbe accedere attraverso l'indirizzo http://localhost/cgi-bin/cachemgr.cgi. La configurazione predefinita di Squid dovrebbe escluderne l'utilizzo da parte di utenti che accedono da nodi differenti da localhost.

Figura 174.6. La maschera di cachemgr.cgi.

figure/a2-squid-cachemgr

Come si vede dalla figura 174.6, è necessario indicare almeno il nome del servente e il numero di porta del proxy.

174.6 Riferimenti

Squid Web Proxy Cache

<http://www.squid-cache.org/>
Stefano Tagliaferri, Squid proxy server

<http://merlino.merlinobbs.net/Squid-Book/>
Stefano Tagliaferri, Squid proxy server

<http://merlino.merlinobbs.net/Squid-Book/>
SquidGuard blacklist

<http://www.squidguard.org/blacklist/>

<http://ftp.teledanmark.no/pub/www/proxy/squidGuard/contrib/blacklists.tar.gz>

1) Squid GNU GPL

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome cache_proxy.html

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]