i Unix

Eccoci dunque ad usare “disconi”…

Non si possono partizionare con gli strumenti classici (disk/cfdisk) dato che il partizionamento msdos non permette partizioni più grandi di 2TB.

Utilizziamo quindi gnu parted (gparted)

# parted -a optimal /dev/sdd
GNU Parted 2.3
Using /dev/sdd
Welcome to GNU Parted! Type 'help' to view a list of commands.

creiamo il partizionamento GPT e creiamo la partizione principale:

(parted) mklabel gpt
Warning: The existing disk label on /dev/sdc will be destroyed and all data on this disk will be lost. Do you want to
continue?
Yes/No? yes
(parted) mkpart primary 1 -1
(parted) print
Model: ATA WDC WD30EZRX-00M (scsi)
Disk /dev/sdc: 3001GB
Sector size (logical/physical): 512B/4096B
Partition Table: gpt

Number Start End Size File system Name Flags
1 1049kB 3001GB 3001GB primary

(parted) align-check
alignment type(min/opt) [optimal]/minimal?
Partition number? 1
1 aligned

controllino:

(parted) print
Model: ATA WDC WD30EZRX-00M (scsi)
Disk /dev/sdc: 3001GB
Sector size (logical/physical): 512B/4096B
Partition Table: gpt

Number Start End Size File system Name Flags
1 1049kB 3001GB 3001GB primary

(parted) quit

adesso facciamo la stessa cosa per il secondo disco e procediamo alla creazione del dispositivo MD:

# mdadm --create /dev/md1 --level=mirror --raid-devices=2 /dev/sdc1 missing
mdadm: /dev/sdc1 appears to be part of a raid array:
level=raid1 devices=2 ctime=Thu Sep 13 19:00:45 2012
mdadm: Note: this array has metadata at the start and
may not be suitable as a boot device. If you plan to
store '/boot' on this device please ensure that
your boot-loader understands md/v1.x metadata, or use
--metadata=0.90
Continue creating array? yes
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md1 started.

creiamo il file system:

# mkfs.ext4 -m 0 -L SPACE /dev/md1
mke2fs 1.41.12 (17-May-2010)
Etichetta del filesystem=SPACE
Tipo SO: Linux
Dimensione blocco=4096 (log=2)
Dimensione frammento=4096 (log=2)
Stride=1 blocks, Stripe width=0 blocks
183148544 inode, 732565982 blocchi
0 blocchi (0.00%) riservati per l'utente root
Primo blocco dati=0
Maximum filesystem blocks=4294967296
22357 gruppi di blocchi
32768 blocchi per gruppo, 32768 frammenti per gruppo
8192 inode per gruppo
Backup del superblocco salvati nei blocchi:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968,
102400000, 214990848, 512000000, 550731776, 644972544

Scrittura delle tavole degli inode: fatto
Creating journal (32768 blocks): fatto
Scrittura delle informazioni dei superblocchi e dell'accounting del filesystem: fatto

l’array è ancora degradato:

# cat /proc/mdstat
Personalities : [raid1]
md1 : active raid1 sdc1[0]
2930263928 blocks super 1.2 [2/1] [U_]

aggiungiamo il secondo disco all’array:

# mdadm --manage /dev/md1 --add /dev/sdd1
mdadm: added /dev/sdd1

e controlliamo lo stato del riallineamento:

# cat /proc/mdstat
Personalities : [raid1]
md1 : active raid1 sdd1[2] sdc1[0]
2930263928 blocks super 1.2 [2/1] [U_]
[>....................] recovery = 0.0% (2553536/2930263928) finish=496.8min speed=98212K/sec

 montiamo il filesystem e controlliamo:

# mount LABEL=SPACE /space/
# df -H /space
File system Dim. Usati Disp. Uso% Montato su
/dev/md1 3,0T 211M 3,0T 1% /space

 fatto.

Linux ha il comando ssh-copy-id che permette la copia della propia chiave pubblica ssh su un altro server, ma non tutte le varianti *nix hanno tale programma. Per copiare la propria chiave pubblica ssh su un server, da una macchina che non ha ssh-copy-id, ad esempio Mac OSX, di può ricorrere al seguente comando da lanciare nel terminale di OSX:

cat ~/.ssh/id_rsa.pub | ssh utente@dominio.estensione "mkdir ~/.ssh; cat >> ~/.ssh/authorized_keys"
dove utente@dominio.estensione rappresenta l’utente ed il server su cui attivare l’accesso senza dover inserire la password ogni volta.

Per consentire l’accesso SSH all’utente root solo con il certificato (bloccando la connessione con password), bisogna modificare il file /etc/ssh/sshd_config ed in particolare impostare la direttiva:

PermitRootLogin without-password
riavviare poi il servizio con il classico:

/etc/init.d/ssh restart

Ecco un banale script python per estrarre gli url delle immagini da un file css
Nel file gli url saranno nella forma: url(‘http://www.qualcosa.com/immagine.png’)

#!/usr/bin/python
import string, os

f=open("file.css", "r")

allf=f.read()

while string.find(allf, 'url') > 0:
    a = string.split(allf, "url(\'", 1)
    b = string.split(a[1], "\')", 1)
    print b[0]
    allf = b[1]

Facile ricetta, 1 stella di difficoltà.

se vogliamo effettuare una copia di un disco locale su una macchina remota:

dd if=/dev/sdX | ssh host.destinazione.com dd of=file.dd

se vogliamo anche comprimere:

dd if=/dev/sdX | gzip -1 | ssh host.destinazione.com gzip -dc | dd of=file.dd

🙂

E’ il più banale dei problemi eppure tutte le volte ci perdo il capo.

Cambiare in una cartella, in modo ricorsivo, tutti i diritti di file e cartelle impostando, per esempio, 0660 per i file (r w – r w – – – ) e 0770 per le cartelle (r w x r w x – – ).

facciamo un bel:

chmod -R 0660 *
find . -type d -exec chmod 0770 '{}' \;

ed è tutto fatto!

🙂

Per connettere un server samba (basato su debian, ovviamente) ad un dominio Active Directory possiamo utilizzare i tool di LikeWise:

scarichiamo i tool dal sito BeyondTrust oppure da qui nelle versioni per i386, amd64 (e anche per OsX)

rendiamo eseguibile lo script

# chmod a+x LikewiseOpen-6.0.0.8388-linux-amd64-deb.sh

e lo eseguiamo:

# ./LikewiseOpen-6.0.0.8388-linux-amd64-deb.sh

e seguiamo tutte le istruzioni.
al termine della procedura connettiamo il server al dominio Active Directory (qui il dominio si chiama ”dominio” ed il suo fqdn è ”dominio.fqdn.com”):

# domainjoin-cli join dominio.fqdn.com administrator

riavviamo.

possiamo connetterci al server con un utente di dominio utilizzando la sintassi:

# ssh dominio\nomeutente@ip.del.server

a questo punto, dopo essere diventati root con ”su” possiamo controllare lo stato del sistema:

# /opt/likewise/bin/lwsm list
lwreg       running (standalone: 1185)
dcerpc      running (standalone: 1718)
eventlog    running (standalone: 1730)
lsass       running (standalone: 1493)
lwio        running (standalone: 1344)
netlogon    running (standalone: 1285)
rdr         running (io: 1344)

e

# /opt/likewise/bin/domainjoin-cli query
Name = nomeserver
Domain = DOMINIO.FQDN.COM
Distinguished Name = CN=NAS,CN=Computers,DC=dominio,DC=fqdn,DC=com

e con:

# /opt/likewise/bin/lw-get-status
[cut]

per avere informazioni su un utente di dominio possiamo:

# id dominio\nomeutente
uid=278922328(DOMINIOnomeutente) gid=278921729(DOMINIOdomain^users) gruppi=278921729(DOMINIOdomain^users)

per controllare ulteriormente la presenza di un utente:

# /opt/likewise/bin/lw-find-user-by-name DOMINIO\nomeutente
User info (Level-0):
====================
Name:              DOMINIOnomeutente
SID:               S-1-5-21-2525912273-188867155-4035306855-1112
Uid:               278922328
Gid:               278921729
Gecos:             Nome Utente
Shell:             /bin/sh
Home dir:          /home/local/DOMINIO/nomeutente
Logon restriction: NO

e

# wbinfo -i DOMINIO\nomeutente
DOMINIOnomeutente:x:278922328:278921729:Nome Utente:/home/local/DOMINIO/nomeutente:/bin/sh

e testiamo la connessione con password:

 wbinfo -a DOMINIO\nomeutente%PASSWORD
plaintext password authentication succeeded

adesso che l’autenticazione funziona perfettamente passiamo a modificare la configurazione di samba, con l’aggiunta di una condivisione di esempio:

/etc/samba/smb.conf:
# Global Settings
[global]
   workgroup = DOMINIO
   server string = %h server
# Authentication #
   security = ADS
   realm = DOMINIO.FQDN.COM
   machine password timeout = 0
   encrypt passwords = true
   passdb backend = tdbsam
   obey pam restrictions = yes
   unix password sync = yes
   pam password change = yes
# condivisione
[Condivisione]
   comment = Condivisione
   path = /raid/condivisione
   browseable = yes
   read only = no
   create mask = 0660
   directory mask = 0770
   valid users = @DOMINIOdomain^users

modifichiamo i permessi ed il proprietario della condivisione:

# chmod 0770 /raid/condivisione
# chown DOMINIO\nomeutente:DOMINIO\domain^users /raid/condivisione

controlliamo se la versione è corretta:

# /opt/likewise/bin/samba-interop-install --check-version
Found smbd version 3.5.6
Samba version supported

adesso dobbiamo usare il comando magico:

# /opt/likewise/bin/samba-interop-install --install
# service samba restart
# service winbind restart

testiamo la connessione con il dominio:

# net ads testjoin
Join is OK

tutto ok?

🙂

Abbiamo una condivisione samba con le opzioni:

  force group = nomegruppo
  create mask = 0660
  directory mask = 0770

l’intenzione è quella di scrivere i file forzando il gruppo su “nomegruppo” in modo che tutti gli utenti di quel gruppo possano scrivere, modificare e cancellare i file creati.

I permessi dei file saranno -rw-rw—- e quelli delle cartelle -rwxrwx—

Quando però accediamo a questa condivisione con OsX troviamo i permessi dei file nella condizione -rw-r—–. Il gruppo può solamente leggere ma non modificare o cancellare.

Per ovviare a questo problema dobbiamo aggiungere una direttiva nella sezione [globals] del file di configurazione di samba (/etc/samba/smb.conf):

unix extensions = off

e riavviare samba:

# service samba restart

🙂

per prima cosa aggiungiamo gli utenti necessari:

# adduser nomeutente

poi lo aggiungiamo agli utenti samba:

# smbpasswd -a nomeutente

a questo punto, dopo aver creato tutti gli utenti, creiamo i gruppi:

# addgroup nomegruppo

baseremo le nostre condivisioni sui gruppi, dobbiamo quindi aggiungere gli utenti ai gruppi (mettere gli utenti dentro i gruppi):

# usermod -a -G nomegruppo nomeutente

in questo modo abbiamo messo l’utente ”nomeutente” dentro il gruppo ”nomegruppo”

creiamo la condivisione e aggiustiamo i permessi:

# mkdir /raid/condivisione
# chown  nomeutente:nomegruppo /raid/condivisione
# chmod 0770 /raid/nomecondivisione

a questo punto possiamo passare a modificare la configurazione di samba (/etc/samba/smb.conf).
Aggiungiamo la definizione della condivisione:

[NomeCondivisione]
  path = /raid/nomecondivisione
  read only = no
  force group = nomegruppo
  create mask = 0660
  directory mask = 0770
  valid users = nomeutente, nomeutente2, nomeutente3

e riavviamo samba

# service samba restart

a questo punto possiamo accedere dalla rete alla condivisione. I file creati saranno di proprietà dell’utente connesso ma saranno modificabili da tutti gli utenti appartenenti al gruppo.

🙂

Se creiamo un dispositivo MD su linux (sia raid 1 che raid 5) la ricostruzione inizia immediatamente.

Se vogliamo creare anche il filesystem e magari fare qualche prova appena effettuata la creazione possiamo andare incontro a rallentamenti veramente imbarazzanti (specie su dischi di grande capienza)

Si può ovviare a tutto questo creando un raid degradato – per il sistema è impossibile aggiornare il mirror o i dati di ridondanza quindi momentaneamente il raid non viene riallineato e lo possiamo utilizzare per fare le nostre prove.

vediamo come

# apt-get install mdadm

mdadm --create /dev/md0 --level=mirror --raid-devices=2 /dev/sda1 missing
mdadm: Note: this array has metadata at the start and
    may not be suitable as a boot device.  If you plan to
    store '/boot' on this device please ensure that
    your boot-loader understands md/v1.x metadata, or use
    --metadata=0.90
Continue creating array? y
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md0 started.

se controlliamo lo stato del dispositivo:

# cat /proc/mdstat
Personalities : [raid1]
md0 : active raid1 sda1[0]
      1953510841 blocks super 1.2 [2/1] [U_]
 unused devices:

vediamo che è degradato ed in questo momento non c’è il riallineamento

possiamo creare il filesystem velocemente e fare tutte le prove del caso:

# mkfs.ext4 -m 1 -L RAID /dev/md0
mke2fs 1.41.12 (17-May-2010)
Etichetta del filesystem=RAID
Tipo SO: Linux
Dimensione blocco=4096 (log=2)
Dimensione frammento=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
122101760 inode, 488377710 blocchi
4883777 blocchi (1.00%) riservati per l'utente root
Primo blocco dati=0
Maximum filesystem blocks=4294967296
14905 gruppi di blocchi
32768 blocchi per gruppo, 32768 frammenti per gruppo
8192 inode per gruppo
Backup del superblocco salvati nei blocchi:
	32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
	4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968,
	102400000, 214990848
Scrittura delle tavole degli inode: fatto
Creating journal (32768 blocks): fatto
Scrittura delle informazioni dei superblocchi e dell'accounting del filesystem: fatto
Questo filesystem verrà automaticamente controllato ogni 26 mount, o
180 giorni, a seconda di quale venga prima. Usare tune2fs -c o -i per cambiare.

appena finito aggiungiamo al raid il disco mancante; inizierà il riallineamento

# mdadm --manage /dev/md0 --add /dev/sdb1
mdadm: added /dev/sdb1

a questo punto parte la sincronizzazione dei due dischi:

cat /proc/mdstat
# cat /proc/mdstat
Personalities : [raid1]
md0 : active raid1 sdb1[2] sda1[0]
      1953510841 blocks super 1.2 [2/1] [U_]
      [>....................]  recovery =  0.0% (1430016/1953510841) finish=788.5min speed=41258K/sec
unused devices:

e ci vorrà un bel pò…

🙂

Per rimuovere da un disco il partizionamento di tipo GPT si può procedere così:

# apt-get install parted

appena installato parted eseguirlo (tipicamente parted /dev/sdx)

al prompt di parted eseguire “mktable” e definire una partizione msdos

# parted /dev/sdb
GNU Parted 2.3
Using /dev/sdb
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) mktable
New disk label type? msdos
(parted) quit
Information: You may need to update /etc/fstab.

la partizione gpt è sparita!

🙂