path: root/it_IT.ISO8859-15/books/handbook/jails/chapter.sgml

<?xml version="1.0" encoding="iso-8859-15" standalone="no"?>
<!--
    The FreeBSD Italian Documentation Project

    $FreeBSD$
    Original revision: 1.14
-->

<chapter id="jails">
  <chapterinfo>
    <authorgroup>
      <author>
        <firstname>Matteo</firstname>

        <surname>Riondato</surname>

        <contrib>Grazie al contributo di </contrib>
      </author>
    </authorgroup>
  </chapterinfo>

  <title>Jail</title>

  <indexterm><primary>jail</primary></indexterm>

  <sect1 id="jails-synopsis">
    <title>Sinossi</title>

    <para>Questo capitolo fornirà una spiegazione di cosa
      siano le jail in &os; e di come usarle.  Le jail, definite
      a volte come una miglioria
      dell'<emphasis>ambiente chroot</emphasis>, sono un strumento molto
      potente per amministratori di sistema, ma il loro uso
      può essere utile anche per utenti avanzati.</para>

    <para>Dopo aver letto questo capitolo, saprai:</para>

    <itemizedlist>
      <listitem>
        <para>Cosa è una jail e a quale scopi può servire
          nelle installazioni di &os;.</para>
      </listitem>

      <listitem>
        <para>Come creare, avviare e fermare una jail.</para>
      </listitem>

      <listitem>
        <para>Le basi per l'amministrazione delle jail, sia
          dall'interno che dall'esterno di una jail.</para>
      </listitem>
    </itemizedlist>

    <para>Altre fonti di informazioni utili a proposito delle jail sono:</para>

    <itemizedlist>
      <listitem>
        <para>La pagina man &man.jail.8;.  Questo è un riferimento
          completo dell'utility <command>jail</command> &mdash;
          il tool di amministrazione che può essere usato in &os;
          per avviare, fermare e controllare le jail in &os;.</para>
      </listitem>

      <listitem>
        <para>Le mailing list ed i loro archivi.  Gli archivi della
          &a.questions; ed altre mailing list ospitate sul &a.mailman.lists;
          contengono già una varietà di materiale per le jail.
          Si dovrebbe sempre cercare negli archivi, o inviare
          una nuova domanda alla mailing list &a.questions.name;.</para>
      </listitem>
    </itemizedlist>
  </sect1>

  <sect1 id="jails-terms">
    <title>Termini Relativi alle Jail</title>

    <para>Per facilitare una migliore comprensione delle parti di &os;
      relative alle jail, i loro meandri ed il modo in cui interagiscono
      con il resto di &os;, i seguenti termini saranno usati più avanti
      in questo capitolo:</para>

    <variablelist>
      <varlistentry>
        <term>&man.chroot.2; (comando)</term>

        <listitem>
          <para>Una chiamata di sistema di &os;, che cambia la directory root
            di un processo e di tutti i suoi discendenti.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>&man.chroot.2; (ambiente)</term>

        <listitem>
          <para>L'ambiente di un processo eseguito con <quote>chroot</quote>.
            Sono incluse le risorse come la parte del file system visibile,
            ID di utenti e di gruppi che sono disponibili, interfacce di rete,
            altri meccanismi di IPC, ecc.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>&man.jail.8; (comando)</term>

        <listitem>
          <para>L'utility di amministrazione di sistema che permette di
            eseguire processi all'interno di una jail.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>host (sistema, processo, utente, ecc.)</term>

        <listitem>
          <para>Il sistema di controllo di una jail.  Il sistema host ha accesso
            a tutte le risorse hardware disponibili, e può controllare
            processi sia all'interno che al di fuori di una jail.
            Una delle differenze importanti di un sistema host rispetto a una
            jail è che le limitazioni applicate ai processi superuser
            dentro una jail non sono valide per i processi del sistema
            host.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>hosted (sistema, processo, utente, ecc.)</term>

        <listitem>
          <para>Un processo, utente o altra entità, che abbia l'accesso
            alle risorse, limitato da una jail di &os;.</para>
        </listitem>
      </varlistentry>
    </variablelist>
  </sect1>

  <sect1 id="jails-intro">
    <title>Introduzione</title>

    <para>Dato che l'amministrazione di sistema è un compito
      difficile e gravoso, sono stati sviluppati molti strumenti potenti per
      rendere la vita più semplice per l'amministratore.
      Questi strumenti forniscono aiuti di vario genere nel modo in cui i
      sistemi sono installati, configurati e quindi manutenuti.  Parte dei
      compiti che un amministratore dovrebbe fare riguarda la corretta
      configurazione nell'ambito della sicurezza di un sistema, in modo tale
      da continuare a servire il suo vero intento, senza permettere
      violazioni di sistema.</para>

    <para>Uno degli strumenti che possono essere usati per migliorare
      la sicurezza di &os; sono le <emphasis>jail</emphasis>.
      Le jail furono introdotte con &os;&nbsp;4.X da &a.phk;, ma furono
      notevolmente migliorate in &os;&nbsp;5.X per renderle un sottosistema
      potente e flessibile.  Il loro sviluppo continua per migliorare
      la loro utilità, le prestazioni e la sicurezza.</para>

    <sect2 id="jails-what">
      <title>Cosa è una Jail</title>

      <para>I sistemi operativi BSD-like hanno avuto il &man.chroot.2;
        dai tempi di 4.2BSD.  L'utility &man.chroot.2; può
        essere usata per cambiare la directory root di un insieme di processi,
        creando un ambiente sicuro e separato dal resto del sistema.
        I processi creati nell'ambiente chroot non possono accedere a file o
        risorse fuori da questo.  Per questa ragione, compromettere un servizio
        che viene eseguito in un ambiente chroot non dovrebbe permettere
        all'attaccante di compromettere l'intero sistema.  L'utility
        &man.chroot.2; è utile per compiti semplici, che non richiedono
        molta flessibilità o caratteristiche complesse e avanzate.
        Tuttavia, dall'inizio del concetto di chroot, sono stati trovati
        diversi modi per uscire da un ambiente chroot, e, benchè
        siano stati fixati nelle versioni moderne del kernel di &os;,
        è diventato chiaro che &man.chroot.2; non era la soluzione
        ideale per rendere sicuri i servizi.  Un nuovo sottosistema
        doveva essere implementato.</para>

      <para>Queste sono alcune delle ragioni principali per
        cui le <emphasis>jail</emphasis> sono state sviluppate.</para>

      <para>Le jail migliorano il concetto dell'ambiente &man.chroot.2;
        tradizionale, in molti modi.  In un ambiente &man.chroot.2;
        tradizionale, i processi sono limitati solo nella porzione di file
        system che possono accedere.  Il resto delle risorse di sistema
        (come l'insieme di utenti di sistema, i processi in esecuzione, o il
        sotto-sistema di rete) sono condivise dai processi in chroot e dai
        processi del sistema host (quelli non inseriti in un ambiente chroot).
        Le jail espandono questo modello virtualizzando non solo l'accesso al
        file system, ma anche l'insieme di utenti, il sotto-sistema di rete del
        kernel di &os; e alcune altre cose.  Un più completo insieme
        di controlli disponibili per calibrare l'accesso ad un ambiente jail
        è descritto nella <xref linkend="jails-tuning"/>.</para>

      <para>Una jail è caratterizzata da quattro elementi:</para>

      <itemizedlist>
        <listitem>
          <para>Un sotto-ramo di una directory &mdash; il punto di partenza
            da cui si entra nella jail.  Una volta all'interno
            della jail, ad un processo non è permesso di
            uscire da questo sotto-ramo.  Le questioni tradizionali
            di sicurezza che colpiscono il design di &man.chroot.2; originale
            non affliggono le jail di &os;.</para>
        </listitem>

        <listitem>
          <para>Un hostname &mdash; l'hostname che sarà
            usato all'interno della jail.  Le jail sono principalmente
            usate per ospitare servizi di rete, quindi avere un nome host
            descrittivo per ogni jail può veramente aiutare
            l'amministratore di sistema.</para>
        </listitem>

        <listitem>
          <para>Un indirizzo <acronym>IP</acronym> &mdash; questo sarà
            assegnato alla jail e non può essere cambiato in alcun modo
            durante l'arco di vita della jail.  L'indirizzo IP di una jail
            è in genere un indirizzo alias di un'interfaccia di rete
            esistente, anche se questo non è strettamente
            necessario.</para>
        </listitem>

        <listitem>
          <para>Un comando &mdash; il percorso di un eseguibile da avviare
            all'interno della jail.  Questo è relativo alla
            directory root dell'ambiente della jail, e può variare molto,
            a seconda del tipo specifico di ambiente della jail.</para>
        </listitem>
      </itemizedlist>

      <para>Oltre a queste caratteristiche, le jail possono avere
        il loro insieme di utenti ed il loro utente <username>root</username>.
        Naturalmente, i poteri dell'utente <username>root</username> sono
        limitati all'interno dell'ambiente jail e, dal punto di vista del
        sistema host, l'utente <username>root</username> della jail non è
        il superuser.  Inoltre, l'utente <username>root</username> di una jail
        non potrà eseguire operazioni critiche sul sistema al di fuori
        del suo ambiente &man.jail.8;.  Altre informazioni sui poteri e sulle
        restrizioni dell'utente <username>root</username> saranno discusse
        nella <xref linkend="jails-tuning"/>.</para>
    </sect2>
  </sect1>

  <sect1 id="jails-build">
    <title>Creare e Controllare la Jail</title>

    <para>Alcuni amministratori dividono le jail nei seguenti due tipi:
      jail <quote>complete</quote>, che sono simili ad un sistema &os; reale,
      e jail <quote>di servizio</quote>, dedicate ad un'unica applicazione
      o servizio, possibilmente in esecuzione con privilegi.  Questa è
      solo una divisione concettuale ed il processo di creazione della
      jail non viene modificato da ciò.  La pagina man &man.jail.8;
      è abbastanza chiara a riguardo della procedura di creazione di una
      jail:</para>

    <screen>&prompt.root; <userinput>setenv D <replaceable>/qui/c'e'/la/jail</replaceable></userinput>
&prompt.root; <userinput>mkdir -p $D</userinput> <co id="jailpath"/>
&prompt.root; <userinput>cd /usr/src</userinput>
&prompt.root; <userinput>make world DESTDIR=$D</userinput> <co id="jailworld"/>
&prompt.root; <userinput>cd etc/</userinput> <footnote><para>Questo step non
è richiesto su &os; 6.0 e successivi.</para></footnote>
&prompt.root; <userinput>make distribution DESTDIR=$D</userinput> <co id="jaildistrib"/>
&prompt.root; <userinput>mount_devfs devfs $D/dev</userinput> <co id="jaildevfs"/></screen>

    <calloutlist>
      <callout arearefs="jailpath">
        <para>Selezionare una directory per la jail è
          il miglior punto in cui iniziare.  Questo sarà il punto
          in cui la jail risiederà fisicamente nel file system del
          sistema host.  Una buona scelta può essere
          <filename role="directory">/usr/jail/<replaceable>nomejail</replaceable></filename>,
          dove <replaceable>nomejail</replaceable> è il nome host
          che identifica la jail.  Il file system
          <filename role="directory">/usr/</filename> in genere ha abbastanza
          spazio vuoto per il file system delle jail, che per una
          jail <quote>completa</quote> è, in pratica, una replica di
          ogni file presente in una installazione base di &os;</para>
      </callout>

      <callout arearefs="jailworld">
        <para>Questo comando popolerà la sotto-directory
          scelta come locazione fisica della jail con
          i binari necessari, le librerie, le pagine man
          e cos&iacute; via.  Tutto è fatto nello stile tipico di
          &os; &mdash; prima tutto viene creato/compilato, poi installato
          nel percorso di destinazione.</para>
      </callout>

      <callout arearefs="jaildistrib">
        <para>Il target <maketarget>distribution</maketarget> per
          <application>make</application> installa ogni file di
          configuazione richiesto.  In parole povere, installa ogni
          file di
          <filename role="directory">/usr/src/etc/</filename> nella
          directory <filename role="directory">/etc</filename>
          dell'ambiente jail:
          <filename role="directory">$D/etc/</filename>.</para>
      </callout>

      <callout arearefs="jaildevfs">
        <para>Non è richiesto di montare il file system &man.devfs.8;
          all'interno della jail.  D'altro lato, ogni applicazione o quasi ha
          bisogno di accedere ad almeno un dispositivo, a seconda dello scopo
          dell'applicazione stessa.  È molto importante controllare
          l'accesso ai dispositivi dall'interno della jail, dato che con
          dei settaggi impropri un attaccante potrebbe compiere azioni dannose
          nella jail.  Il controllo su &man.devfs.8; è gestito attraverso
          le regole che sono descritte nelle pagine man di &man.devfs.8; e
          &man.devfs.conf.5;.</para>
      </callout>
    </calloutlist>

    <para>Una volta che una jail è installata, può essere
      avviata usando l'utility &man.jail.8;.  L'utility &man.jail.8;
      prende quattro argomenti obbligatori che sono descritti nella
      <xref linkend="jails-what"/>.  Possono essere specificati altri argomenti,
      ad esempio, per eseguire il programma nella jail con le credenziali
      di un utente specifico.  L'argomento
      <option><replaceable>comando</replaceable></option>
      dipende dal tipo di jail; per un <emphasis>sistema virtuale</emphasis>,
      <filename>/etc/rc</filename> è una buona scelta, dato che
      replicherà la sequenza di avvio di un sistema &os; reale.
      Per una jail <emphasis>di servizio</emphasis>, dipenderà
      dal servizio o dalla applicazione che sarà eseguita
      all'interno della jail.</para>

    <para>Le jail spesso sono avviate al momento di boot
      e il meccanismo <filename>rc</filename> di &os; fornisce
      un modo semplice per farlo.</para>

    <procedure>
      <step>
        <para>Una lista delle jail che sono abilitate al boot
          dovrebbe essere aggiunta al file &man.rc.conf.5;:</para>

        <programlisting>jail_enable="YES"   # NO per disabilitare l'avvio delle jail
jail_list="<replaceable>www</replaceable>"  # Lista dei nomi delle jail separati da spazi</programlisting>
      </step>

      <step>
        <para>Per ogni jail elencata in <varname>jail_list</varname>,
          dovrebbe essere aggiunto un gruppo di impostazioni di &man.rc.conf.5;,
          che descrive la jail:</para>

  <programlisting>jail_<replaceable>www</replaceable>_rootdir="/usr/jail/www"     # directory root della jail
jail_<replaceable>www</replaceable>_hostname="<replaceable>www</replaceable>.example.org"  # nome-host della jail
jail_<replaceable>www</replaceable>_ip="192.168.0.10"           # indirizzo IP della jail
jail_<replaceable>www</replaceable>_devfs_enable="YES"          # dispositivi di mount devfs nella jail
jail_<replaceable>www</replaceable>_devfs_ruleset="<replaceable>www_ruleset</replaceable>" # regole devfs da applicare alla jail</programlisting>

        <para>L'avvio di default delle jail configurate in
          &man.rc.conf.5; eseguirà lo script
          della jail in <filename>/etc/rc</filename>, che assume che la
          jail sia un completo sistema virtuale.  Per jail di servizio,
          il comando di default di avvio della jail dovrebbe essere cambiato,
          impostando l'opzione
          <varname>jail_<replaceable>nomejail</replaceable>_exec_start</varname>
          in modo appropriato.</para>

        <note>
          <para>Per una lista completa delle opzioni disponibili, per favore
            consulta la pagina man &man.rc.conf.5;.</para>
        </note>
      </step>
    </procedure>

    <para>Lo script <filename>/etc/rc.d/jail</filename> può
      essere usato per avviare o fermare una jail a mano, se esiste una entry
      in <filename>rc.conf</filename>:</para>

    <screen>&prompt.root; <userinput>/etc/rc.d/jail start <replaceable>www</replaceable></userinput>
&prompt.root; <userinput>/etc/rc.d/jail stop <replaceable>www</replaceable></userinput></screen>

    <para>Un modo pulito per spegnere una &man.jail.8; non è disponibile
      al momento.  Questo perchè i comandi usati normalmente per fare
      uno shutdown pulito non possono essere usati all'interno della jail.
      Il modo migliore per spegnere una jail è eseguire il seguente
      comando all'interno della jail stessa o usando l'utility &man.jexec.8;
      da fuori della jail:</para>

    <screen>&prompt.root; <userinput>sh /etc/rc.shutdown</userinput></screen>

    <para>Maggiori informazioni al riguardo possono essere trovate nella
      pagina man &man.jail.8;.</para>
  </sect1>

  <sect1 id="jails-tuning">
    <title>Messa a Punto ed Amministrazione</title>

    <para>Ci sono molte opzioni che possono essere impostate per ogni jail,
      e molti modi di combinare un sistema &os; con le jail, per produrre
      applicazioni di alto livello.  Questa sezione presenta:</para>

    <itemizedlist>
      <listitem>
        <para>Alcune delle opzioni disponibili per impostare il comportamento
          e le restrizioni di sicurezza implementate da una installazione di
          una jail.</para>
      </listitem>

      <listitem>
        <para>Alcune degli applicativi di alto livello per la gestione
          delle jail, che sono disponibili attraverso la Collezione
          dei Port di &os;, e possono essere usate per implementare
          soluzioni complete basate sulle jail.</para>
      </listitem>
    </itemizedlist>

    <sect2 id="jails-tuning-utilities">
      <title>Strumenti di sistema per mettere a punto una jail in &os;</title>

      <para>La messa a punto di una configurazione di una jail è
        principalmente fatta settando variabili &man.sysctl.8;.
        Esiste un sotto-ramo speciale di sysctl con tutte
        le opzioni del caso: la gerarchia <varname>security.jail.*</varname>
        delle opzioni del kernel di &os;.  Qui c'è una lista
        delle principali opzioni di sysctl relative alle jail, con il loro
        valori di default.  I nomi dovrebbero essere auto
        esplicativi, ma per maggiori informazioni riguardo questi, per favore
        fai riferimento alle pagine man &man.jail.8; e &man.sysctl.8;.</para>

      <itemizedlist>
        <listitem>
          <para><varname>security.jail.set_hostname_allowed: 1</varname></para>
        </listitem>

        <listitem>
          <para><varname>security.jail.socket_unixiproute_only:
            1</varname></para>
        </listitem>

        <listitem>
          <para><varname>security.jail.sysvipc_allowed: 0</varname></para>
        </listitem>

        <listitem>
          <para><varname>security.jail.enforce_statfs: 2</varname></para>
        </listitem>

        <listitem>
          <para><varname>security.jail.allow_raw_sockets: 0</varname></para>
        </listitem>

        <listitem>
          <para><varname>security.jail.chflags_allowed: 0</varname></para>
        </listitem>

        <listitem>
          <para><varname>security.jail.jailed: 0</varname></para>
        </listitem>
      </itemizedlist>

      <para>Queste variabili possono essere usate dall'amministratore di
        sistema del <emphasis>sistema host</emphasis> per aggiungere o
        rimuovere alcune delle limitazioni imposte di default all'utente
        <username>root</username>.  Nota che ci sono alcune limitazioni
        che non possono essere rimosse.  L'utente <username>root</username>
        non ha il permesso di montare o smontare file system all'interno
        della &man.jail.8;.  L'utente <username>root</username> all'interno
        della jail non può caricare o scaricare regole di
        &man.devfs.8;, impostare regole del firewall, o compiere
        molti altri compiti di amministrazione che richiedono modifiche
        in kernel, come impostare il <varname>securelevel</varname>
        del kernel.</para>

      <para>Il sistema base di &os; contiene un insieme di base di strumenti
        per vedere informazioni a proposito delle jail attive, e per
        attaccarsi ad una jail per eseguire compiti amministrativi.
        Il comando &man.jail.8; e &man.jexec.8; sono parte del sistema
        base di &os;, e possono essere usati per eseguire i seguenti semplici
        compiti:</para>

      <itemizedlist>
        <listitem>
          <para>Stampa una lista di jail attive e i loro corrispondenti
            identificativi di jail (<acronym>JID</acronym>),
            indirizzo <acronym>IP</acronym>, nome host e percorso.</para>
        </listitem>

        <listitem>
          <para>Attaccarsi ad una jail in esecuzione, dal suo sistema
            host, ed eseguire un comando o compiti amministrativi dall'interno
            della jail stessa.  Questo è specialmente utile quando
            l'utente <username>root</username> vuole spegnere in modo pulito
            una jail.  L'utility &man.jexec.8; può anche essere usata
            per avviare una shell in una jail per fare dell'amministrazione;
            ad esempio:</para>

          <screen>&prompt.root; <userinput>jexec <replaceable>1</replaceable> tcsh</userinput></screen>
        </listitem>
      </itemizedlist>
    </sect2>

    <sect2 id="jails-tuning-admintools">
      <title>Strumenti di amministrazione di alto livello nella
        Collezione dei Ports di &os;</title>

      <para>Fra le tante utility di terze parti per l'amministrazione
        delle jail, uno dei più completi ed utili è
        <filename role="package">sysutils/jailutils</filename>.  È
        un insieme di piccoli applicativi che contribuiscono alla gestione
        delle &man.jail.8;.  Per favore fai riferimento alla corrispondente
        pagina web per maggiori informazioni.</para>
    </sect2>
  </sect1>

  <sect1 id="jails-application">
    <title>Applicazioni di Jail</title>

    <sect2 id="jails-service-jails">
      <sect2info>
        <authorgroup>
          <author>
            <firstname>Daniel</firstname>

            <surname>Gerzo</surname>

            <contrib>Contributo di  </contrib>
          </author>
        </authorgroup>
      </sect2info>

      <title>Servizi Jail</title>

      <para>Questa sezione è basata su un'idea di &a.simon; (<ulink
        url="http://simon.nitro.dk/service-jails.html"></ulink>), e su un
        articolo scritto da by Ken Tom <email>locals@gmail.com</email>.
        Questa sezione illustra come configurare un sistema &os; aggiungendo
        uno strato di sicurezza addizionale, usando le funzionalità
        delle &man.jail.8;.  Inoltre questa sezione assume che la versione
        &os; del sistema sia almeno la RELENG_6_0 e che siano state capite le
        informazioni fornite precedentemente nel capitolo.</para>

      <sect3 id="jails-service-jails-design">
        <title>Progetto</title>

        <para>Uno dei maggiori problemi delle jail è la gestione del loro
          processo di aggiornamento.  Questo tende a essere un problema
          poichè ciascuna jail deve essere ricostruita da zero ogni
          volta che deve essere aggiornata.  Di solito questo non è
          un problema per una jail singola, poichè il processo
          di aggiornamento è abbastanza semplice, ma se sono create
          tante jail può diventare un processo lungo e tedioso.</para>

        <warning>
          <para>Questa configurazione richiede una esperienza avanzata con
            &os;.  Se i procedimenti seguenti risultano troppo complicati, si
            consiglia di dare un'occhiata a un sistema più intuitivo
            come <filename role="package">sysutils/ezjail</filename>, che
            fornisce un modo semplice di amministrare le jail in &os; e non
            è sofisticato come questa configurazione.</para>
        </warning>

        <para>Questa idea è stata presentata per risolvere
          il problema di condividere quanto più possibile tra le jail,
          in modo sicuro &mdash; usando &man.mount.nullfs.8; in sola lettura,
          affinchè l'aggiornamento sia semplice, e per fare diventare
          più allettante mettere singoli servizi in jail individuali.
          Inoltre, si fornisce un modo per creare, aggiornare e rimuovere
          jail.</para>

        <note>
          <para>Esempi di servizi in questo contesto sono: un server
            <acronym>HTTP</acronym>, un server <acronym>DNS</acronym>,
            un server <acronym>SMTP</acronym>, e via dicendo.</para>
        </note>

        <para>Gli scopi di configurazione descritti in questa sezione
          sono:</para>

        <itemizedlist>
          <listitem>
            <para>Comprendere la struttura jail.  Questo implica di
            <emphasis>not</emphasis> dovere eseguire un installworld completo
            per ogni jail.</para>
          </listitem>

          <listitem>
            <para>Semplificare l'aggiunta di una nuova jail o la rimozione
              di una esistente.</para>
          </listitem>

          <listitem>
            <para>Semplificare l'aggiornamento o la modifica di una jail
              esistente.</para>
          </listitem>

          <listitem>
            <para>Rende possibile l'esecuzione di un &os; su misura.</para>
          </listitem>

          <listitem>
            <para>Essere paranoici sulla sicurezza, riducendo quanto più
              possibile la possibilità di mettere a repentaglio il
              sistema.</para>
          </listitem>

          <listitem>
            <para>Salvare spazio e inode, quanto più possibile.</para>
          </listitem>
        </itemizedlist>

        <para>Come già menzionato, questa configurazione si basa
          pesantemente nell'avere un unico template master che è in sola
          lettura (conosciuto come <application>nullfs</application>) montato in
          ogni jail e un dispositivo in lettura-scrittura per jail.  Il
          dispositivo può essere un disco fisico separato, una
          partizione, o un dispositivo vnode &man.md.4;.  In questo esempio,
          useremo un <application>nullfs</application> in lettura e
          scrittura.</para>

        <para>Viene qui descritto il layout del file system:</para>

        <itemizedlist>
          <listitem>
            <para>Ogni jail sarà montata sotto la directory
              <filename role="directory">/home/j</filename>.</para>
          </listitem>

          <listitem>
            <para><filename role="directory">/home/j/mroot</filename> è
              il template per ogni jail e la partizione in sola lettura per
              tutte le jail.</para>
          </listitem>

          <listitem>
            <para>Una directory vuota sarà creata per ogni jail sotto
            la directory <filename role="directory">/home/j</filename>.</para>
          </listitem>

          <listitem>
            <para>Ogni jail avrà una directory <filename
                role="directory">/s</filename>, che sarà linkata
              alla porzione del sistema in lettura e scrittura.</para>
          </listitem>

          <listitem>
            <para>Ogni jail ha il suo sistema in lettura e scrittura in
              <filename role="directory">/home/j/skel</filename>.</para>
          </listitem>

          <listitem>
            <para>Ogni spazio di jail (la porzione in lettura e scrittura di
              ogni jail) sarà creato in <filename
                role="directory">/home/js</filename>.</para>
          </listitem>
        </itemizedlist>

        <note>
          <para>Si assume che le jail siano posizionate sotto la partizione
          <filename role="directory">/home</filename>.  Di sicuro, questo
          può essere modificato con qualcosa di diverso, ma questo
          cambiamento dovrà essere tenuto in considerazione
          negli esempi più avanti.</para>
        </note>
      </sect3>

      <sect3 id="jails-service-jails-template">
        <title>Creare il Template</title>

        <para>Questa sezione descrive le fasi necessarie per creare il
          template di riferimento che sarà la parte in sola lettura
          utilizzate dalle jail.</para>

        <para>È sempre una buona idea aggiornare &os; al branch -RELEASE
          più recente.  Per farlo, consulta il
          <ulink url="&url.books.handbook;/makeworld.html">capitolo</ulink>
          di riferimento dell'Handbook.  Nel caso che l'aggiornamento
          non sia fattibile, sarà necessaria la procedura di buildworld
          per poter procedere.  Inoltre, è richiesto il pacchetto
          <filename role="package">sysutils/cpdup</filename>.
          Useremo l'utility &man.portsnap.8; per scaricare la
          &os; Ports Collection.  Il <ulink
            url="&url.books.handbook;/portsnap.html">Capitolo Portsnap</ulink>
          dell'handbook è sempre una buona lettura per i nuovi
          arrivati.</para>

        <procedure>
          <step>
            <para>Primo, creiamo la struttura della directory per il file
              system in sola lettura che conterrà i binari di &os;
              per le nostre jail, quindi portiamoci nel ramo della directory
              dei sorgenti di &os; e installiamo il file system in sola
              lettura per il template delle jail:</para>

            <screen>&prompt.root; <userinput>mkdir /home/j /home/j/mroot</userinput>
&prompt.root; <userinput>cd /usr/src</userinput>
&prompt.root; <userinput>make installworld DESTDIR=/home/j/mroot</userinput></screen>
          </step>

          <step>
            <para>Quindi, prepariamo la &os; Ports Collection per le jail
              così come abbiamo fatto per l'alberatura dei sorgenti,
              richiesta per <application>mergemaster</application>:</para>

            <screen>&prompt.root; <userinput>cd /home/j/mroot</userinput>
&prompt.root; <userinput>mkdir usr/ports</userinput>
&prompt.root; <userinput>portsnap -p /home/j/mroot/usr/ports fetch extract</userinput>
&prompt.root; <userinput>cpdup /usr/src /home/j/mroot/usr/src</userinput></screen>
          </step>

          <step>
            <para>Creiamo lo scheletro per la parte del sistema in
              lettura e scrittura:</para>

            <screen>&prompt.root; <userinput>mkdir /home/j/skel /home/j/skel/home /home/j/skel/usr-X11R6 /home/j/skel/distfiles</userinput>
&prompt.root; <userinput>mv etc /home/j/skel</userinput>
&prompt.root; <userinput>mv usr/local /home/j/skel/usr-local</userinput>
&prompt.root; <userinput>mv tmp /home/j/skel</userinput>
&prompt.root; <userinput>mv var /home/j/skel</userinput>
&prompt.root; <userinput>mv root /home/j/skel</userinput></screen>
          </step>

          <step>
            <para>Usiamo <application>mergemaster</application> per installare
              i file di configurazione mancanti.  Quindi liberiamoci delle
              directory extra che <application>mergemaster</application> ha
              creato:</para>

            <screen>&prompt.root; <userinput>mergemaster -t /home/j/skel/var/tmp/temproot -D /home/j/skel -i</userinput>
&prompt.root; <userinput>cd /home/j/skel</userinput>
&prompt.root; <userinput>rm -R bin boot lib libexec mnt proc rescue sbin sys usr dev</userinput></screen>
          </step>

          <step>
            <para>Ora, linkiamo in modo simbolico il file system in lettura
              e scrittura nel file system di sola lettura.  Assicuriamoci
              che i link simbolici siano creati nelle posizioni corrette in
              <filename role="directory">s/</filename>.  La creazione di
              directory in posti sbagliati causerà un fallimento
              durante l'installazione.</para>

            <screen>&prompt.root; <userinput>cd /home/j/mroot</userinput>
&prompt.root; <userinput>mkdir s</userinput>
&prompt.root; <userinput>ln -s s/etc etc</userinput>
&prompt.root; <userinput>ln -s s/home home</userinput>
&prompt.root; <userinput>ln -s s/root root</userinput>
&prompt.root; <userinput>ln -s ../s/usr-local usr/local</userinput>
&prompt.root; <userinput>ln -s ../s/usr-X11R6 usr/X11R6</userinput>
&prompt.root; <userinput>ln -s ../../s/distfiles usr/ports/distfiles</userinput>
&prompt.root; <userinput>ln -s s/tmp tmp</userinput>
&prompt.root; <userinput>ln -s s/var var</userinput></screen>
          </step>

          <step>
            <para>Come ultima fase, creiamo un generico
              <filename>/home/j/skel/etc/make.conf</filename> con
              il seguente contenuto:</para>

            <programlisting>WRKDIRPREFIX?=  /s/portbuild</programlisting>

            <para>Avendo settato <literal>WRKDIRPREFIX</literal> in questo modo
              sarà possibile compilare i port di &os; all'interno
              di ogni jail.  Ricordati che la directory dei port è
              parte del sistema in sola lettura.  Il percorso ad doc di
              <literal>WRKDIRPREFIX</literal> permette di compilare nella
              porzione in lettura e scrittura di ogni jail.</para>
          </step>
        </procedure>
      </sect3>

      <sect3 id="jails-service-jails-creating">
        <title>Creazione di Jail</title>

        <para>Ora che abbiamo completato il template della jail, possiamo
          configurare le jail in
          <filename>/etc/rc.conf</filename>.  Questo esempio mostra
          la creazione di 3 jail: <quote>NS</quote>,
          <quote>MAIL</quote> e <quote>WWW</quote>.</para>

        <procedure>
          <step>
            <para>Inseriamo le seguenti righe nel file
              <filename>/etc/fstab</filename>, in modo tale che
              il template in sola lettura per le jail e lo spazio
              in lettura e scrittura sarà disponibile
              nella rispettive jail:</para>

            <programlisting>/home/j/mroot   /home/j/ns     nullfs  ro  0   0
/home/j/mroot   /home/j/mail   nullfs  ro  0   0
/home/j/mroot   /home/j/www    nullfs  ro  0   0
/home/js/ns     /home/j/ns/s   nullfs  rw  0   0
/home/js/mail   /home/j/mail/s nullfs  rw  0   0
/home/js/www    /home/j/www/s  nullfs  rw  0   0</programlisting>

            <note>
              <para>Le partizioni con uno 0 come numero di pass non
                sono verificate da &man.fsck.8; durante il boot, e le partizioni
                con uno 0 come numero di dump non sono prese in considerazione
                da &man.dump.8;.  Non si vuole che
                <application>fsck</application> verifichi i mount
                <application>nullfs</application> o che
                <application>dump</application> faccia un backup dei mount
                nullfs in sola lettura delle jail.  Ecco perchè
                queste partizioni hanno <quote>0&nbsp;0</quote> nelle ultime
                due colonne di ogni riga di
                <filename>fstab</filename> sopra mosrate.</para>
            </note>
          </step>

          <step>
            <para>Configuriamo le jail in
              <filename>/etc/rc.conf</filename>:</para>

              <programlisting>jail_enable="YES"
jail_set_hostname_allow="NO"
jail_list="ns mail www"
jail_ns_hostname="ns.example.org"
jail_ns_ip="192.168.3.17"
jail_ns_rootdir="/usr/home/j/ns"
jail_ns_devfs_enable="YES"
jail_mail_hostname="mail.example.org"
jail_mail_ip="192.168.3.18"
jail_mail_rootdir="/usr/home/j/mail"
jail_mail_devfs_enable="YES"
jail_www_hostname="www.example.org"
jail_www_ip="62.123.43.14"
jail_www_rootdir="/usr/home/j/www"
jail_www_devfs_enable="YES"</programlisting>

              <warning>
                <para>La ragione del perchè la variabile
                  <varname>jail_<replaceable>nome</replaceable>_rootdir</varname>
                  è settata a <filename
                    role="directory">/usr/home</filename> invece di
                  <filename role="directory">/home</filename> è che
                  il percorso reale della directory <filename
                    role="directory">/home</filename> in una installazione
                  standard di &os; è <filename
                    role="directory">/usr/home</filename>.  La variabile
                  <varname>jail_<replaceable>nome</replaceable>_rootdir</varname>
                  <emphasis>non</emphasis> deve essere settata a un percorso
                  che include link simbolici, altrimenti la jail
                  rifiuterà di partire.  Usa l'utility &man.realpath.1;
                  per determinare il valore che questa variabile dovrebbe
                  assumere.  Per favore da un occhio al Security Advisory
                  &os;-SA-07:01.jail per maggiorni informazioni.</para>
              </warning>
            </step>

          <step>
            <para>Creiamo i punti di mount richiesti per il file system
              in sola lettura di ogni jail:</para>

            <screen>&prompt.root; <userinput>mkdir /home/j/ns /home/j/mail /home/j/www</userinput></screen>
          </step>

          <step>
            <para>Installiamo il template in lettura e scrittura
              in ciascuna jail.  Notare l'utilizzo di <filename
                role="package">sysutils/cpdup</filename>, che assicura
              una corretta copia di ogni directory:</para>

            <screen>&prompt.root; <userinput>mkdir /home/js</userinput>
&prompt.root; <userinput>cpdup /home/j/skel /home/js/ns</userinput>
&prompt.root; <userinput>cpdup /home/j/skel /home/js/mail</userinput>
&prompt.root; <userinput>cpdup /home/j/skel /home/js/www</userinput></screen>
          </step>

          <step>
            <para>In questa fase, le jail sono preparate per essere eseguite.
              Montiamo il file system richiesto per ogni jail, e quindi
              avviamole con lo script
              <filename>/etc/rc.d/jail</filename>:</para>

            <screen>&prompt.root; <userinput>mount -a</userinput>
&prompt.root; <userinput>/etc/rc.d/jail start</userinput></screen>
          </step>
        </procedure>

        <para>Le jail dovrebbero essere in esecuzione.  Per verificare che
          siano state avviate correttamente, usiamo il comando &man.jls.8;.
          Il suo output dovrebbe essere simile al seguente:</para>

        <screen>&prompt.root; <userinput>jls</userinput>
   JID  IP Address      Hostname                      Path
     3  192.168.3.17    ns.example.org                /home/j/ns
     2  192.168.3.18    mail.example.org              /home/j/mail
     1  62.123.43.14    www.example.org               /home/j/www</screen>

        <para>A questo punto, dovrebbe essere possibile entrare in ciascuna
          jail, aggiungere nuovi utenti o configurare demoni.  La colonna
          <literal>JID</literal> indica il numero identificativo
          di ciascuna jail in esecuzione.  Usa il comando seguente per
          effettuare compiti amministrativi nella jail con
          <literal>JID</literal> 3:</para>

        <screen>&prompt.root; <userinput>jexec 3 tcsh</userinput></screen>
      </sect3>

      <sect3 id="jails-service-jails-upgrading">
        <title>Aggiornamento</title>

        <para>Il tempo passa, e sarà necessario aggiornare il sistema
          a una nuova versione di &os;, vuoi per questioni di sicurezza,
          o perchè sono state implementate nuove funzionalità
          che ritornano utili per le jail esistenti.  Di seguito si fornisce
          un modo semplice per effettuare l'aggiornamento delle jail esistenti.
          Inoltre, questo metodo minimizza il tempo in cui le jail non
          sono in esecuzione, poichè le jail saranno disattivate solo
          per un breve periodo.  Questa procedura fornisce un modo per
          ritornare indietro alle vecchie versioni nel caso qualcosa vada
          storto.</para>

        <procedure>
          <step>
            <para>Il primo passo è aggiornare il sistema host nella
              maniera usuale.  Quindi creiamo un template temporaneo
              in sola lettura in <filename
                role="directory">/home/j/mroot2</filename>.</para>

            <screen>&prompt.root; <userinput>mkdir /home/j/mroot2</userinput>
&prompt.root; <userinput>cd /usr/src</userinput>
&prompt.root; <userinput>make installworld DESTDIR=/home/j/mroot2</userinput>
&prompt.root; <userinput>cd /home/j/mroot2</userinput>
&prompt.root; <userinput>cpdup /usr/src usr/src</userinput>
&prompt.root; <userinput>mkdir s</userinput></screen>

            <para>Il processo di <maketarget>installworld</maketarget> crea
              alcune directory non necessarie, che possono essere
              rimosse:</para>

            <screen>&prompt.root; <userinput>chflags -R 0 var</userinput>
&prompt.root; <userinput>rm -R etc var root usr/local tmp</userinput></screen>
          </step>

          <step>
            <para>Ricreiamo i link simbolici in lettura e scrittura
              per il file system di riferimento:</para>

            <screen>&prompt.root; <userinput>ln -s s/etc etc</userinput>
&prompt.root; <userinput>ln -s s/root root</userinput>
&prompt.root; <userinput>ln -s s/home home</userinput>
&prompt.root; <userinput>ln -s ../s/usr-local usr/local</userinput>
&prompt.root; <userinput>ln -s ../s/usr-X11R6 usr/X11R6</userinput>
&prompt.root; <userinput>ln -s s/tmp tmp</userinput>
&prompt.root; <userinput>ln -s s/var var</userinput></screen>
          </step>

          <step>
            <para>È questo il momento per fermare le jail:</para>

            <screen>&prompt.root; <userinput>/etc/rc.d/jail stop</userinput></screen>
          </step>

          <step>
            <para>Smontiamo il file system originale:</para>

            <screen>&prompt.root; <userinput>umount /home/j/ns/s</userinput>
&prompt.root; <userinput>umount /home/j/ns</userinput>
&prompt.root; <userinput>umount /home/j/mail/s</userinput>
&prompt.root; <userinput>umount /home/j/mail</userinput>
&prompt.root; <userinput>umount /home/j/www/s</userinput>
&prompt.root; <userinput>umount /home/j/www</userinput></screen>

            <note>
              <para>I sistemi in lettura e scrittura sono attaccati al
                sistema in sola lettura
                (<filename role="directory">/s</filename>) e devono essere
                smontati.</para>
            </note>
          </step>

          <step>
            <para>Muovi il file system in sola lettura e rimpiazzalo con
              quello nuovo.  Il vecchio file system in sola lettura
              servirà da backup in caso qualcosa dovesse andare storto.
              La convenzione dei nomi qui utilizzata corrisponde a quella
              utilizzata quando fu creato il file system in sola lettura.
              Muovi la &os; Ports Collection originale nel nuovo file system
              per risparmiare spazio e inode:</para>

            <screen>&prompt.root; <userinput>cd /home/j</userinput>
&prompt.root; <userinput>mv mroot mroot.20060601</userinput>
&prompt.root; <userinput>mv mroot2 mroot</userinput>
&prompt.root; <userinput>mv mroot.20060601/usr/ports mroot/usr</userinput></screen>
          </step>

          <step>
            <para>A questo punto il nuovo template in sola lettura è
              pronto, quindi ci rimare di rimontare il file system e
              avviare le jail:</para>

            <screen>&prompt.root; <userinput>mount -a</userinput>
&prompt.root; <userinput>/etc/rc.d/jail start</userinput></screen>
          </step>
        </procedure>

        <para>Usa &man.jls.8; per verificare che le jail sono state avviate
          correttamente.  Non dimenticare di eseguire mergemaster in
          ciascuna jail.  I file di configurazione dovranno essere aggiornati
          così come gli script rc.d.</para>
      </sect3>
    </sect2>
  </sect1>
</chapter>