Lo primero de haremos será crear un fichero que emulará la partición /tmp, por ejemplo de 500 MB.

#dd if=/dev/zero of=/dev/tmpTL bs=1024 count=500000


A continuación lo formateamos con nuestro sistema de archivos en mi caso etx3.

#/bin/mke2fs -j /dev/tmpTL

Luego hacemos un backup de nuestro actual /tmp, por si tuviésemos algún dato importante ahí (aunque no deberiamos tener gran cosa):

#mkdir /backup && cp -R /tmp /backup

Luego montamos nuestro nuevo archivo /tmp:

#mount -o loop,noexec,nosuid,rw /dev/tmpTL /tmp


Y lo agregamos en el /etc/fstab para que la proxima vez que reiniciemos todo siga funcionando.

/dev/tmpTL /tmp ext2 loop,noexec,nosuid,rw 0 0


Luego de montarlo y que todo este bien vamos a otorgar los permisos adecuados al archivo recien creado /tmp creado:

#chmod 1777 /tmp


Copiamos el contenido que teniamos en el antiguo /tmp

#cp -R /backup/* /tmp/


Aclaracion: El hostname del hypervisor es: xendom0

1.- Instalando los paquetes necesarios.


xendom0:~# apt-get install linux-image-2.6.26-2-xen-amd64


Cuando hayamos instalado estos paquetes vamos a tener una nueva entrada en el archivo /boot/grub/menu.lst

title Debian GNU/Linux, kernel 2.6.26-2-xen-amd64
root (hd0,0)
kernel /boot/vmlinuz-2.6.26-2-xen-amd64 root=/dev/sda1 ro quiet
initrd /boot/initrd.img-2.6.26-2-xen-amd64


title Debian GNU/Linux, kernel 2.6.26-2-xen-amd64 (single-user mode)
root (hd0,0)
kernel /boot/vmlinuz-2.6.26-2-xen-amd64 root=/dev/sda1 ro single
initrd /boot/initrd.img-2.6.26-2-xen-amd64


2.- Instalacion de las herramientas xen.

Esto va a tardar un rato dependiendo del ancho de banda de internet. Quisiera mensionar como interesante que se van a instalar como dependencias las bridge-tools estas herramientas van a permitir que el dom0 (hypervisor), sea bridge de las domU (maquinas virtuales).


xendom0:~# apt-get install xen-tools


3.- Aumentar el numero de loops del equipo
Dado que el número máximo de dispositivos loop que existen en el sistema es por defecto 8 y que cada máquina virtual usa 2, para arrancar más de 4 máquinas virtuales tenemos que incrementar este valor. Para hacer esto vamos a modificar el archivo /etc/modules modificando la linea que dice loop, observar que comente con varios “#” la linea original del archivo.

xendom0:~# cat /etc/modules
# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with "#" are ignored.
# Parameters can be specified after the module name.

### loop max_loop=64


4.- Reiniciar el equipo.

Simplemente

xendom0:~# reboot


4.- Verificamos si el kernel con el que arranco el equipo es el adecuado.


xendom0:~# uname -r
2.6.26-2-xen-amd64


5.- Configurando la red Bridge en XEN

# Configurar la red: para que dom0 funcione en modo puente (paquete bridge-utils) editaremos
/etc/xen/xend-config.sxp, comentaremos la línea:

# (network-script network-dummy)

y verificar que las siguientes líneas esten descomentadas:

(network-script network-bridge)
(vif-script vif-bridge)
(dom0-min-mem 196)
(dom0-cpus 0)


6.- Reiniciar el servicio de xen:

xendom0:~# /etc/init.d/xend stop
xendom0:~# /etc/init.d/xend start

7.- Verificar que el servicio de xen este corriendo.


xendom0:~# xm list
Name ID Mem VCPUs State Time(s)
Domain-0 0 811 1 r----- 15.4


Vamos a verificar ahora el kernel del dom0


xendom0:~# xm dmesg
(XEN) Xen version 3.2-1 (Debian 3.2.1-2) (waldi@debian.org) (gcc version 4.3.1 (Debian 4.3.1-2) ) Sat Jun 28 09:32:18 UTC 2008
(XEN) Command line:
(XEN) Video information:
(XEN) VGA is text mode 80x25, font 8x16
(XEN) VBE/DDC methods: none; EDID transfer time: 0 seconds
(XEN) EDID info not retrieved because no DDC retrieval method detected
(XEN) Disc information:
(XEN) Found 1 MBR signatures
(XEN) Found 1 EDD information structures
(XEN) Xen-e820 RAM map:
(XEN) 0000000000000000 - 000000000009f800 (usable)
(XEN) 000000000009f800 - 00000000000a0000 (reserved)
(XEN) 00000000000e7000 - 0000000000100000 (reserved)
(XEN) 0000000000100000 - 0000000037fb0000 (usable)
(XEN) 0000000037fb0000 - 0000000037fc0000 (ACPI data)
(XEN) 0000000037fc0000 - 0000000037ff0000 (ACPI NVS)
(XEN) 0000000037ff0000 - 0000000038000000 (reserved)
(XEN) 00000000fec00000 - 00000000fec01000 (reserved)
(XEN) 00000000fee00000 - 00000000fef00000 (reserved)
(XEN) 00000000fff80000 - 0000000100000000 (reserved)
(XEN) System RAM: 895MB (916796kB)
(XEN) Xen heap: 14MB (15048kB)
(XEN) Domain heap initialised: DMA width 32 bits
(XEN) Processor #0 0:6 APIC version 16
(XEN) IOAPIC[0]: apic_id 1, version 17, address 0xfec00000, GSI 0-23
(XEN) Enabling APIC mode: Flat. Using 1 I/O APICs
(XEN) Using scheduler: SMP Credit Scheduler (credit)
(XEN) Detected 2712.343 MHz processor.
(XEN) AMD SVM: ASIDs enabled.
(XEN) HVM: SVM enabled
(XEN) HVM: Hardware Assisted Paging detected and enabled.
(XEN) CPU0: AMD Sempron(tm) Processor 140 Processor stepping 02
(XEN) Total of 1 processors activated.
(XEN) ENABLING IO-APIC IRQs
(XEN) -> Using new ACK method
(XEN) ..MP-BIOS bug: 8254 timer not connected to IO-APIC
(XEN) works.
(XEN) Platform timer overflows in 234 jiffies.
(XEN) Platform timer is 3.579MHz ACPI PM Timer
(XEN) Brought up 1 CPUs
(XEN) AMD IOMMU: Disabled
(XEN) *** LOADING DOMAIN 0 ***
(XEN) Xen kernel: 64-bit, lsb, compat32
(XEN) Dom0 kernel: 64-bit, lsb, paddr 0x200000 -> 0x631918
(XEN) PHYSICAL MEMORY ARRANGEMENT:
(XEN) Dom0 alloc.: 0000000032000000->0000000034000000 (199618 pages to be allocated)
(XEN) VIRTUAL MEMORY ARRANGEMENT:
(XEN) Loaded kernel: ffffffff80200000->ffffffff80631918
(XEN) Init. ramdisk: ffffffff80632000->ffffffff81bd2200
(XEN) Phys-Mach map: ffffffff81bd3000->ffffffff81d68e10
(XEN) Start info: ffffffff81d69000->ffffffff81d694a4
(XEN) Page tables: ffffffff81d6a000->ffffffff81d7d000
(XEN) Boot stack: ffffffff81d7d000->ffffffff81d7e000
(XEN) TOTAL: ffffffff80000000->ffffffff82000000
(XEN) ENTRY ADDRESS: ffffffff80200000
(XEN) Dom0 has maximum 1 VCPUs
(XEN) Initrd len 0x15a0200, start at 0xffffffff80632000
(XEN) Scrubbing Free RAM: done.
(XEN) Xen trace buffers: disabled
(XEN) Std. Loglevel: Errors and warnings
(XEN) Guest Loglevel: Nothing (Rate-limited: Errors and warnings)
(XEN) Xen is relinquishing VGA console.
(XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen)
(XEN) Freed 104kB init memory.
(XEN) ioapic_guest_write: apic=0, pin=2, old_irq=-1, new_irq=0
(XEN) ioapic_guest_write: old_entry=00010000, new_entry=000009f0
(XEN) ioapic_guest_write: Installing bogus unmasked IO-APIC entry!


Tambien podemos seguir obteniendo informacion de xen con el comando:


xendom0:~# xm info
host : xendom0
release : 2.6.26-2-xen-amd64
version : #1 SMP Wed May 12 18:37:58 UTC 2010
machine : x86_64
nr_cpus : 1
nr_nodes : 1
cores_per_socket : 1
threads_per_core : 1
cpu_mhz : 2712
hw_caps : 078bf3ff:efd3fbff:00000000:00000110:00802001:000037fd:000037fd
total_memory : 895
free_memory : 54
node_to_cpu : node0:0
xen_major : 3
xen_minor : 2
xen_extra : -1
xen_caps : xen-3.0-x86_64 xen-3.0-x86_32p hvm-3.0-x86_32 hvm-3.0-x86_32p hvm-3.0-x86_64
xen_scheduler : credit
xen_pagesize : 4096
platform_params : virt_start=0xffff800000000000
xen_changeset : unavailable
cc_compiler : gcc version 4.3.1 (Debian 4.3.1-2)
cc_compile_by : waldi
cc_compile_domain : debian.org
cc_compile_date : Sat Jun 28 09:32:18 UTC 2008
xend_config_format : 4


1.- crear los volumenes fisicos:

[root@rh ~]# pvcreate /dev/hda8
Physical volume "/dev/hda8" successfully created
[root@rh ~]# pvcreate /dev/hda9
Physical volume "/dev/hda9" successfully created
[root@rh ~]# pvcreate /dev/hda10
Physical volume "/dev/hda10" successfully created


2.- Juntar los volumenes fisicos en un Grupo de Volumenes

Todos forman una misma unidad.

[root@rh ~]# vgcreate VG0 /dev/hda8 /dev/hda9 /dev/hda10
Volume group "VG0" successfully created


3.- Vamos a verificar cual es el tamaño del VG podemos observar que es de 1.49G
Tambien vemos que esta compuesto por tres volumenes fisicos /dev/hda8, /dev/hda9 y /dev/hda10

[root@rh ~]# vgdisplay -v VG0
--- Volume group ---
VG Name VG0
System ID
Format lvm2
Metadata Areas 3
Metadata Sequence No 1
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 0
Open LV 0
Max PV 0
Cur PV 3
Act PV 3
VG Size 1,49 GB
PE Size 4,00 MB
Total PE 381
Alloc PE / Size 0 / 0
Free PE / Size 381 / 1,49 GB
VG UUID iNSlQR-Oc5t-fLE3-PwbP-eQcE-89tc-tuDin2
--- Physical volumes ---
PV Name /dev/hda8
PV UUID H8j2q7-1vIl-NsYO-FS6f-QiII-eM4a-I2lFY0
PV Status allocatable
Total PE / Free PE 127 / 63

PV Name /dev/hda10
PV UUID gvqsCV-hwLH-2Vn8-wCkE-4ngv-Cvmw-ktHHHv
PV Status allocatable
Total PE / Free PE 127 / 127


4.- Vamos a tomar una porcion de 256M y le vamos a llamar datos.

[root@rh ~]# lvcreate -L 256M VG0 -n datos
Logical volume "datos" created


5.- vamos a ver como se creo este volumen lògico.

[root@rh ~]# vgdisplay VG0 -v
Using volume group(s) on command line
Finding volume group "VG0"
--- Volume group ---
VG Name VG0
System ID
Format lvm2
Metadata Areas 3
Metadata Sequence No 6
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 1
Open LV 0
Max PV 0
Cur PV 3
Act PV 3
VG Size 1,49 GB
PE Size 4,00 MB
Total PE 381
Alloc PE / Size 64 / 256,00 MB
Free PE / Size 317 / 1,24 GB
VG UUID iNSlQR-Oc5t-fLE3-PwbP-eQcE-89tc-tuDin2

PV Name /dev/hda10
PV UUID gvqsCV-hwLH-2Vn8-wCkE-4ngv-Cvmw-ktHHHv
PV Status allocatable
Total PE / Free PE 127 / 127


6.- Vamos a formatear ese volumen de datos

[root@rh ~]# mkfs.ext3 /dev/VG0/datos
mke2fs 1.39 (29-May-2006)
Etiqueta del sistema de ficheros=
Tipo de SO: Linux
Tamaño del bloque=1024 (bitácora=0)
Tamaño del fragmento=1024 (bitácora=0)
65536 nodos i, 262144 bloques
13107 bloques (5.00%) reservados para el súper usuario
Primer bloque de datos=1
Maximum filesystem blocks=67371008
32 bloque de grupos
8192 bloques por grupo, 8192 fragmentos por grupo
2048 nodos i por grupo
Respaldo del súper bloque guardado en los bloques:
8193, 24577, 40961, 57345, 73729, 204801, 221185
Mientras se escribían las tablas de nodos i: terminado
Creando el fichero de transacciones (8192 bloques): hecho
Escribiendo superbloques y la información contable del sistema de ficheros:
hecho
Este sistema de ficheros se revisará automáticamente cada 39 meses o
180 dias, lo que suceda primero. Utilice tune2fs -c o -i para cambiarlo.


7.- Crear el punto de montaje.

mkdir /mnt/datos


8.- Montar el Volumen Logico.

mount -t ext3 /dev/VG0/datos /mnt/datos


9.- Crear la entrada en /etc/fstab

En debian vamos a usar esta sintaxis:

/dev/VG0/datos /mnt/datos ext3 defaults 0 0

En rh vamos a usar el Label de la particion en vez del dispositivo.

LABEL=DATOS /mnt/datos ext3 defaults 0 0


11.- Supongamos ahora que queremos extender el volumen logico en 512M.


[root@rh ~]# lvextend -L +500M /dev/VG0/datos
Extending logical volume datos to 756,00 MB
Logical volume datos successfully resized


12.- Todavia no terminamos tenemos que ejecutar el comando que cambia el
tamaño del LV.

[root@rh ~]# resize2fs -p /dev/VG0/datos
resize2fs 1.39 (29-May-2006)
Filesystem at /dev/VG0/datos is mounted on /mnt/datos; on-line resizing
required
Performing an on-line resize of /dev/VG0/datos to 774144 (1k) blocks.
The filesystem on /dev/VG0/datos is now 774144 blocks long.


13.- Verificamos los cambios.

[root@rh ~]# vgdisplay VG0 -v
Using volume group(s) on command line
Finding volume group "VG0"
--- Volume group ---
VG Name VG0
System ID
Format lvm2
Metadata Areas 3
Metadata Sequence No 7
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 1
Open LV 1
Max PV 0
Cur PV 3
Act PV 3
VG Size 1,49 GB
PE Size 4,00 MB
Total PE 381
Alloc PE / Size 189 / 756,00 MB
Free PE / Size 192 / 768,00 MB
VG UUID iNSlQR-Oc5t-fLE3-PwbP-eQcE-89tc-tuDin2

PV Name /dev/hda10
PV UUID gvqsCV-hwLH-2Vn8-wCkE-4ngv-Cvmw-ktHHHv
PV Status allocatable
Total PE / Free PE 127 / 127


14.- Reducir el tamaño de una particion en este ejemplo la reducciòn va a ser
de 56M.

Antes que nada desmontar

[root@rh ~]# umount /mnt/datos


[root@rh ~]# resize2fs /dev/VG0/datos 700M
resize2fs 1.39 (29-May-2006)
Por favor corra primero 'e2fsck -f /dev/VG0/datos'.


[root@rh ~]# e2fsck -f /dev/VG0/datos
e2fsck 1.39 (29-May-2006)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
DATOS: 11/194560 files (9.1% non-contiguous), 35331/774144 blocks


Ahora si podemos reducir


[root@rh ~]# resize2fs /dev/VG0/datos 700M
resize2fs 1.39 (29-May-2006)
Resizing the filesystem on /dev/VG0/datos to 716800 (1k) blocks.
The filesystem on /dev/VG0/datos is now 716800 blocks long.


Tambien podemos usar el comando:

[root@rh ~]# lvreduce -L 56M /dev/VG0/datos
WARNING: Reducing active logical volume to 56,00 MB
THIS MAY DESTROY YOUR DATA (filesystem etc.)
Do you really want to reduce datos? [y/n]: y
Reducing logical volume datos to 56,00 MB
Logical volume datos successfully resized


15.- Tambien podemos ahora quitar un volumen fisico del grupo de volumenes.


[root@rh ~]# pvmove /dev/hda10
No data to move for VG0
[root@rh ~]# vgreduce VG0 /dev/hda10
Removed "/dev/hda10" from volume group "VG0"


Esto es todo.

Aclaración: tenemos que instalar OOo en modo gráfico.

1. Descargar el paquete de openoffice teniendo en cuenta que es una paquete (archivo tar.gz) dentro de este se encuentran los archivos .deb para instalar todo el OOo
Vamos a trabajar en el modo gráfico para poder instalar OOo

2. Tenemos que loguearnos como root en una terminal de texto gráfica.
Teniendo en cuenta que debian no nos deja loguearnos con el usuario root en el modo gráfico tenemos que ejecutar los siguientes comandos.

Con el usuario de trabajo levantamos una terminal de texto. En esta terminal de texto ejecutar el comando

$ xhost + (este comando permite que desde cualquier otro equipo o usuario se pueda usar el entorno gráfico)

El siguiente comando nos permite transformarnos en root sin las variables de entorno.

$ su

Tipear la clave de root. Muy bien ahora podemos seguir con la instalacion de OpenOffice.org

3. Si tenemos instalada la versión 2.4 la desinstalamos usando el siguiente comando:

apt-get –purge remove -y openoffice.org openoffice.org-base openoffice.org-base-core openoffice.org-common openoffice.org-core lp-solve openoffice.org-impress openoffice.org-filter-mobiledev openoffice.org-draw libgfortran3 openoffice.org-report-builder-bin libsuitesparse-3.1.0 ttf-liberation openoffice.org-math libblas3gf openoffice.org-officebean liblapack3gf openoffice.org-calc


4. Descomprimir el archivo descargado en el directorio /opt (ahi es donde va a quedar instalado OOo)

cd /opt
tar xzvf OOo.....tar.gz


5. Ahora vamos a instalar OOo con el siguiente comando:


cd OOO300_m9_native_packed-1_es.9358/DEBS/ && dpkg -i *.deb


6. Ahora vamos a instalar la integracion con el escritorio para esto ejecutamos:


cd desktop-integration


5. Instalamos el paquete que hay en ese directorio con el siguiente comando:

dpkg -i openoffice.org3.0-debian-menus_3.0-9354_all.deb


Todo esta ahora instalado

Saludos

En distintos ambientes oportunidades tenemos muchos equipos con el sistema GNU/debian instalados ya sea en casa o en nuestro trabajo y sabemos que debian tiene actualizaciónes constantes, si conectamos todas las maquinas a la vez para actualizar o descargar un software vamos a notar que el ancho de banda de nuestra red decae de manara alarmante. Es por eso es que quiero presentarles a apt-proxy.

apt-proxy es un proxy de paquetes, más sencillo imposible. Con él, cada vez que nos descargamos un paquete, se queda almacenado en su repositorio local, así cuando una máquina pide ese paquete, se lo entregará directamente sin necesidad de descargarlo desde el repositorio original (repositorio debian en internet).

Instalación:

# apt-get install apt-proxy


Una vez que está instalado, tenemos que modificar ver el archivo de configuración, ubicado en /etc/apt-proxy con el nombre apt-proxy-v2.conf. Este se divide en secciones, la sección [DEFAULT] proporciona la configuración de apt-proxy (puerto de escucha, timeouts, tiempo máximo de vida de un paquete,…) Aquí poco nada habrá que tocar, como verémos está todo muy bien comentado y sobra explicar esta sección.

Las secciones que vienen a continuación son las más interesantes. Definen los repositorios. Por ejemplo, vemos que hay una sección que se llama [debian].


[debian]
;; The main Debian archive
;; You can override the default timeout like this:
;timeout = 30
;; Rsync server used to rsync the Packages file (NOT YET IMPLEMENTED)
;;rsyncpackages = rsync://ftp.de.debian.org/debian
;; Backend servers, in order of preference
backends =

ftp://ftp.uk.debian.org/debian


En esta sección tenemos que poner los repositorios donde apt-proxy buscará los paquetes que las demás máquinas (clientes) le piden al servidor bajo el directorio debian. Para entenderlo mejor un ejemplo de sources.list:

deb http://192.168.1.1:9999/debian stable main non-free contrib

Como vemos, esta ip pertenece a mi servidor de apt-proxy y la raíz que pido es la de debian. Entonces apt-proxy buscará una sección que se llame así y mirará qué repositorios puede usar para descargar esos paquetes. Ahora solo nos queda ir máquina por máquina cambiando las sources.list y poniendo nuestro servidor de apt-proxy como fuente única. También es una muy buena idea que nuestro propio servidor tuviera en sus sources.list la dirección del proxy, así cualquier actualización de cualquier máquina pasará por el proxy.

Otra aplicación que se puede usar y que es muy útil se llama apt-move.

Sirve para generar repositorios locales moviendo y generando la estructura de un repositorio.
Lo bueno de esta es que podemos crear un repositorio local en equipos que no tienen internet.

Podemos encontrar un articulo en:
apt-move

Espero que sea de utilidad.

La solucion que linux nos ofece es ACL, listas de control de acceso. Veamos de que se trata.

¿Qué es una ACL?

Es una ACL es una lista de usuarios o grupos Linux que tienen derecho a usar un directorio o un archivo.

1.- Instalando y activando las ACL:

Para garantizar que el sistema acepte acls tenemos que tener en cuenta las siguientes premisas:

1. El nucleo debe soportar y estar compilado para soportar atributos extendidos y ACL.
2. Debemos montar el file system (partición) con atributos extendidos y ACL.
3. Tenemos que instalar las utilidades de espacio de usuario (chacl,getfacl y setfacl) para establecer ACL.

2.- Activación de las ACL.

Soporte ACL del núcleo de sistema:

La gran mayoría de distros actuales ya soportan ACL podemos comprobarlo ejecutando el siguiente comando.

# grep POSIX_ACL /boot/config-`uname -r`
CONFIG_EXT2_FS_POSIX_ACL=y
CONFIG_EXT3_FS_POSIX_ACL=y
CONFIG_REISERFS_FS_POSIX_ACL=y
CONFIG_JFS_POSIX_ACL=y
CONFIG_FS_POSIX_ACL=y
CONFIG_XFS_POSIX_ACL=y
# CONFIG_TMPFS_POSIX_ACL is not set


Como vemos tenemos el soporte de ACLs activado en el kernel. De lo contrario tenemos que recompilarlo teniendo el cuenta marcando estas opciones.
Las ACL pueden aplicarse sobre sistemas de archivos ReiserFS, XFS, Ext3 y otros.

3.- Soporte ACL en /etc/fstab:

Una vez que tenemos soporte ACL necesitamos configurar el archivio /etc/fstab. Los sistemas de archivos montados con acl tienen la palabra clave “acl” en las opciones de montaje de sus entradas en el archivo.

/dev/hda1 /opt ext3 defaults 0 0


Como vemos el dispositivo /dev/hda1 no tiene soporte acl en el punto de montaje , si queremos activarlo cambiamos el archivo como sigue:

/dev/hda1 /opt ext3 defaults,acl 0 0


Una vez que hemos actualizado el archivo /etc/fstab tenemos que remontar el file system .

Ejemplo para hda1:

# mount -o remount /dev/hda1


4.- Soporte ACL en el espacio de usuario:

El último paso para usar ACL es asegurarse de que las aplicaciones de espacio de usuario estén presentes en el sistema. En Debian podemos comprobarlo de esta manera:


# dpkg -l |grep acl
ii acl 2.2.42-1ubuntu1
Access control list utilities
ii libacl1 2.2.42-1ubuntu1


También podemos comprobarlo buscando las herramientas:

# type -a getfacl
getfacl is /usr/bin/getfacl


Si el control de ACLs no esta instalado podemos instalarlo con el comando apt ejecutando:

# apt-get install acl


5.- Formato ACL:

Linux soporta 2 tipos básicos de ACL:

• ACL de control de directorios y archivos.
• ACL de directorio (máscaras) ACL que toman por defecto los archivos creados en ese directorio.

La ACL se representa por tres campos separados por “:”.

Campo 1:
Entrada

• “u” Usuario
• “g” Grupo
• “o” Otro
• “m” Máscara

Campo 2:

• UID (ID numérico de usuario)
• GID (ID numérico de grupo)
• Vacío (Asume UID,GID del Creador)

Campo 3:

El tercer campo es el de acceso y puede ser representado de 2 maneras.

• Cadena estandar RWX (las cadenas se pueden remplazar por “-” si no queremos dar acceso de ese tipo)
• Cadena simbólica + ^

6.- Herramientas:

• chacl: Permite cambiar, examinar o eliminar ACL.
• getfacl: Permite examinar acl para encontrar archivos o directorios.
• setfacl: Establece ACL a fichero o directorio.

7.- Mostrar ACL:

Para el ejemplo usaremos un directorio con archivos que hemos creado usando el comando touch.

$ ls -l
total 0
-rw-r--r-- 1 prueba prueba 0 2008-01-26 03:03 archivo.txt
-rw-r--r-- 1 root root 0 2008-01-26 03:03 pass
-rw-r--r-- 1 root root 0 2008-01-26 03:02 user


La acl para el directorio siguiente es:

$ getfacl .
# file: .
# owner: root
# group: root
user::rwx
group::rwx
other::rwx


La acl por defecto para el archivo archivo.txt es esta:

$ getfacl archivo.txt
# file: archivo.txt
# owner: prueba
# group: prueba
user::rw-
group::r--
other::r--


La acl para el directorio el cual no se le ha asignado toma los valores de umask.

8.- Establecer ACL:

Tenemos varias maneras de establecer un ACL:

1. Usando el comando setfacl el cual sobrescribe cualquier ACL anterior.
2. Usando el comando setfacl con la opción -m (Modifica ACL).
3. Usando chacl para modificar una ACL existente.

Veamos entonces como podemos las acl con chacl, este comando sobrescribe la existente, y además proporciona algo más de información acerca del funcionamiento de las listas de acceso.

Ejemplo:

Añadiremos al usuario fab como alguien que puede leer el archivo archivo.txt, y usaremos chacl (cambiar la ACL) ejecutando:

$ chacl u::rw-,g::r--,o::---,u:fab:r--,m::rw- archivo.txt


Esta es la forma en la que colocamos una acl en la vida real, el hecho de que este sea un comando demasiado largo es que se debemos definir en los puntos ya nombrados anteriormente el propietario de archivo, grupo propietario y otros.

Para que podamos entender mejor, la porción u::rw,g::r–,o::— es la ACL existente y la porción u:fab:r–,m::rw- especifica el nuevo usuario que quiero añadir a dicha acl y la máscara de permisos cuando sea añadida dicha acl.

La máscara de permisos nos muestra la unión de todos los permisos ya existentes de User,Group,Others para un archivo o directorio.

Podemos hacer la siguiente comprobación:

$ getfacl archivo.txt
# file: archivo.txt
# owner: prueba
# group: prueba
user::rwx group::r-- other::--- user:fab:r-- mask::rw-


Ahora que ya sabemos como funciona acl podriamos poner que fab tenga permisos de lectura y escritura a archivo.txt:

$ chacl u::rw-,g::r--,o::---,u:fab:rr-,m::rw- archivo.txt


Como vemos en el ejemplo hemos agregado permisos de escritura:

$ getfacl archivo.txt
# file: archivo.txt
# owner: prueba
# group: prueba
user::rwx group::r-- other::---user:fab:rw-


A trabajar.


$cpio -ov < archivos.txt > /dev/fd0


Esto copia los archivos que estan en el archivo llamado archivos.txt en un dkt.
El parámetro v hace que el comando muestre el nombre de cada archivo copiado. Este comando es muy util para hacer backups copiado los archivos. El diskette debe estar formateado pero no debe estar montado.

2.- Para copiar archivos del directorio actual a un diskette ejecutar:


$ls *.c cpio -ov > /dev/fd0


Este comando copia los archivos que terminan en .c al dispositivo /dev/fd0.

3.- Para copiar los directorios y subdirectorios a un diskette


find . -print cpio -ov > /dev/rfd0


Este comando guarda el arbol de directorios incluidos en “.” directorio actual incluyendo los archivos en el dispositivo /dev/fd0.

Para hacer esto mas rápido ejecutar:

find . -cpio /dev/fd0 -print


El parámetro print muestra el nombre de cada uno de los archivos copiados.

4.- Para listar los archivos que han sido copiados al diskette con el comando cpio ejecutar:

cpio -itv

Este comando muestra el contenido de los datos guardados previamente en el dispositivo /dev/fd0 usando el comando cpio. El listado es parecido al que se muestra al ejecutar el comando ls -l en un directorio.

5.- Para restaurar los archivos previamente guardados con cpio en un diskette, ejecutar:


cpio -idmv < /dev/fd0


Este comando restaura los archivos previamente guardados en /dev/fd0 por medio del comando cpio en el directorio actual (parámetro -i). El parámetro d activa al comando cpio para que cree los directorios que estan en el dispositivo. El parámetro m mantiene fecha de actualización. El parámetro v nos muestra los archivos que se estan restaurando.

6.- Para restaurar algunos archivos seleccionados, ejecutar:


$cpio -i "*.c" "*.o" < /dev/fd0


Este parámetro restaura los archivos que terminan en ".c" ó ".o" desde el dispositivo la doble comilla hace que el asterisco solo sea visible dentro de las mismas de lo contrario se aplicaría a todo.

Comando tar

El comando tar es utilizado normalmente para empaquetar archivos. El comando tar no comprime
automáticamente los archivos mientras los empaqueta. El formato del comando tar es:

tar ...


donde es la lista de comandos y opciones para tar, y hasta es
la lista de archivos a añadir o extraer del archivo empaquetado. Por ejemplo, el comando

# tar cvf backup.tar /etc


empaquetará todos los archivos de /etc en el archivo backup.tar.

En el primer argumento de tar (“cvf”), la opción “c” le dice a tar que cree un nuevo archivo
(create). La opción “v” fuerza a tar en el modo verbose, imprimiendo los nombres de los archivos
según se empaquetan. La opción “f” le dice a tar que el siguiente argumento (backup.tar) es el
nombre del archivo a crear. El resto de los argumentos de tar son los nombres de archivos y
directorios a añadir al archivo empaquetado.

Descomprimir archivos con tar

# tar xvf backup.tar


Esto, extraerá el archivo backup.tar en el directorio actual. Esto puede ser peligroso, porque si el
archivo ya existía se sobrescribirá. Por otra parte, antes de extraer archivos tar es importante
conocer donde se deben desempaquetar.

Por ejemplo, digamos que se empaquetaron los siguientes archivos: /etc/hosts, /etc/group, y
/etc/passwd. Si se usó:


# tar cvf backup.tar /etc/hosts /etc/group /etc/passwd


el nombre de directorio /etc se añadió al principio de cada nombre de archivo. Para poder extraer
los archivos en el directorio correcto, se necesitará utilizar los siguientes comandos:

# cd /
# tar xvf backup.tar


Ya que los archivos se extraen con el nombre de camino almacenado. Sin embargo, si se
empaquetaron los archivos con los comandos:

# cd /etc
# tar cvf hosts group passwd


Los nombres de directorio no se salvaron en el archivo empaquetado. Por esto se necesitara hacer
“cd /etc” antes de extraer los archivos. Como se puede ver, el cómo haya sido creado un archivo
tar marca una gran diferencia en como se extrae. Se puede usar el comando:

# tar tvf backup.tar

para mostrar un “índice” del archivo tar antes de desempaquetarlo. De esta forma se puede ver que
directorio se utilizó como origen de los nombres de los archivos, y se puede extraer el archivo
desde la localización correcta.
Además agregando el switch ’z’ utiliza el gzip y el gunzip para comprimir / descomprimir.

Comando gzip

El comando gzip se utiliza para comprimir un archivo. El formato del comando gzip es:
gzip archivo

(archivo se convierte en archivo.gz comprimido)

gzip −c archivo > archivo.gz


(Se crea archivo.gz, archivo no se modifica)

Por ejemplo:

# gzip −9 backup.tar

Comprimirá backup.tar y lo dejará como backup.tar.gz, que es la versión comprimida del archivo
tar. La opción −9 le dice a gzip que utilice el mayor factor de compresión.

Descomprimir archivos con gunzip o con gzip

El comando gunzip se utiliza para descomprimir un archivo comprimido con gzip.

Equivalentemente, se puede utilizar “gzip −d”.

El formato del comando gunzip es:


gunzip archivo.gz (descomprime archivo.gz)
gunzip −c archivo.gz > nuevo (descomprime archivo.gz y se redirecciona la salida al archivo nuevo).