Creare un file server integrato con Active Directory utilizzando Linux, Samba e Winbind

Questo tutorial vi guiderà nella creazione di un file server basato su Linux e Samba ed integrato con un dominio Active Directory tramite Winbind. Il server Linux erogherà il servizio di condivisione dei file attraverso Samba, attingendo ad Active Directory per ottenere le credenziali di accesso degli utenti. In altre parole, esso opererà come un server membro di dominio.

Perché Linux?

Linux è un sistema operativo potente, stabile, flessibile, performante e ricco di funzionalità. Può svolgere molto bene diversi compiti in una rete aziendale, compreso quello di file server. Lo scopo di questo tutorial non è promuovere Linux come sostituto di Windows, bensì dimostrare come i due sistemi possano coesistere e interagire tra loro con profitto. L’amministratore di rete ed i suoi utenti trarranno benefici da entrambi i sistemi, sfruttando ciò che di meglio ciascuno dei due ha da offrire.

Perché Windows?

È indiscutibile che, in un ambiente di rete dove la maggior parte dei PC è equipaggiata con Windows, sia un server Windows a gestire l’accesso alle risorse. Linux non svolge ancora, a mio parere, un lavoro altrettanto buono in tal senso (a meno di non potersi permettere Novell eDirectory). Chi ha tentato di implementare un domain controller con Samba sa bene che non è cosa né semplice né rapida; la manutenzione, senza gli strumenti visuali offerti da Windows, è piuttosto scomoda; senza contare che Samba 3, come domain controller, è fermo ai domini di Windows NT 4.0 e Samba 4, che promette di emulare Active Directory, è ancora in alto mare. Perciò, ad ognuno il suo mestiere.

Scenari di utilizzo

Ecco alcuni scenari in cui l’utilizzo di Linux come file server può essere vantaggioso:

  • Archiviazione di grandi quantità di dati aziendali. Linux è in grado di offrire ottime performance anche in situazioni limite (file molto grandi o directory estremamente popolate), scalabilità, gestione delle quote, stabilità, sicurezza e molto altro.
  • Aree di scambio dati con l’esterno. Si possono creare archivi serviti via FTP o HTTP sul lato Internet, ed accessibili in condivisione directory sul lato LAN.
  • Creazione di file server di classe enterprise a basso costo. Non vi sono costi legati all’acquisto e all’utilizzo del software. Il setup è relativamente semplice e rapido e la manutenzione, una volta che il sistema è a regime, è minima.
  • Recupero di vecchio hardware. Linux notoriamente gira bene anche su hardware obsoleto. Con un paio di dischi nuovi, il vostro vecchio server può ancora dare molto.

La nostra configurazione

Per il nostro esempio abbiamo tre macchine in rete:

  1. un server Windows 2008 R2, preconfigurato con Active Directory, servizio DNS e quant’altro necessario perché svolga il ruolo di controller di dominio;
  2. un client Windows XP, già membro del dominio;
  3. un server Linux Debian 6 (Squeeze).

La nostra subnet è 192.168.50.0/24 e il dominio ha nome acme.local (nome NetBIOS ACME). Il server Windows ha indirizzo IP 192.168.50.20 e nome di rete vmw2008r2, il gateway è 192.168.50.254. Il server Linux si chiama smbserver. Andremo a creare un’area dati sul server Linux, appoggiandola su un filesistem XFS creato sopra un volume LVM. Vedremo più avanti che questa soluzione offre una buona scalabilità, permettendo l’espansione e l’allocazione dinamica dello spazio su disco, anche a caldo. L’area dati verrà quindi esposta con Samba e resa disponibile a tutti gli utenti del dominio.

Panoramica dell’intervento

Ecco i punti fondamentali dell’implementazione:

  1. impostazioni di rete del server Linux
  2. creazione del volume LVM e del filesystem XFS
  3. installazione e configurazione di Kerberos (autenticazione)
  4. installazione e configurazione di Winbind (accesso a utenti e gruppi di Active Directory)
  5. installazione e configurazione di Samba (file server)

1. Impostazioni di rete del server Linux

Come prima cosa interveniamo sulle impostazioni di rete del server Linux. Se si è appena conclusa l’installazione del sistema operativo, è probabile che l’interfaccia di rete sia configurata in DHCP. Ciò non è consigliabile per un server; inoltre è necessario che il resolver DNS punti al server Windows, poiché è quest’ultimo a risolvere i nomi e la posizione dei servizi in rete, tra cui il servizio Kerberos che ci servirà più avanti. Assegniamo al server Linux l’indirizzo statico 192.168.50.21:

lorenzo@smbserver:~$ sudo nano /etc/network/interfaces

ed eccoci nell’editor Nano. È facile da usare: ci si sposta con le frecce, si salva con CTRL+O e si esce con CTRL+X.

  GNU nano 2.2.4          File: /etc/network/interfaces

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug eth0
iface eth0 inet dhcp

^G Guida       ^O Salva       ^R Inserisci   ^Y Pag Prec.   ^K Taglia      ^C Posizione
^X Esci        ^J Giustifica  ^W Cerca       ^V Pag Succ.   ^U Incolla     ^T Ortografia

Modifichiamo la riga:

iface eth0 inet dhcp

nel modo seguente:

iface eth0 inet static
        address 192.168.50.21
        netmask 255.255.255.0
        gateway 192.168.50.254

In pratica abbiamo modificato l’interfaccia eth0 da DHCP a IP statico, e gli abbiamo fornito i vari parametri. CTRL+O, Invio per confermare il nome del file, CTRL+X per uscire.
Ora sistemiamo il resolver DNS:

lorenzo@smbserver:~$ sudo nano /etc/resolv.conf

Modifichiamo il contenuto del file come segue:

domain acme.local
search acme.local
nameserver 192.168.50.20

Salviamo e usciamo da Nano. È ora di applicare i cambiamenti:

lorenzo@smbserver:~$ sudo ifdown eth0 ; sudo ifup eth0

Facciamo un test:

lorenzo@smbserver:~$ ping vmw2008r2

Dovremmo vedere qualcosa del genere:

PING vmw2008r2.acme.local (192.168.50.20) 56(84) bytes of data.
64 bytes from 192.168.50.20: icmp_req=1 ttl=128 time=0.369 ms
64 bytes from 192.168.50.20: icmp_req=2 ttl=128 time=0.426 ms
64 bytes from 192.168.50.20: icmp_req=3 ttl=128 time=0.348 ms
...

CTRL+C per fermare il ping.
È consigliabile inserire nome e indirizzo del server Linux in /etc/hosts:

lorenzo@smbserver:~$ sudo nano /etc/hosts

Assicuriamoci che il nostro server Linux sia elencato correttamente:

192.168.50.21   smbserver.acme.local    smbserver

2. Creazione del volume LVM e del filesystem XFS

Per questa fase abbiamo bisogno del supporto LVM e delle utilità per XFS. In due parole, LVM (Logical Volume Manager) è un sottile strato di software posto appena sopra i dispositivi fisici (hard disk e partizioni), che rende possibile l’allocazione dinamica dello spazio, il ridimensionamento dei volumi, gli snapshot, e via dicendo. Con LVM, per esempio, si possono unire più partizioni e farne un unico device, in modo analogo allo striping dei controller RAID o al JBOD. XFS, invece, è un filesystem originariamente sviluppato dall’americana SGI e successivamente rilasciato al mondo Open Source, dotato di ottime performance e affidabilità, nonché di caratteristiche che lo rendono interessante in abbinamento con LVM e Samba, come la capacità di ridimensionamento a caldo e il supporto per le ACL (Access Control List). Potendo ridimensionare a caldo sia il device sottostante, anche aggiungendo nuovi dischi fissi, sia il filesystem sovrastante, è possibile di fatto allocare dinamicamente lo spazio, a macchina accesa e utenti collegati!
Bene, procediamo. Installiamo i pacchetti relativi all’LVM e alle utility XFS:

lorenzo@smbserver:~$ sudo apt-get install lvm2 xfsprogs

Prepariamo la partizione che ospiterà i dati. Nel nostro esempio la macchina Linux è dotata di un secondo hard disk (/dev/sdb), che verrà interamente utilizzato come spazio per LVM.

lorenzo@smbserver:~$ sudo fdisk -c -u /dev/sdb

I comandi da inserire sono evidenziati:

Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First sector (2048-266338303, default 2048): (premere Invio)
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-266338303, default 266338303): (premere Invio)
Using default value 266338303

Command (m for help): t
Selected partition 1
Hex code (type L to list codes): 8e
Changed system type of partition 1 to 8e (Linux LVM)

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

La partizione /dev/sdb1 è stata creata. Prepariamola per l’utilizzo con LVM:

lorenzo@smbserver:~$ sudo pvcreate /dev/sdb1
  Physical volume "/dev/sdb1" successfully created

Creiamo ora il Volume Group. Il Volume Group è un’astrazione sopra i device fisici (partizioni), che funge da serbatoio per lo spazio su disco. Più device possono contribuire alla formazione di un Volume Group, ed è possibile aggiungere, eliminare e spostare device da un Volume Group. In breve, il Volume Group è un po’ come l’hard disk del sistema LVM, ma a differenza degli hard disk tradizionali è molto flessibile.

lorenzo@smbserver:~$ sudo vgcreate vg0 /dev/sdb1
  Volume group "vg0" successfully created

Lo spazio contenuto nel Volume Group non è direttamente utilizzabile, ma deve essere assegnato a dei Logical Volume. I Logical Volume sono visti dal sistema esattamente come le partizioni tradizionali, ma a differenza di queste ultime possono essere manipolati in molti modi: si può espanderli, restringerli (con qualche precauzione), spostarli, farne uno snapshot, e via dicendo.
Creiamo dunque un Logical Volume da 10GB con nome lv0 sopra il Volume Group creato in precedenza:

lorenzo@smbserver:~$ sudo lvcreate -n lv0 -L 10g vg0
  Logical volume "lv0" created

Bene. Abbiamo un device, utilizzabile esattamente come una partizione tradizionale, ed accessibile dal percorso /dev/vg0/lv0. È giunto il momento di creare il nostro filesystem:

lorenzo@smbserver:~$ sudo mkfs -t xfs /dev/vg0/lv0
meta-data=/dev/vg0/lv0           isize=256    agcount=4, agsize=655360 blks
         =                       sectsz=512   attr=2, projid32bit=0
data     =                       bsize=4096   blocks=2621440, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal log           bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

È ora di montare il filesystem. Innanzitutto creiamo il mount point:

lorenzo@smbserver:~$ sudo mkdir /var/fileserver

Quindi creiamo la entry nel file /etc/fstab, in modo che il sistema monti il nostro filesystem ad ogni boot:

lorenzo@smbserver:~$ sudo nano /etc/fstab

Aggiungiamo queste righe alla fine del file:

# partizione dati
/dev/mapper/vg0-lv0                     /var/fileserver   xfs     defaults        0       0

Notare che sia /dev/mapper/vg0-lv0 che /dev/vg0/lv0 sono link simbolici che puntano a /dev/dm-0. Salviamo e usciamo da Nano. Montiamo il filesystem:

lorenzo@smbserver:~$ sudo mount /dev/vg0/lv0

Creiamo la directory dati al suo interno:

lorenzo@smbserver:~$ sudo mkdir /var/fileserver/dati

Dobbiamo assegnare i permessi di lettura e scrittura alla directory dati, ma lo faremo più avanti poiché ancora non abbiamo in linea gli utenti del dominio. Per questo ci vogliono Kerberos e Winbind. Forza, non manca molto!

3. Installazione e configurazione di Kerberos

Kerberos è un protocollo di rete che permette l’autenticazione dell’utente mediante crittografia. Kerberos è uno dei protocolli che stanno alla base di Active Directory; tramite esso il controller Windows autentica gli utenti e implementa il meccanismo del Single sign-on (SSO), che permette agli utenti di autenticarsi una sola volta e, successivamente, di accedere alle risorse di rete senza fornire ulteriori credenziali. Ciò avviene grazie a dei ticket, che vengono rilasciati dal server Kerberos e che possono essere ripresentati dal client, anche ad altri server della rete, per ottenere l’accesso alle risorse.
Noi abbiamo bisogno del client Kerberos, per autenticarci sul controller di dominio Windows. Installiamolo:

lorenzo@smbserver:~$ sudo apt-get install krb5-user

Vengono mostrate un paio di schermate di configurazione:

Configurazione del pacchetto

 +--------------¦ Configurazione dell'autenticazione Kerberos +--------------+
 ¦ Quando gli utenti cercano di usare Kerberos specificando un principal o   ¦
 ¦ un nome utente e senza indicare a quale realm amministrativo Kerberos     ¦
 ¦ appartengono, il sistema aggiunge il realm predefinito. Il realm          ¦
 ¦ predefinito potrebbe anche essere usato come realm di un servizio         ¦
 ¦ Kerberos in esecuzione sulla macchina locale. Spesso, il realm            ¦
 ¦ predefinito, è la versione in maiuscolo del dominio DNS locale.           ¦
 ¦                                                                           ¦
 ¦ Realm predefinito per Kerberos versione 5:                                ¦
 ¦                                                                           ¦
 ¦ ACME.LOCAL_______________________________________________________________ ¦
 ¦                                                                           ¦
 ¦                                  <OK>                                     ¦
 ¦                                                                           ¦
 +---------------------------------------------------------------------------+

Diamo ok…

Configurazione del pacchetto

 +--------------¦ Configurazione dell'autenticazione Kerberos +--------------+
 ¦                                                                           ¦
 ¦ Solitamente i client trovano i server Kerberos del proprio realm          ¦
 ¦ predefinito tramite il DNS. I server del proprio realm sono stati         ¦
 ¦ trovati nel DNS. Nella maggior parte dei casi è meglio usare il DNS per   ¦
 ¦ cercare questi server così quando l'insieme dei server del proprio realm  ¦
 ¦ cambia, non sarà necessario riconfigurare ogni macchina del realm. È      ¦
 ¦ comunque possibile, in casi particolari, configurare localmente           ¦
 ¦ l'insieme dei server del proprio realm Kerberos.                          ¦
 ¦                                                                           ¦
 ¦ Aggiungere i server Kerberos predefiniti in /etc/krb5.conf?               ¦
 ¦                                                                           ¦
 ¦                    <Sì>                        <No>                       ¦
 ¦                                                                           ¦
 +---------------------------------------------------------------------------+

…e scegliamo No. Lasciamo che sia il DNS a scovare il servizio Kerberos.
Il protocollo Kerberos impone che il cosiddetto clock skew (differenza di orario) tra client e server sia inferiore a 5 minuti, per evitare che un utente possa resettare il proprio orologio e continuare ad usare un ticket Kerberos scaduto. Per questo motivo, è fondamentale che le due macchine Linux e Windows siano sincronizzate. Consiglio a tal proposito di installare NTP (Network Time Protocol), che assolve allo scopo in modo automatico e trasparente:

lorenzo@smbserver:~$ sudo apt-get install ntp

Editiamo il file di configurazione, per dire a ntp di leggere l’ora dal nostro server Windows:

lorenzo@smbserver:~$ sudo nano /etc/ntp.conf

Scendiamo di qualche riga. Troveremo queste direttive:

server 0.debian.pool.ntp.org iburst
server 1.debian.pool.ntp.org iburst
server 2.debian.pool.ntp.org iburst
server 3.debian.pool.ntp.org iburst

Commentiamole tutte mettendo un carattere # all’inizio della riga, e aggiungiamo il nostro server Windows:

#server 0.debian.pool.ntp.org iburst
#server 1.debian.pool.ntp.org iburst
#server 2.debian.pool.ntp.org iburst
#server 3.debian.pool.ntp.org iburst
server 192.168.50.20 iburst

Riavviamo il servizio:

lorenzo@smbserver:~$ sudo service ntp restart

A questo punto dovremmo poter inizializzare un ticket per l’utente administrator:

lorenzo@smbserver:~$ kinit administrator
Password for administrator@ACME.LOCAL:

Inseriamo la password che abbiamo assegnato all’utente Administrator del dominio. Se abbiamo fatto tutto correttamente, non dovremmo vedere messaggi. Abbiamo un ticket Kerberos pronto per l’accesso ai servizi Active Directory di Windows. Ci manca solo Winbind per completare l’integrazione con il dominio, dopodiché passeremo a Samba.

4. Installazione e configurazione di Winbind

Winbind è un componente che fornisce l’interfaccia verso il mondo Windows per il sistema NSS (Name Service Switch). Tramite NSS, il sistema può disporre di diverse sorgenti per vari database di configurazione e risoluzione dei nomi. Così, ad esempio, ai tradizionali file locali /etc/passwd e /etc/group per la gestione degli account, si possono affiancare sorgenti di dati NIS, LDAP, e via dicendo. Ecco dove Winbind entra in gioco: tramite esso, gli utenti e i gruppi di dominio diventano a pieno titolo utenti e gruppi di Linux, con un proprio UID e GID, come se fossero elencati nei file locali /etc/passwd e /etc/group. Le applicazioni vedranno questi nuovi utenti in modo trasparente, senza apportare alcuna modifica.
Iniziamo a installare Winbind:

lorenzo@smbserver:~$ sudo apt-get install winbind

Editiamo il file di configurazione. Winbind condivide il file di configurazione con Samba, in quanto fa parte della medesima suite. Conviene rinominare il file di default e crearne uno nuovo:

lorenzo@smbserver:~$ sudo mv /etc/samba/smb.conf /etc/samba/smb.conf.distrib
lorenzo@smbserver:~$ sudo nano /etc/samba/smb.conf

Inseriamo quanto segue:

[global]
        unix charset = UTF8
        display charset = UTF8

        netbios name = SMBSERVER
        workgroup = ACME
        realm = ACME.LOCAL

        log file = /var/log/samba/log.%M.%U
        max log size = 500

        server string = Samba Server

        security = ads
        winbind separator = ^
        winbind uid = 10000-20000
        winbind gid = 10000-20000
        winbind enum users = yes
        winbind enum groups = yes
        idmap backend = rid

        load printers = no
        printing = bsd
        printcap name = /dev/null
        disable spoolss = yes

        local master = no
        dns proxy = no

        template shell = /usr/sbin/nologin
        template homedir = /dev/null

        socket options = IPTOS_LOWDELAY TCP_NODELAY SO_SNDBUF=8192 SO_RCVBUF=8192

        hosts allow = 127.0.0.1 192.168.50.0/24
        hosts deny = 0.0.0.0/0

[dati]
        comment = file condivisi
        path = /var/fileserver/dati
        read only = no
        browseable = yes

Per ora osserviamo solo le direttive dalla riga winbind separator = ^ alla riga idmap backend = rid: stiamo dicendo a Winbind di prelevare utenti e gruppi da Active Directory, calcolando UID e GID a partire dal RID (Relative IDentifier) fornito dal controller Windows e rimappandolo nel range 10000-20000. Così, ad esempio, un utente di dominio che ha RID = 1500 prenderà un UID = 11500. Il range deve essere scelto con cura, per evitare che entità locali e entità del dominio possano avere UID o GID sovrapposti. Winbind userà il carattere ^ per separare il nome di dominio dal nome dell’utente, come vedremo più avanti.
Ora dobbiamo istruire NSS perché si interfacci con Winbind. Editiamo il file /etc/nsswitch.conf:

lorenzo@smbserver:~$ sudo nano /etc/nsswitch.conf

In grassetto le parti da aggiungere:

# /etc/nsswitch.conf
#
# Example configuration of GNU Name Service Switch functionality.
# If you have the `glibc-doc-reference' and `info' packages installed, try:
# `info libc "Name Service Switch"' for information about this file.

passwd:         compat winbind
group:          compat winbind
shadow:         compat winbind

hosts:          files dns winbind wins
networks:       files

protocols:      db files winbind
services:       db files winbind
ethers:         db files
rpc:            db files

netgroup:       nis winbind

Salviamo e usciamo. È il momento di agganciarsi al dominio e testare il collegamento ad Active Directory:

lorenzo@smbserver:~$ sudo net ads join -U administrator
Enter administrator's password:
Using short domain name -- ACME
Joined 'SMBSERVER' to realm 'acme.local'

Inseriamo la password di Administrator quando richiesta. Quindi riavviamo il servizio Winbind:

lorenzo@smbserver:~$ sudo service winbind restart

Testiamo il collegamento:

lorenzo@smbserver:~$ wbinfo -u
SMBSERVER^nobody
SMBSERVER^lorenzo
ACME^administrator
ACME^guest
ACME^krbtgt
ACME^lorenzom

Gli utenti di dominio vengono visti come utenti locali:

lorenzo@smbserver:~$ getent passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
...
ntp:x:105:109::/home/ntp:/bin/false
ACME^administrator:*:10500:10513:Administrator:/dev/null:/usr/sbin/nologin
ACME^guest:*:10501:10514:Guest:/dev/null:/usr/sbin/nologin
ACME^krbtgt:*:10502:10513:krbtgt:/dev/null:/usr/sbin/nologin
ACME^lorenzom:*:11104:10513:Lorenzo Monti:/dev/null:/usr/sbin/nologin

Cominciate a divertirvi?

5. Installazione e configurazione di Samba

Manca solo un piccolo passaggio: l’installazione di Samba.

lorenzo@smbserver:~$ sudo apt-get install samba

Il file di configurazione è già stato inserito. Per i dettagli rimando alla pagina man:

lorenzo@smbserver:~$ man smb.conf

Non è questa la sede per esplorare le mille opzioni di Samba, che dispone di una letteratura mostruosamente ampia, sia in rete che in libreria. Anche i forum sono un’ottima fonte di informazione e di aiuto. Consiglio di visitare il sito http://lists.samba.org/.
Assegniamo i permessi di lettura e scrittura agli utenti del dominio sulla directory condivisa. Per far questo ci servono le utility ACL:

lorenzo@smbserver:~$ sudo apt-get install acl

Assegniamo i permessi:

lorenzo@smbserver:~$ sudo setfacl -m g:ACME^domain\ users:rwx /var/fileserver/dati
lorenzo@smbserver:~$ sudo setfacl -d -m g:ACME^domain\ users:rwx /var/fileserver/dati

Gli appartenenti al gruppo ACME\domain users hanno ora permesso di lettura e scrittura sulla directory condivisa. L’opzione -d fa sì che l’ACL venga propagata a tutti gli oggetti (file e directory) figli della directory /var/fileserver/dati.
Testiamo la condivisione dal client Windows XP:
Windows XP client
Provate con un copia-incolla un po’ cattivo. La velocità di trasferimento vi sorprenderà!

Giù il pedale a tavoletta senza paura, la tenuta di strada è da F1!

Abbiamo allocato 10GB di spazio per i nostri utenti in rete. Che ne direste di allocarne altri 10, a caldo, proprio mentre il vostro capo sta spostando sul nuovo server le foto del cane e dei figli in piscina?
Allarghiamo per prima cosa il Logical Volume:

lorenzo@smbserver:~$ sudo lvresize -L +10g /dev/vg0/lv0
  Extending logical volume lv0 to 20,00 GiB
  Logical volume lv0 successfully resized

Ed ora allarghiamo il filesystem sovrastante:

lorenzo@smbserver:~$ sudo xfs_growfs /var/fileserver/
meta-data=/dev/mapper/vg0-lv0    isize=256    agcount=4, agsize=655360 blks
         =                       sectsz=512   attr=2
data     =                       bsize=4096   blocks=2621440, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0
log      =internal               bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
data blocks changed from 2621440 to 5242880

Et voilà. 20GB di spazio!

lorenzo@smbserver:~$ df -h
File system           Dim. Usati Disp. Uso% Montato su
/dev/sda2             4,6G  769M  3,6G  18% /
tmpfs                 252M     0  252M   0% /lib/init/rw
udev                  247M  176K  247M   1% /dev
tmpfs                 252M     0  252M   0% /dev/shm
/dev/sda1              92M   20M   67M  24% /boot
/dev/sda3             2,8G   69M  2,6G   3% /home
/dev/mapper/vg0-lv0    20G  4,4M   20G   1% /var/fileserver

Per approfondire: http://www.tldp.org/HOWTO/LVM-HOWTO/index.html
Buon divertimento!

2 pensieri su “Creare un file server integrato con Active Directory utilizzando Linux, Samba e Winbind

  1. Ciao, per prima cosa ti faccio i complimenti per l’articolo, è molto ben scritto e spiegato. sono riuscito a seguirti in tutto. Ho un problema però, che non capisco se sono dovuti al nostro Server Windows AD o a miei errori. Posso chiederti? anche in privato magari mandando la mia configurazione, o non rispondi a richieste del genere? Grazie in anticipo e aldilà della tua risposta, ancora complimenti,
    ciao
    Emanuele

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

*