1

GESTIÓN Ernesto Pérez (autor textos 2005-2008)

DE UNIDADES DE

ALMACENAIENTO

Ricardo Ortega (redacción de textos y

diseño gráfico 2010)

http://aula.virtualepn.edu.ec

infovirtual@cec-epn.edu.ec

2

Capacitación en Modalidad Virtual Administración Linux I, Gestión de unidades de almacenamiento Ricardo Ortega Levantamiento de texto 2008: Ernesto Pérez Redacción de textos 2010: Ricardo Ortega Registro de derecho autoral: en trámite ISBN de este volumen: en trámite Depósito Legal: en trámite Publicado en http://aula.virtualepn.edu.ec desde Abril 2008

CENTRO DE EDUCACIÓN CONTINUA ESCUELA POLITÉCNICA NACIONAL DIRECCIÓN DE CAPACITACIÓN Y CONSULTORÍA CAPACITACIÓN EN MODALIDAD VIRTUAL

Quito –Ecuador

3

ADMINISTRACIÓN DE LINUX I

Gestión de unidades de almacenamiento

Material para la modalidad virtual

Master Ricardo B. Ortega O.

www.ricardoortega.com

Objetivos del capítulo 5

Entender el uso de utilerías para el manejo de unidades de almacenamiento en Linux.

Aprender a distinguir los diferentes tipos de discos

Aprender a montar y desmontar los diferentes dispositivos

Aprender a añadir y eliminar las particiones

Aprender distintas maneras de sacar respaldos en Linux

Prerrequisitos para el capítulo 5

Tener instalado y funcionando un computador con Linux CENTOS

Tener instalado y funcionando un software de virtualización para practicar el particionamiento o en su defecto, disponer de un computador con espacio libre para practicar el particionamiento

Conocer los comandos básicos de Linux

Conocer el uso de un editor de texto

Recursos necesarios para el capítulo 5

Un computador con Linux CENTOS instalado y funcionando

Un computador (real o virtual) para practicar el particionamiento

Distintos dispositivos para pruebas (flash memory, floppy, cd, etc.)

Recomendaciones para el capítulo 5

LINUX CENTOS Nos limitaremos a explicar el funcionamiento de CENTOS. Las pruebas en otras

distribuciones quedan a su propia cuenta y riesgo.

MODO TEXTO a menos que se indique otra cosa, todos los comandos se deben escribir desde una

sesión de bash desde el usuario root. Si se dice escriba fdisk -l se está diciendo precisamente eso:

desde el bash, escriba ese texto (tal como está escrito) y presione ENTER.

LEA LOS MENSAJES: Observe los mensajes que le aparecen. No pase por alto los mensajes de error.

La mayoría de usuarios no lee los mensajes y cuando se le pregunta ―qué decía el mensaje‖ la

respuesta es ―no sé, nunca leo los mensajes‖. Por supuesto que esa actitud no es propia de aspirantes

a administradores de redes.

Contenidos del capítulo 5

4

OBJETIVOS DEL CAPÍTULO 5 .................................................................................................................................... 3

PRERREQUISITOS PARA EL CAPÍTULO 5 ............................................................................................................. 3

RECURSOS NECESARIOS PARA EL CAPÍTULO 5 ................................................................................................ 3

RECOMENDACIONES PARA EL CAPÍTULO 5 ....................................................................................................... 3

CONTENIDOS DEL CAPÍTULO 5 ............................................................................................................................... 3

5.1 TIPOS DE ALMACENAMIENTO ........................................................................................................................... 4

5.1.1 ATENCION ........................................................................................................................................................ 4 5.1.2 Conceptos generales .......................................................................................................................................... 5 5.1.3 Tipos de almacenamiento .................................................................................................................................. 5 5.1.4 Discos mecánicos ............................................................................................................................................... 5 5.1.5 Dispositivos no mecánicos ................................................................................................................................. 6 5.1.6 Unidades de cinta .............................................................................................................................................. 7 5.1.7 Discos extraíbles ................................................................................................................................................ 7

5.2 CONOCIENDO LAS UNIDADES ............................................................................................................................ 8

fdisk –l......................................................................................................................................................................... 8 mount .......................................................................................................................................................................... 8 archivo /etc/fstab ........................................................................................................................................................ 9 Otros ......................................................................................................................................................................... 10

5.3 MONTAR Y DESMONTAR DISPOSITIVOS ....................................................................................................... 10

5.3.1 Comando mount ............................................................................................................................................... 10

5.4 AÑADIR/ELIMINAR PARTICIONES .................................................................................................................. 12

5.5 CHEQUEAR EL DISCO.......................................................................................................................................... 18

5.6 COMPRENSIÓN DE ARCHIVOS ......................................................................................................................... 19

5.7 TRABAJO CON IMÁGENES Y CD ...................................................................................................................... 21

5.8 RESPALDOS CON TAR Y STAR ........................................................................................................................... 27

5.9 PLANIFICAR Y REALIZAR RESPALDOS ......................................................................................................... 31

5.1 Tipos de almacenamiento

5.1.1 ATENCION

En esta parte del curso aprenderemos a realizar tareas potencialmente destructivas y/o dañinas para la

información guardada en su disco o en su unidad de almacenamiento. Por ello, debe leer todo con atención

y realizar cada paso con cautela.

Se recomienda que las labores de prueba no se realicen en el disco duro de la máquina sino en un pendrive

o flash. Se recomienda que las labores de compresión se hagan con archivos y/o directorios creados por

Ud. mismo, para evitar el riesgo de borrar información del sistema o de otros usuarios.

Si no se tiene un archivo o directorio para probar, es necesario crearlo. Mediante el open office o el vi se

debe crearse uno o varios archivos para realizar las pruebas; los contenidos no importan en un principio,

sino el hecho de que existan archivos y directorios.

No busque las letras A: B: C: D: etc. en Linux. No existe tal cosa. Los distintos dispositivos se montan y se

desmontan sobre cualquier directorio, aunque generalmente se montan dentro de /mnt o /media. Recuerde

que Linux tiene una sola estructura de árbol. Todas las unidades de almacenamiento están dentro del árbol

5

raíz / y se montan dentro de esta estructura. Montar una unidad significa dejar preparado para el uso del

sistema. Más detalles a continuación.

5.1.2 Conceptos generales

El uso de utilerías para el manejo de unidades de almacenamiento es algo totalmente necesario a la hora

de trabajar con un servidor Linux.

Esto, sin duda, va más allá de montar particiones o sacar respaldos. De hecho, existen muchísimas utilerías

que permiten también optimizar los accesos al disco, así como herramientas para particionar o reparticionar

discos, y para chequearlos, formatearlos, etc.

Ahora bien, no solamente se debe pensar en la unidad de almacenamiento como un disco duro; también las

unidades de almacenamiento comprenden, por ejemplo, las unidades de floppy, dispositivos USB para

mass storage (de almacenamiento masivo o a gran escala) y, sobre todo, las cintas para realizar respaldos.

5.1.3 Tipos de almacenamiento

Linux puede manejar varios tipos de almacenamiento • Discos mecánicos • Dispositivos no mecánicos • Unidades de cinta • Discos extraíbles (floppies). • Unidades ópticas (CD, DVD, CD-RW, DVD-RAM, DVD-R, etc)

5.1.4 Discos mecánicos

Los discos mecánicos son aquellos que se componen de uno o varios platos metálicos donde se escribe y

se lee la información. Estos platos rotan a cierta velocidad y uno o varios brazos mecánicos dotados de

cabezas lectoras/escritoras se ocupan de acceder a los platos rotatorios y leer o escribir la información.

Existen varios tipos de discos mecánicos, normalmente conocidos por su controladora y tasa de

transferencia. Entre los más populares al momento están:

Discos IDE o PATA (Parallel ATA)

Discos SATA (Serial ATA o Serial Advanced Technology Attachment)

Discos SCSI (Small Computer System Interface – Parallel)

Discos SAS (Serial Attached SCSI)

Básicamente, la tecnología mecánica subyacente es muy similar, sólo que se diferencian por la forma en

que la información es transferida del disco hacia el procesador y hacia la memoria.

Los discos SCSI tienen la virtud de ser extremadamente rápidos en términos de capacidad de rotación;

además, la tasa de transferencia es extremadamente alta (actualmente llegan a 6 Gigabits por segundo), lo

que hace que, para aplicaciones que requieren de mucha E/S, estos discos sean extremadamente

apetecidos. Por otro lado, estos discos no consumen tiempo del procesador del sistema porque tienen un

procesador incluido en el disco mismo así que permite que se independicen del uso o no que se esté dando

al procesador y acelera todo el proceso. El punto negativo de estos discos es el costo: ¡un disco SCSI vale

lo que rinde, y rinde mucho!

Los discos más conocidos al momento y más usados por el mundo en general son los discos SATA (Serial

ATA). Hasta el año 2007 los discos más usados eran los discos IDE (o PATA, que significa Parallel ATA).

Los discos SATA tienen tasas de transferencia de entre 33MB/s a 3 Gigabits por segundo. Sin embargo, en

realidad, no todo es la tasa de transferencia; los discos IDE y SATA consumen interrupciones del

procesador por lo que generan cuellos de botella relacionados con el uso de la CPU.

6

SATA no solamente es más rápido que los discos ATA, sino que es comparablemente igual de rápido que

los discos SCSI más comunes y están sobrepasando a los SCSI más comunes. Usa una tecnología que,

técnicamente, consume mucha menos energía y, sobre todo, el precio es muy cómodo.

SATA I SATA II SATA III

Frecuencia 1500 MHz 3000 MHz 6000MHz

Bits/clock 1 1 1

Codificación 8b10b 80% 80% 80%

bits/Byte 8 8 8

Velocidad real 150 MB/s 300 MB/s 600 MB/s

Esto significa que se pueden formar arreglos de discos SATA sin problemas de rendimiento, y a costos muy

convenientes.

Los discos SATA son soportados directamente por el kernel 2.6 y superiores, esto es, toda la serie de

CENTOS 5.x y RHEL 5.x en adelate. Esto es importante ya que muchas personas todavía intentan instalar

Red Hat 7, una versión del año 2002 que tiene un kernel 2.2 que por supuesto, no trabaja con discos SATA.

Un dato importante de recordar es que los discos IDE se identifican con las siglas hd (de hard disk). En el

directorio /dev se encontrarán nombres ya establecidos como hda (Primario Master), hdb (Primario

Esclavo), hdc (Secundario Master) y hdd (Secundario Esclavo), mientras que el resto de discos no IDE se

identifican con las siglas sd (de SCSI disk) ya que el controlador SCSI (el device driver de Linux) es el

encargado de manejar no solo los discos SCSI sino también los SATA, USB, SD, etc. Y esto es afortunado,

ya que terminaríamos con una gran cantidad de siglas, mientras que ahora nos limitamos a dos: hd para

tecnologías IDE y sd para el resto de tecnologías.

Si los discos IDE tienen sus nombres preestablecidos, no sucede lo mismo con los demás discos, por lo que

en un momento dado su memoria flash será sdb, pero en otro momento podrá ser sdc, sdd, sde, etc.

dependiendo de los dispositivos SCSI, SATA, USB, SD que tenga instalados en el sistema.

El primer dispositivo SCSI, SATA, USB, SD será entonces sda, el segundo que se conecte será sdb y así

sucesivamente.

Recuerde que la primera partición del dispositivo será 1, esto es, sda1. La segunda (si es que existe) será

sda2, y así sucesivamente.

Recuerde que todo disco duro debe tener al menos una partición, así que siempre habrán dos entradas: sda

para el disco duro completo (todos los sectores, incluyendo el MBR) y sda1 que corresponde a la partición

1, excluyendo el MBR e incluyendo todos los sectores de la primera partición.

Todos los dispositivos de almacenamiento reconocidos por Linux requieren un proceso de montaje y

desmontaje, que se traduce en los comandos mount y umount (ojo, NO es unmount sino umount) y

opcionalmente se describen en el archivo /etc/fstab (file system table) para que se monten automáticamente

al arrancar el sistema.

Los RAIDS y LVMS serán estudiados en el siguiente módulo. En este capítulo trataremos de los discos

independientes.

5.1.5 Dispositivos no mecánicos

Estos son nuevas o viejas técnicas de almacenamiento que se han ido abaratando con el tiempo. Son las

llamadas Compact Flash (CF) que son discos duros que soportan cientos de miles de escrituras sin

dañarse, así como, cantidades casi infinitas de lecturas.

7

Estos discos tienen la peculiaridad de que consumen muy baja energía, al no tener motores que muevan

sus partes móviles, además de que son extremadamente compactos. Además, al no tener partes móviles,

estos dispositivos no se rompen debido a caídas o fallas en sus mecanismos. Son dispositivos que en

cuanto se empiecen a usar, trabajarán por mucho tiempo mientras sus componentes de grabación estén en

la capacidad de seguir almacenando nuevos datos.

Los discos CF tienen varios nombres y variantes: SD, Mini SD, micro SD, pendrives, USBdrives, etc. y que

son muy usados en cámaras digitales, pues, son pequeños y almacenan información sin depender de

golpes o caídas.

Estos dispositivos tienen una desventaja y es que normalmente son un poco más caros que sus

contrapartes mecánicas. Además están limitados por la velocidad del puerto al cual se conectan,

típicamente USB (1.1 transmite a 11 Megabits por segundo) mientras que USB 2.0 trasmite a 400 Megabits

por segundo. Esto significa que un disco SATA de 1.5 Gigabits será casi cuatro veces más rápido que un

disco USB 2.0

Sin embargo, esta tecnología no mecánica se usa mucho para sistemas embebidos, que requieren de

partes no móviles y de bajo consumo.

Los sistemas Linux soportan lecturas y escrituras de dispositivos no mecánicos de forma totalmente natural.

Linux ve estos dispositivos como si fueran un dispositivo SCSI y se puede leer y escribir en ellos como se

escribe en cualquier disco mecánico, usando las siglas sd (dentro del directorio /dev).

5.1.6 Unidades de cinta

Es una de las tecnologías más viejas que existen para almacenar información y sigue siendo usada por

muchas empresas. Mayormente, los dispositivos de cinta están estandarizados y se manejan a través de un

dispositivo del sistema Linux llamado: /dev/st0

Las unidades de cinta son muy útiles para guardar respaldos, ya que son capaces de almacenar cantidades

realmente grandes de información y el costo por GB, asociado con ellas, es más bajo que mantener un

disco para hacer respaldos. Además, las cintas pueden cambiarse y moverse de lugar a conveniencia lo

que normalmente permite guardar los respaldos en otros lugares separados de los servidores.

Las unidades de cinta tienen varias desventajas, la mayor de ella es que no mantienen un filesystem; es

decir, los datos se escriben en ellas unos detrás de los otros y normalmente es necesario saber qué se ha

escrito para poderlo recuperar. Además, son muy lentas comparadas con las escrituras en un disco y

también tienden a fallar con el tiempo, así que NO se confíe. La vida útil de una cinta se mide en meses.

5.1.7 Discos extraíbles

Son básicamente los discos floppies; esos antiguos aliados que al momento están quedando en desuso,

pero también podemos ver como discos extraíbles a sus nuevos hermanos, los discos CDROM y DVD que

permiten almacenar muchísima información comparado con los floppies.

Aunque los CDs y DVDs son un medio muy bueno para almacenar la información también se caracterizan

por ser más susceptibles a los fallos que los discos mecánicos o no mecánicos, así como que las unidades

de cinta. Sobre todo porque tienen expuesta la información directamente a las inclemencias del tiempo (sol,

lluvia, agua, arañazos, etc.). Sin embargo se puede afirmar que es una forma confiable de trasladar la

información, e incluso, de almacenarla si se toman las debidas precauciones, ya que un CD o DVD tiene en

teoría una vida útil de 100 años (bueno, nadie lo ha comprobado, pero eso dice la teoría).

Linux también es capaz de manejar estos dispositivos extraíbles. En general, virtualmente, cada dispositivo

de almacenamiento es manejable mediante Linux.

8

Se debe recordar que Linux no sólo maneja mucha variedad de hardware referente a los dispositivos

extraíbles, sino que también entiende los diferentes formatos conque estos pueden estar inicializados, de

forma tal, que desde Linux se pueden leer particiones FAT12, FAT16, FAT32, NTFS, así como una gran

variedad de sistemas existentes en el mercado.

5.2 Conociendo las unidades

fdisk –l

Muestra la información de discos y particiones

Se puede mirar que el disco sda de 12GB tiene dos particiones, la primera de 100MB (104391 bloques de

1k) y la segunda de 12GB (12474472 bloques de 1k).

Linux maneja los discos duros en bloques de 1Kbyte, es decir dos sectores de 512 bytes, o 1024 bytes.

Otra máquina:

Se puede mirar que el disco sda de 21GB tiene dos particiones, la primera de 100MB (104391 bloques de

1k) y la segunda de 20GB (20860482 bloques de 1k). La segunda partición es un LVM del cual se hablará

en el Módulo 2.

mount

El comando mount sin argumentos nos permite mirar los puntos de montaje en cada dispositivo

9

Mire cómo el dispositivo /dev/sda1 está asignado al directorio /boot

Y /dev/sda2 está asignado al directorio raíz

En este sistema, /dev/sda1 está asignado a /boot (100MB) y lo que debería ser /dev/sda2 está formando un

LVM en /dev/mapper/VolGroup00-LogVol00 para el directorio raíz.

archivo /etc/fstab

Contenido de un archivo fstab en una maquina virtual con vmware.

10

La estructura de fstab es de 6 columnas separadas por espacios o tabuladores.[1]

<dispositivo> <punto_de_montaje> <sistema_de_archivos> <opciones> <dump-freq> <pass-num>

<dispositivo> es el directorio lógico que hace referencia a una partición o recurso.

<punto_de_montaje> es la carpeta en que se proyectaran los datos del sistema de archivos.

<sistema de archivos> es el algoritmo que se utilizará para interpretarlo.

<opciones> es el lugar donde se especifica los parámetros que mount utilizará para montado el dispositivo, deben estar separadas por comas. Pueden consultarse aquí.

<dump-freq> es el comando que utiliza dump para hacer respaldos del sistema de archivos, si es cero no se toma en cuenta ese dispositivo.

<pass-num> indica el orden en que la aplicación fsck revisará la partición en busca de errores durante el inicio, si es cero el dispositivo no se revisa.

Luego de defaults se acostumbra agregar ―,usrquota,grpquota‖ sin comillas y sin espacios, para activar

cuotas de disco en cada partición.

Luego de defaults se suele poner ―,noatime‖ sin comillas para acelerar el rendimiento del computador

cuando no nos interesa que se actualice la fecha y la hora de acceso de cada archivo (un proceso que

consume bastante tiempo).

Otros

Para ver mayor información sobre un LVM se puede usar el comando vgs como se indica aquí arriba.

5.3 Montar y desmontar dispositivos

5.3.1 Comando mount

El comando mount permite acceder a un dispositivo (o partición) de almacenamiento. Al no existir el

concepto de unidades (letras A: B: C: D: etc.) en Linux, se debe previamente "montar" el dispositivo antes

de acceder a él. Y desmontarlo (expulsarlo) cuando ya no se lo necesita.

En las versiones modernas de Linux, el proceso de montaje y desmontaje de memorias flash y dispositivos

USB ocurre de forma bastante automática, gracias a los servicios automount y pcscd. Esto significa que

mientras estén activos esos dos servicios, no necesitará montar los dispositivos, y podrá desmontarlos

fácilmente con un clic derecho.

11

Como ejemplo pongamos una memoria flash en el computador. A los pocos momentos todos pudieron ver

una ventana del navegador donde muestra el contenido de la memoria flash.

En efecto, al final se ve como dice: "1.9GB Removable"; esta es la flash que acaban de introducir. A la

derecha (respaldo*, reporteaeci, gparted, dsl) se ven los contenidos de la flash de forma visual.

Se puede verificar mediante el comando mount sin argumentos.

Como se ve, está montada en /media/disk y si se entra en /media/disk se verán los mismos contenidos que

se miran en modo gráfico. También, se puede determinar que la flash se llama: /dev/sdcl y está formateada

en tipo vfat

Para poder extraer un dispositivo, primeramente se indicó al personal de laboratorios que debía

desmontarlo. Esto se puede hacer vía gráfica: sobre el nombre del dispositivo se puede dar: Clic derecho y

escoger la opción que dice: Unmount (Desmontar).

Una vez que hayan escogido desmontar, probaran nuevamente poner: mount:

Todos pudieron verificar que su flash ya no estaba montada.

Además, se pueden montar y desmontar dispositivos mediante línea de comando. Por ejemplo, si uno sabe

que su flash es /dev/sdc1 puede montarla manualmente:

Eso, ejecuta: mount /dev/sdc1 /mnt y se montó la flash (/dev/sdc1) en el directorio /mnt

Esto se verifica ejecutando "mount" al finalizar de montar.

Si se quiere desmontar un dispositivo desde la línea de comando, se puede hacer mediante el nombre del

dispositivo o mediante el directorio donde está montado. Por ejemplo, para desmontar la flash anteriormente

montada se puede usar uno de estos dos comandos:

• umount /mnt

• umount /dev/sdc1

12

Será ve que, al desmontar un dispositivo, ya no aparece la información.

Recomendaciones:

• nunca sacar una flash sin desmontar ya que al desmontar se vacían los buffers de grabación

• no se puede desmontar un dispositivo si está en uso, por ejemplo estamos dentro del directorio del

dispositivo. Es decir, debemos salir del directorio del dispositivo para desmontarlo.

• Si no sabemos en qué dispositivo está nuestra flash o disco externo, podemos ejecutar: fdisk -l

Otros dispositivos de interés:

• /dev/dvd : dvd

• /dev/cdrom : cdrom

• /dev/fd0 : floppy

5.4 Añadir/eliminar particiones

Mientras que la mayoría de los pasos necesarios para añadir o eliminar unidades de almacenamiento

dependen más en el hardware del sistema que en el software, hay aspectos del procedimiento que son

específicos a su entorno operativo. En esta sección los expositores explicaron los pasos necesarios para

añadir o eliminar almacenamientos que son específicos a RHEL (CentOS). Por supuesto, los expositores

puntualizaron que la unidad que está siendo agregada debe estar correctamente instalada a nivel de

hardware.

5.4.1 Añadir almacenamiento

El proceso de añadir almacenamiento a un sistema Linux es relativamente directo. He aquí los pasos:

• Particionar

• Formatear la partición(es)

• Actualizar /etc/fstab

5.4.2 Particionar

Una vez instalado el disco duro, es hora de crear una o más particiones para hacer el espacio disponible a Linux.

Hay más de una forma de hacer esto:

• Usando el programa de línea de comandos fdisk

• Usando parted, otro programa utilitario de línea de comandos

• Usando la distribución GParted

Aunque las herramientas pueden ser diferentes, los pasos básicos son los mismos. En el ejemplo siguiente, se incluyen los comandos necesarios para efectuar estos pasos usando fdisk:

• Definir a qué unidad de almacenamiento se procederá a particionar. Se puede usar el comando:

13

fdisk -l

• Al determinar la unidad de almacenamiento que se quiere particionar se procede a llamar el fdisk

indicándole a qué disco se quiere llegar. En este ejemplo será: /dev/hda:

fdisk /dev/hda

• Revisar la tabla de particiones de la unidad para verificar que la unidad a particionar es, en realidad,

la correcta. En el ejemplo que los expositores pusieron al equipo de "Mentes Libres", fdisk muestra la

tabla de partición usando el comando p:

Command (m for help): p

Disk /dev/hda: 255 heads, 63 sectors, 1244 cylinders Units = cylinders of 16065 1 512 bytes

Device Boot Start End Blocks Id System /dev/hda1 2 1 17

136521 83 Linux /dev/hda2 18 83 530145 82 Linux swap

/dev/hda3 84 475 3148740 83 Linux /dev/hda4 476 1244

6176992+ 83 Linux

Este ejemplo indica que se tienen 4 particiones (hda1 hasta hda4). La primera mide 136MB; la segunda,

530MB; la tercera, 31GB; y la última, unos 61GB. Todas menos hda2 son de tipo Linux. hda2 es de tipo

Linux SWAP

• Borrar cualquier partición no deseada que pueda existir en la nueva unidad de disco. Esto se hace

usando el comando d en fdisk:

Command (m for help): d Partition number (1-4):

1

• El proceso debe repetirse para todas las particiones no deseadas presentes en el disco. En nuestro

ejemplo: hay que borrar todas las particiones.

• Crear la(s) nueva(s) partición(es), asegurándose de especificar el tamaño deseado y el tipo de

sistemas de archivos. Usando fdisk, esto es un proceso de dos pasos : primero, se crea la partición

(usando el comando n):

Command (m for help): n Command action e extended

p primary partition (1-4)

1 Es muy importante no cometer errores en este proceso. El fdisk, una vez grabados los cambios, es destructivo y si uno se equivoca de unidad de almacenamiento los datos se pueden perder.

2 Es muy importante no cometer errores en este proceso. El fdisk, una vez grabados los cambios, es destructivo y si uno se equivoca de unidad de almacenamiento los datos se pueden perder.

14

p

Partition number (1-4): 1 First cylinder (1-

767): 1

Last cylinder or +size or +sizeM or +sizeK: +512M

• Segundo, se configura el tipo de sistema de archivos (usando el comando t):

Command (m for help): t Partition number (1-4): 1 Hex code (type L to list codes): 82

• El tipo de partición 82 representa una partición Linux swap.

• Si no se desea guardar los cambios, se puede salir del programa de particionamiento fdisk con el

comando: q < - - USAR ESTA OPCION PUES ESTAMOS PROBANDO SOLAMENTE.

• Si se desea, se puede guardar los cambios y salir del programa de particionamiento. Esto se hace

en fdisk ejecutando w:

Command (m for help): w

5.4.2.2 Formatear la partición

El formateo de particiones bajo Linux se hace usando el programa de utilidades mkfs. Sin embargo, mkfs en realidad no hace el trabajo de escribir la información específica del sistema de archivos en el disco; lo que hace es pasar el control a uno de los muchos programas que crean el sistema de archivos.

Los expositores puntualizan que este es el momento de observar la página man de mkfs.<fstype> para el sistema de archivos que se ha seleccionado. Por ejemplo: ver la página man de mkfs.ext3 para revisar las opciones disponibles durante la creación de un sistema de archivos ext3.

En general, los programas mkfs.<fstype> suministran valores por defecto razonables para la mayoría de las configuraciones; sin embargo, he aquí algunas de las opciones que los administradores de sistemas cambian más a menudo y que el personal de laboratorio de "Mentes Libres" debe tener en cuenta:

• Configuran una etiqueta de volumen para su uso posterior en /etc/fstab

• En discos duros muy grandes, configuran un porcentaje más pequeño de espacio reservado para el

súper-usuario

• Configuran un tamaño de bloque no estándar y/o bytes para las configuraciones de inodos, que

deben soportar tamaños de archivos muy grandes o muy pequeños

• Verifican por bloques dañados antes de formatear

Personalmente, los expositores dijeron que preferían llamar directamente a la utilería de formateo deseada.

Por ejemplo, para formatear una partición con el FS tipo ext3, se debe ejecutar el comando:

mkfs.ext3 /dev/hda3 _______________________________________________________ ATENCION: ESTE COMANDO DESTRUIRÁ TODA LA INFORMACIÓN CONTENIDA EN LA PARTICIÓN

/dev/hda3. NO LO USE SI NO QUIERE PERDER

LA INFORMACIÓN.

15

El comando mkfs.ext3 permite especificar algunos parámetros adicionales (ver la página manual para una

lista extensa de opciones). De los cuales los más usados son:

-m# : Porcentaje del disco reservado para el súper usuario. El valor por defecto es el 5%, es decir, el 5% del disco se reservará para el súper usuario del sistema y no podrá ser usado por ningún otro usuario. Normalmente se hacía para evitar que un disco se llenara y que el súper usuario mientras tanto no pudiera hacer operaciones de respaldo, copia de información etc. Los expositores explicaron que al momento esto ya no es algo común. Si un disco se llena, al menos la información se puede sacar al vuelo hacia otra máquina por la red y no se requiere limitar el espacio en disco... pues de esta forma sólo el 95% del disco estaría disponible para usarse por todos los usuarios. Normalmente hay que especificar 0, lo que quiere decir 0% reservado para el súper usuario.

-N#: Número de inodos que serán creados para esta partición. Los inodos se calculan normalmente en una relación de 1 inodo por cada 4kb de espacio en disco. De forma tal, que un disco de 80GB consumirá algo así como 80 * 1024M *1024K / 4k, o lo que es lo mismo: 83886080 / 4 = unos 21 millones de inodos. Uno de los asistentes pregunto: "¿Realmente se usarán 21millones de inodos para mi disco?".

La respuesta de los expositores fue:

"Bueno, esto depende de las características de nuestro sistema, puede que sean mucho menos, puede que sean mucho más. En todo caso, la tabla de inodos también consume espacio, lo que hace que, mientras más inodos creemos para una partición determinada, menos espacio podremos dedicar a almacenar información. Por ejemplo, si tenemos una flash de 128mb, nuestro Linux formatearía la flash con 32768 inodos (128 * 1024k / 4k) ¿guardaremos en esta flash 32768 archivos? Lo dudo realmente. Lo normal es que una flash guarde digamos 10, 100, 2000 archivos... entonces para qué gastar espacio creando inodos que nunca usaremos? Es aquí que entra la N, podemos decirle al mkfs que formatee nuestra partición con 1000 inodos por ejemplo. Y todo el resto del espacio en disco lo podemos aprovechar para guardar más información".

Un ejemplo del uso de switches:

mkfs.ext3 -m0 -N128 /dev/hda1 ______________________________________________

¿Qué se hizo aquí? Se le indicó que no guarde ningún espacio en disco para el súper usuario (es decir todo el disco lo podrán usar tanto usuarios, como súper usuarios) y que sólo cree 128 inodos. Uno de los asistentes del personal del laboratorio preguntó asombrado:

- "¿Por qué tan pocos inodos?"

La respuesta de los expositores fue contundente:

- "Pensemos en /boot: la partición que dedicamos a /boot ¿cuántos archivos se guardan en ella?

Cuéntenlos: normalmente no pasan de 15... 128 aún es un número grande para mi /boot, y tengo la

oportunidad de aprovechar hasta el último byte en espacio en disco en vez de desperdiciarlo con inodos que

posiblemente nunca usaré".

-c : Manda al sistema a formatear la partición pero le pide que chequee clusters malos y los marque. Es un proceso muy lento, y normalmente no se usa. Los expositores especificaron que puede tardar de 12 a 48 horas en terminar de chequear realmente contra clusters malos.

mkfs.msdos Permite crear una partición con formato fat16 (útil para las flash) y mkfs.vfat permite crear

particiones fat32 que podrán ser leídas por Windows. Es decir, sí se puede formatear particiones de DOS

desde Linux sin mayor inconveniente y sin tener que instalar Windows.

Una vez creados los sistemas de archivos en todas las particiones apropiadas, la unidad de disco estará configurada adecuadamente para su uso.

16

Luego, recalcaron los expositores, siempre es bueno volver a verificar su trabajo manualmente montando la partición(es) y asegurándose de que está en orden. Una vez que todo está verificado, es el momento de configurar su sistema Linux para que monte automáticamente el nuevo sistema de archivos durante el arranque.

5.4.2.3 Actualizar /etc/fstab

Como se describió anteriormente, primero hay que añadir las líneas necesarias a /etc/fstab para asegurarse de que se monte el nuevo sistema de archivos cuando arranque el sistema. Una vez actualizado /etc/fstab, hay que probar el trabajo ejecutando un comando "incompleto" de mount, especificando solamente el dispositivo o punto de montaje. El grupo del personal quiso que los expositores aclararan este punto con un ejemplo. Los expositores les dijeron que es suficiente usar algo similar a alguno de los comandos siguientes:

mount /home mount /dev/hda3

(Hay que reemplazar /home or /dev/hda3 con el punto de montaje o dispositivo para su situación específica.)

Si la entrada correspondiente en /etc/fstab es correcta, mount obtiene la información faltante desde el archivo y completa la operación de montaje.

En este punto uno puede estar confiado de que /etc/fstab está configurado correctamente para montar automáticamente el nuevo almacenamiento cada vez que el sistema arranca. Los expositores aconsejaron que si uno se puede permitir un reinicio rápido, debe hacerlo; puesto que no hace daño: simplemente permite estar aún más seguros de que todo funciona correctamente.

5.4.3 Eliminar Almacenamiento

El proceso de eliminar almacenamiento desde un sistema Linux es relativamente directo. He aquí los pasos

específicos:

• Eliminar las particiones de disco desde /etc/fstab

• Desmontar las particiones activas del disco

• Borrar los contenidos de la unidad de disco

Los expositores anunciaron que las secciones siguientes cubrían estos tópicos en más detalles, paso a paso. Todos se fueron a tomar un café y al volver, los expositores repartieron unas hojas en las que cada punto estaba descrito paso a paso.

5.4.3.1 Eliminar las particiones de disco desde /etc/fstab

Usando el editor de texto de su preferencia, elimine la(s) línea(s) correspondiente(s) a la(s) partición(es) de disco desde el archivo /etc/fstab. Puede identificar las líneas correctas por alguno de los métodos siguientes:

• Haciendo corresponder los puntos de montaje con los directorios en la segunda columna de

/etc/fstab

• Haciendo corresponder el nombre del archivo de dispositivo con el nombre de archivo en la primera

columna de /etc/fstab

17

5.4.3.3 Terminar el acceso con umount

Luego, se deben terminar todos los accesos. Para particiones con sistemas de archivos activos en ellas, esto se hace con el comando umount. Si una partición swap existe en el disco, se debe desactivar con el comando swapoff o se debe reiniciar el sistema.

Desmontar las particiones con el comando umount requiere que usted especifique el nombre de archivo de dispositivo, o el punto de montaje.

umount /dev/hda2 umount /home

Solamente se puede desmontar una partición si ésta no se encuentra en uso. Si la partición no se puede

desmontar mientras se encuentra en el nivel de ejecución normal, arranque en modo de rescate y elimine la

entrada de la partición de /etc/fstab.

Cuando utilice swapoff para desactivar el swapping en una partición, debe especificar el nombre de archivo de dispositivo representando la partición swap:

swapoff /dev/hda4

Si no puede desactivar el swapping usando swapoff, arranque en modo de rescate y elimine la entrada de la partición desde /etc/fstab.

5.4.4 Borrar los contenidos de la unidad de disco

Borrar los contenidos desde una unidad de disco bajo Linux es un procedimiento directo.

Después de desmontar todas las particiones del disco, ejecute el comando siguiente (conectado como root):

badblocks -ws <device-name>

Donde <device-name> representa el nombre del archivo de la unidad de disco que desea borrar,

excluyendo el número de la partición. Por ejemplo, /dev/hdb para la segunda unidad ATA.

Se muestra la salida siguiente mientras se ejecuta badblocks:

Writing pattern 0xaaaaaaaa: done Reading and comparing: done Writing pattern 0x55555555: done

Reading and comparing: done Writing pattern 0xffffffff:

done Reading and comparing: done Writing pattern

0x00000000: done Reading and comparing: done

Tenga en mente que badblocks, en realidad, está escribiendo cuatro patrones de datos diferentes a cada

bloque en la unidad de disco. Para las unidades grandes, este proceso puede tomar un largo tiempo — a

menudo varias horas.

18

ESTE PROCESO ES DESTRUCTIVO. Precisamente el fin que se persigue es el de destruir totalmente la información del disco con el objetivo de que futuros usuarios no puedan obtener ningún dato potencialmente sensitivo en él.

El proceso de destrucción nos parece bastante seguro; sin embargo hacemos notar que su empresa o compañía puede tener otros procesos de destrucción de datos diferentes de los nuestros. El uso de nuestro proceso no debe, bajo ningún motivo, obviar el procedimiento dictado a seguir para el caso de su empresa o compañía y el ignorar este proceso por parte de usted le puede traer severas consecuencias.

Los asistentes del personal del laboratorio se miraron mutuamente y se aseguraron de que siempre tendrían mucho cuidado, porque ninguno quería perder su trabajo en "Mentes Libres".

Los expositores explicaron que otra forma de eliminar la información en una partición es usando el comando shred:

shred -n 2 -v /dev/hda

ejecutará dos iteracciones (-n 2) copiando datos aleatorios en toda la partición. De no especificarse -n, se ejecutarán 25 iteracciones. Así que posiblemente, advirtieron los expositores, ni el más rudo de los programas de recuperación hará que los datos se recuperen, pues no quedará ni la sombra, ni el último hálito de vida de los datos al ser concienzudamente sobrescrito todo /dev/hda (en este caso, usar el dispositivo que se quieren borrar) por varias veces.

shred también sirve para eliminar la información de un archivo:

shred /root/miarchivo

hará lo mismo pero con los datos de "miarchivo" Un expositor pidió a los asistentes que miraran un ejemplo de la salida de shred sobre un archivo:

[root@eperez ~]# shred -v freetemp1071.zip

shred: freetemp1071.zip: pass 1/25 (random)... shred:

freetemp1071.zip: pass 2/25 (924924)... shred: freetemp1071.zip:

pass 3/25 (222222)... shred: freetemp1071.zip: pass 4/25 (555555)... shred: freetemp1071.zip: pass 5/25 (bbbbbb)... shred:

freetemp1071.zip: pass 6/25 (249249)... shred: freetemp1071.zip:

pass 7/25 (492492)... shred: freetemp1071.zip: pass 8/25

(333333)...

shred: freetemp1071.zip: pass 9/25 (000000)... shred:

freetemp1071.zip: pass 10/25 (ffffff)... shred: freetemp1071.zip: pass

11/25 (6db6db)... shred: freetemp1071.zip: pass 12/25 (b6db6d)...

shred: freetemp1071.zip: pass 13/25 (random)... shred:

freetemp1071.zip: pass 14/25 (666666)... shred: freetemp1071.zip:

pass 15/25 (111111)... shred: freetemp1071.zip: pass 16/25

(eeeeee)... shred: freetemp1071.zip: pass 17/25 (777777)... shred:

freetemp1071.zip: pass 18/25 (cccccc)... shred: freetemp1071.zip: pass 19/25 (444444)... shred: freetemp1071.zip: pass 20/25

(db6db6)... shred: freetemp1071.zip: pass 21/25 (aaaaaa)... shred:

freetemp1071.zip: pass 22/25 (999999)... shred: freetemp1071.zip:

pass 23/25 (dddddd)... shred: freetemp1071.zip: pass 24/25

(888888)...

shred: freetemp1071.zip: pass 25/25 (random)... ________________________________

"¿Qué hice aquí?", preguntó el expositor. "Simple, ejecuté el shred en 25 pasos, en cada uno sobrescribió

todos los bytes del archivo seleccionado con diferentes patrones, es decir, cambió básicamente la

estructura del disco duro varias veces de forma tal que en realidad no pueda ser leído entre líneas (hay

quien lo hace) y no se pueda obtener nada útil."

5.5 Chequear el disco

19

Esta de las utilerías más importantes a la hora de la verdad (esa hora en que realmente uno tiene que

ponerse a trabajar y que es cuando el sistema no levanta).

El fsck permite revisar diferentes tipos de particiones con solamente llamarle indicándole a qué partición nos

referimos:

fsck /dev/hda1 ____________________________________________________________

por ejemplo, chequeará la partición 1 del disco IDE máster primario (hda)

fsck SIEMPRE debe ser usado en un disco desmontado, de lo contrario dañará los contenidos del

disco.

fsck /dev/sdb5 realizará lo mismo pero para la partición 5ta del 2do disco scsi en una cadena SCSI.

fsck normalmente arregla todas las situaciones, pero si alguna situación no la pudiera arreglar, hay que considerar que el disco ha muerto y que hay que reformatearlo, fsck normalmente pregunta si se quiere realizar todos y cada uno de los arreglos. Los expositores sugirieron que SIEMPRE digamos que sí a cada una de sus preguntas.

Si no quisiéramos responder y constantemente (a veces son cientos de veces) podemos llamar al fsck con el switch -y, por ejemplo:

fsck -y /dev/hdb5 __________________________________________________________

esto revisará hdb5 y asumirá yes fca todas sus preguntas.

5.6 Comprensión de archivos

En Linux existen varias formas de comprimir la información. Estos diferentes comandos se dividen en dos tipos:

1. Compresión sin pérdida: el que hace que la información no se pierda entre compresión y

descompresión.

2. Compresión con pérdida: el que sí pierde información al comprimirla.

La compresión con pérdida es cualquier procedimiento de codificación que tenga como objetivo representar cierta cantidad de información utilizando una menor cantidad de la misma, siendo imposible una reconstrucción exacta de los datos originales.

La compresión con pérdida solo es útil cuando la reconstrucción exacta no es indispensable para que la información tenga sentido. La información reconstruida es solo una aproximación de la información original.

Suele restringirse a información analógica que ha sido digitalizada (imágenes, audio, video, etc...), donde la información puede ser parecida, y al mismo tiempo, ser subjetivamente la misma.

Su mayor ventaja reside en las altas razones de compresión que ofrece en contraposición a un algoritmo de compresión sin pérdida.

20

Para ver ejemplos de sistemas de compresión con pérdida (lossy compression), los expositores sugirieron

ver en wikipedia.

Los expositores aclararon que se centrarían en el tema de la compresión sin pérdida (lossless compression). En el cual todo dato que se logre comprimir, se puede descomprimirlo y obtener TODA su información original.

Este tipo de compresión es muy útil para cuando se realizan respaldos y copias entre sistemas, y es la que más preocupa a los expositores, porque quieren que les quede muy claro al personal de "Mentes Libres".

Para esto se puede usar el comando gzip, gzip es uno de los mejores compresores del mercado, superado por el bzip2, pero gzip es mucho más rápido que el bzip2, por lo tanto, mucho más usado.

Ambos están presentes en Linux. El comando para comprimir un archivo con gzip sería:

gzip archivo ______________________________________________________________

el gzip no conserva el archivo original, es decir, al terminar de comprimir "archivo" lo borrará y en el disco nos quedará un "archivo.gz" el cual será una copia comprimida de éste.

Para el bzip2 se puede usar el mismo formato:

bzip2 archivo _____________________________________________________________

en este caso, tampoco se conservaría la copia del archivo.

gzip tiene otros switches interesantes que igual pueden aplicarse al bzip2: ____________

gzip -9 archivo ___________________________________________________________

intentará comprimir el archivo con un árbol de compresión de 9 pisos de profundidad, por lo que logrará una mayor compresión, a un costo de un mayor consumo de recursos y, por lo tanto, tardará en la compresión.

Por defecto gzip comprime con un nivel 6. La diferencia entre 6 y 9 es poco apreciable en el orden de un 1 a 5% más de compresión de un archivo. Pero el costo de usar 9 en recursos es muy alto, por lo que sólo se debe usar el -9 si se sabe que la máquina dispone de recursos y no será afectado el proceso.

Uno de los expositores puso este ejemplo: "Uso el -9 para hacer copias permanentes

(de esas que no abriré en muchos meses) pero nunca lo uso para hacer copias diarias de mis respaldos

pues eso demora mucho".

gzip -d archivo.gz _________________________________________________________ Esto abrirá un archivo comprimido con gzip. También podemos usar

gunzip archivo.gz

para descomprimir.

gzip -t archivo.gz __________________________________________________________ Probará la integridad (test) de un archivo comprimido para saber si está bien copiado. Si no se obtiene respuesta al ejecutar -t, esto es que el archivo está bien. Si dice algo relativo a crc error, el archivo está mal comprimido y no podremos recuperarlo.

cat archivo | gzip -c - > archivo.gz ____________________________________________ Este comando lo que hará será un cat (vaciado de un archivo) y lo pasará a la entrada estándar del gzip. Este lo tomará de la entrada estándar (-) y lo mandará hacia la salida estándar (-c) y en la salida estándar lo redirigiremos a un archivo.

Esta es una forma de conservar el archivo original mientras se comprime.

21

TAREA: Comprimamos un archivo con gzip y con bzip2 sin perder el original. Y verifiquemos cuál de los

dos comprimidos es mejor. [root@eperez ~]# mkdir t

[root@eperez ~]# cat Deber1.doc | gzip -9c - > tmp/Deber.doc.gz9 [root@eperez ~]# cat

Deber1.doc | gzip -c - > tmp/Deber.doc.gz [root@eperez ~]# cat Deber1.doc | bzip2 -c - >

tmp/Deber.doc.bz2 [root@eperez ~]# cd tmp [root@eperez tmp]# ll total 24

-rw-r--r-- 1 root root 6806 Aug 16 19:19 Deber.doc.bz2 -rw-r--r-- 1 root root 6335 Aug 16 19:19 Deber.doc.gz

-rw-r-r- 1 root root 6273 Aug 16 19:19 Deber.doc.gz9 _____________________________

Al día, siguiente un expositor explicó cómo había hecho él la tarea: "En fin, el que gana en mi caso es el gzip -9 (era de esperar). El bzip2 no fue bueno porque es un archivo muy pequeño (Deber1.doc realmente tiene 57k). El algoritmo bzip2 es muy bueno para archivos grandes o medianamente grandes. Pero para pequeños no se diferencia del gzip."

El expositor aclaró que, aunque gzip y bzip2 permiten comprimir varios archivos a la vez, no lo usa normalmente y, añadió que después, explicaría otra forma más precisa de comprimir directorios y múltiples archivos en un sólo paquete.

5.7 Trabajo con imágenes y CD

Muchas veces se necesita realizar copias completas de un disco duro, bit por bit. Los objetivos son variados:

• Necesidad de clonar un disco hacia otra máquina

• Guardar una imagen de un disco para análisis forénsico

• Replicaciones en masa del mismo sistema (Un expositor dijo lo siguiente para aclarar este punto:

"Supongamos que estamos vendiendo 500 máquinas con Linux y que queremos ponerle la misma

información a todas. Aparte de que sería sumamente egoísta de su parte el no invitarme a participar

en esta licitación tan grande, sería muy lento el proceso de instalar cientos o decenas de máquinas

con Linux".)

• Necesidad de realizar una copia exacta de un CD, para quemarlo posteriormente.

• Necesidad de realizar una copia exacta de un floppy pues se requiere usar un floppy y este, que

contiene un sistema muy especial, es el único que tenemos para formatear.

Los expositores preguntaron: "En todos esto casos... ¿Qué comando podemos usar? Bueno, Linux tiene un

comando que se ocupa de realizar copias en crudo (raw) de discos completos o particiones. Se llama dd"

dd

El dd requiere básicamente de dos parámetros, uno es el dispositivo o archivo de entrada y otro es el dispositivo o archivo de salida. Por ejemplo, cómo se realiza una copia exacta de la partición /dev/hda1:

dd if=/dev/hda1 of=/root/imagenhda1.img ______________________________________

Por supuesto, /root no debe estar en /dev/hda1 sino se caería en un ciclo infinito. No hay que olvidar que, if

y of (que se leen como input file, output file) siempre deben estar en particiones diferentes.

22

El dd en este caso tardará un poco, dependiendo de la cantidad de información que tenga hda1 y de la

velocidad de lectura y escritura del sistema.

El archivo imagenhda1.img quedará con una copia exacta de hda1 en el momento que se tomó. Se puede borrar con confianza hda1, también producir errores en hda1, o lo que se quiera, y ue exite una copia.

Uno de los del grupo del personal de laboratios preguntó: "¿Podemos reponer esa copia cuando queramos,

cómo se repone la info?

Los expositores pusieron lo siguiente en el pizarrón y explicaron:

dd if=/root/imagenhda1.img of=/dev/hda1 ______________________________________

"Aquí estamos trayendo la imagen que anteriormente sacamos hacia la partición

hda1.

Las imágenes las podemos comprimir para ahorrar espacio en disco, de esta forma la podremos guardar en menor espacio y sólo abrirlas si las necesitáramos.

Ahora, al crear una imagen, puede que la partición de destino no tenga el espacio suficiente, ¿qué podemos hacer?

Podemos intentar comprimir los datos que saca dd, de forma tal que lo que escribamos a disco vaya comprimido y ahorremos espacio.

[root@eperez ~]# dd if=/dev/hda1 | gzip -c - > boot.img.gz 208782+0 records in

208782+0 records out ______________________________________________________ dd if=/dev/hda1 : hazte una imagen de /dev/hda1. Como no especificamos of, entonces el dd sacará los datos de la imagen por la salida estándar. Con el comando | capturamos esta salida y se la pasamos a: gzip -c - > boot.img.gz : comprime lo que recibas de la entrada estándar (-) y mándalo (>) hacia un archivo llamado boot.img.gz

Para crear una partición partiendo de una imagen comprimida se puede usar:

gzip -dc boot.img.gz | dd of=/dev/hda1_________________________________________

Tarea: Comparemos la compresión con bzip2 y gzip2

[root@eperez ~]# dd if=/dev/hda1 | gzip -9c - > boot.img.gz [root@eperez ~]# dd if=/dev/hda1 | bzip2 -c - >

boot.img.bz2 [root@eperez ~]# ll boot*

-rw-r--r-- 1 root root 72863762 Aug 16 19:48 boot.img.bz2

-rw-r--r-- 1 root root 72984867 Aug 16 19:46 boot.img.gz

Un expositor contó lo siguiente "En mi caso el bzip2 se demoró mucho más que el gzip. y sí comprimió un

poquito mejor (unos 100kb menor) que el gzip."

Además los expositores explicaron que cualquier archivo de imagen que se haya creado con dd, desde una partición, es posible montarlo así mismo desde la imagen. Esto se puede hacer por medio de un artilugio que existe en Linux llamado loop (lazos). Mediante los lazos se puede montar imágenes hechas con dd y leer desde ellas. Como ejemplo, lo expositores dieron los siguientes pasos:

Primero se hace una imagen:

23

[root@eperez ~]# dd if=/dev/hda1 of=boot.img 208782+0 records in

208782+0 records out

Después se crea un directorio donde se montará esta imagen (en este caso se hará en /mnt/loop) y

posteriormente se montará la imagen en este directorio. [root@eperez ~]# mkdir /mnt/loop

[root@eperez ~]# mount -o loop ./boot.img /mnt/loop/

Como se ve, se ha llamado al comando mount pero con una opción llamada loop

(lazo). Loop es la que permite montar imágenes en directorios.

Si se entra en /mnt/loop y se crea un directorio, no habrá ningún problema, porque es una imagen creada de

un disco y permitirá que se cambie.

[root@eperez ~]# cd /mnt/loop/

[root@eperez loop]# ll total 2587

-rw-r--r-- 1 root root 48299 Jun 8 17:39 config-2.6.9-11.EL

drwxr-xr-x 2 root root 1024 Aug 15 22:58 grub

-rw-r--r-- 1 root root 395477 Jul 22 17:21 initrd-2.6.9-11.EL.img

drwx- 2 root root 12288 Jul 21 11:28 lost+found

-rw-r--r-- 1 root root 10213 Feb 26 12:39 message -rw-r--r-- 1 root root 10213

Feb 26 12:39 message.ja -rw-r--r-- 1 root root 715755 Jun 8 17:39 System.map-

2.6.9-11.EL -rw-r--r-- 1 root root 1435513 Jun 8 17:39 vmlinuz-2.6.9-11.EL

[root@eperez loop]# mkdir t [root@eperez loop]# ll total 2588

-rw-r--r-- 1 root root 48299 Jun 8 17:39 config-2.6.9-11.EL drwxr-xr-x 2 root

root 1024 Aug 15 22:58 grub -rw-r--r-- 1 root root 395477 Jul 22 17:21 initrd-

2.6.9-11.EL.img

drwx- 2 root root 12288 Jul 21 11:28 lost+found

-rw-r--r-- 1 root root 10213 Feb 26 12:39 message

-rw-r--r-- 1 root root 10213 Feb 26 12:39 message.ja

-rw-r~r~ 1 root root 715755 Jun 8 17:39 System.map-2.6.9-11.EL

drwxr-xr-x 2 root root 1024 Aug 16 19:57 t

-rw-r~r~ 1 root root 1435513 Jun 8 17:39 vmlinuz-2.6.9-11.EL

[root@eperez loop]# cd

[root@eperez ~]# umount /mnt/loop

¿Y de qué sirve usar loops?"

• Pues que podemos ver los contenidos de un CD sin tener que quemarlo (usando imágenes),

• Podemos ver los contenidos de una imagen de una partición sin tener que quemarla.

24

• Podemos analizar los contenidos de una imagen para realizar un análisis forénsico, sin tener que

ejecutar los contenidos de esta partición y, además, podemos ya tener activo el disco sobre el que

sacamos la imagen, disminuyendo el downtime.

• Podemos realizar cambios en la imagen para entonces sí quemarla (digamos que crear un directorio

o agregar archivos, etc.).

5.7.1 Clonación de floppies:

Los expositores dijeron: "Supongamos que queremos guardar una imagen de un floppy para poder usar el medio físico. Después podríamos recuperar la información de la imagen en otro medio cuando nos haga falta.

dd if=/dev/fd0 of=floppy.img _________________________________________________

Esto sacaría una imagen del floppy. También la podemos montar con un loop, e,

igual, posteriormente podríamos crear una copia exacta del floppy:

dd if=floppy.img of=/dev/fd0 _________________________________________________

Así podemos mantener copias exactas de nuestros floppies y recuperarlas cuando

deseemos hacia cualquier otro floppy."

5.7.2 Clonación de CDs

Lo mismo se puede hacer para clonar un CD dd if=/dev/cdrom of=cdrom.img

Lo expositores aclararon: "cuando clonemos los CDs también podremos montarlos con loop, pero los CDs

usan un formato llamado iso9660 que no permite escrituras, por lo que sólo podríamos leer desde el loop,

mas no escribir".

5.7.3 Creación de CDs propios

¿Y cómo podemos crear nuestros propios CDs?, preguntó un asistente del grupo de "Mentes Libres"

Los expositores le respondieron que para eso se puede usar un comando llamado mkisofs, que toma los

datos de un directorio indicado por nosotros, y crea un archivo .img que igualmente se puede montar o

quemar. Para ello hay que tener en cuenta lo siguiente:

-J : Crear en formato Joliet (usado normalmente para los CDs de windows) -v : Ser verbose (hablador), dar bastante información de lo que hace -o archivo : Crear la imagen con este nombre rh9.img (por ejemplo) y especificar el directorio de donde creará la imagen (por ejmplo: rh9/, tomará de este directorio todos los archivos y directorios de donde creará la imagen)

[root@eperez ~]# mkisofs -J -v -o rh9.img rh9/ Warning: creating filesystem with

(nonstandard) Joliet extensions but without (standard) Rock Ridge extensions. It is

highly recommended to add Rock Ridge INFO: UTF-8 character encoding detected by

locale settings. Assuming UTF-8 encoded filenames on source filesystem, use -input-

charset to override. mkisofs 2.01 (i686-pc-Linux-gnu) Scanning rh9/

Unknown file type (unallocated) rh9/.. - ignoring and continuing.

Using KERNE000.RPM;1 for /kernel-smp-2.4.20-31.9.i686.rpm (kernel-source-2.4.20-

43.9.legacy.i386.rpm)

Using KERNE001.RPM;1 for /kernel-source-2.4.20-43.9.legacy.i386.rpm (kernel- smp-2.4.20-43.9.legacy.i686.rpm)

25

Writing: Initial Padblock Start Block 0

Done with: Initial Padblock Block(s) 16

Writing: Primary Volume Descriptor Start Block 16

Done with: Primary Volume Descriptor Block(s) 1

Writing: Joliet Volume Descriptor Start Block 17

Done with: Joliet Volume Descriptor Block(s) 1

Writing: End Volume Descriptor Start Block 18

Done with: End Volume Descriptor Block(s) 1

Writing: Version block Start Block 19

Done with: Version block Block(s) 1

Writing: Path table Start Block 20

Done with: Path table Block(s) 4 Writing: Joliet path table Start Block 24 Done with: Joliet path table Block(s)

4 Writing: Directory tree Start Block 28 Done with: Directory tree Block(s) 1 Writing: Joliet directory tree Start

Block 29 Done with: Joliet directory tree Block(s) 1 Writing: Directory tree cleanup Start Block 30 Done with:

Directory tree cleanup Block(s) 0 Writing: The File(s) Start Block 30 15.00% done, estimate finish Tue Aug

16 18:20:55 2005 29.99% done, estimate finish Tue Aug 16 18:20:52 2005 44.95% done, estimate finish Tue

Aug 16 18:20:53 2005 59.96% done, estimate finish Tue Aug 16 18:20:54 2005 74.92% done, estimate

finish Tue Aug 16 18:20:53 2005 89.91% done, estimate finish Tue Aug 16 18:20:53 2005 Total translation

table size: 0 Total rockridge attributes bytes: 0 Total directory bytes: 212 Path table size(bytes): 10 Done

with: The File(s) Block(s) 33193 Writing: Ending Padblock Start Block 33223 Done with: Ending Padblock

Block(s) 150 Max brk space used 0

33373 extents written (65 MB)

Hasta el momento lo que se habrá hecho será crear una imagen iso9660, que se

podrá quemar en un CD.

Ahora hay que montar esta imagen que se acaba de quemar para verificarla:

[root@eperez ~]# mount -o loop ./rh9.img /mnt/loop/ ____________________________

Se listan los contenidos:

[root@eperez ~]# ls /mnt/loop/ kernel-smp-2.4.20-31.9.i686.rpm kernel-smp-2.4.20-43.9.legacy.i686.rpm

kernel-source-2.4.20-43.9.legacy.i386.rpm

Y se obtiene EXACTAMENTE lo que había en el directorio rh9/ (que es directorio

creado como ejemplo).

Para que todo quedara más claro, lo expositores propusieron lo siguiente: "Intentemos crear un directorio (t)

dentro de esa imagen: [root@eperez ~]# mkdir /mnt/loop/t

mkdir: cannot create directory 7media/loop/t': Read-only file system

Correcto, nos dice que no; pues la imagen es del tipo iso9660 y es de sólo lectura.

Desmontémosla, pues no debemos tener montadas las imágenes por gusto":

[root@eperez ~]# umount /mnt/loop/

TAREA: Crear una imagen iso9660

26

Para proceder a quemar, hay que usar el comando cdrecord. Este comando quema en un CD. Los switches

son variados, pero estos generalmente funcionan: -v : verbose, hablador, decir todo lo que va haciendo

speed=4 : Quemar a una velocidad de 4x, si se desea más velocidad poner el valor adecuado (8, 16, etc.)

./rh9.img : Es la imagen que se creó en el paso anterior (con mkisofs). Por supuesto, puede tener cualquier nombre.

[root@eperez ~]# cdrecord -v speed=4 ./rh9.img cdrecord: No write

mode specified. cdrecord: Asuming -tao mode.

cdrecord: Future versions of cdrecord may have different drive dependent defaults. cdrecord: Continuing in 5

seconds...

Cdrecord-Clone 2.01-dvd (i686-pc-Linux-gnu) Copyright (C) 1995-2004 Jórg Schilling Note: This version is an unofficial (modified) version with DVD support Note: and therefore may have bugs that are not present in

the original. Note: Please send bug reports or support requests to http://bugzilla.redhat.com/bugzilla

Note: The author of cdrecord should not be bothered with problems in this version.

TOC Type: 1 = CD-ROM

scsidev: '/dev/cdrom'

devname: '/dev/cdrom'

scsibus: -2 target: -2 lun: -2

Linux sg driver version: 3.5.27

Using libscg version 'schily-0.8'.

cdrecord:

Warning: using inofficial libscg transport code version (schily - Red Hat-scsi-Linux-sg.c-1.83-

RH '@(#)scsi-Linux-sg.c 1.83 04/05/20 Copyright 1997 J. Schilling'). Driveropts: 'burnfree' SCSI buffer size: 64512 atapi: 1

Device type : Removable CD-ROM Version : 0

Response Format: 1 Vendor_info : 'ATAPI ' Identifikation

: 'CD-R/RW 40X12 ' Revision : '1.HB'

Device seems to be: Generic mmc CD-RW.

Using generic SCSI-3/mmc CD-R/CD-RW driver (mmc_cdr).

Driver flags : MMC-2 SWABAUDIO BURNFREE

Supported modes: TAO PACKET SAO RAW/R16 RAW/R96R

Drive buf size : 1630208 = 1592 KB

FIFO size : 4194304 = 4096 KB

Track 01: data 65 MB

Total size: 74 MB (07:25.00) = 33375 sectors Lout start: 75 MB (07:27/00) = 33375 sectors Current Secsize: 2048

ATIP info from disk:

Indicated writing power: 5 Is not unrestricted Is not erasable

Disk sub type: Medium Type B, low Beta category ( (4)

ATIP start of lead in: -11607 (97:27/18)

ATIP start of lead out: 359849 (79:59/74)

Disk type: Short strategy type (Phthalocyanine or similar)

Manuf. index: 18

Manufacturer: Plasmon Data systems Ltd.

Blocks total: 359849 Blocks current: 359849 Blocks remaining: 326474 Speed set to 706 KB/s

Starting to write CD/DVD at speed 4.0 in real TAO mode for single session.

Last chance to quit, starting real write 0 seconds. Operation starts.

Waiting for reader process to fill input buffer ... input buffer ready.

trackno=0

27

BURN-Free is ON.

Performing OPC...

Starting new track at sector: 0

Track 01: 65 of 65 MB written (fifo 100%) [buf 98%] 4.7x.

Track 01: Total bytes read/written: 68347904/68347904 (33373 sectors).

Writing time: 122.900s

Average write speed 3.6x.

Min drive buffer fill was 89%

Fixating...

Fixating time: 70.034s

cdrecord: fifo had 1077 puts and 1077 gets.

cdrecord: fifo was 0 times empty and 592 times full, min fill was 92%.

Listo. Con esto se habrá creado una compilación (imagen, mkisofs) y se habrá

quemado con cdrecord.

5.8 RESPALDOS CON TAR y STAR

5.8.1 tar La forma más común de hacer respaldos, ya sea a cinta o a disco o a cualquier medio de almacenamiento, es mediante el comando tar. En realidad es un comando antiguo, muy probado, por lo que casi siempre funciona para hacer respaldos.

tar permite realizar copias exactas, manteniendo intactos los permisos y características de los archivos. tar devuelve un archivo que contendrá, a su vez, toda la información del directorio o conjunto de directorios que hayamos respaldado. tar devuelve un sólo archivo por la simple razón de que se usaba y se usa para escribir en cinta. Como las unidades de cinta no mantienen un filesystem, se hace un poco complicado el almacenar archivos y directorios pues estos tendrían que conocer de antemano dónde estarían localizados, etc.

El tar se ocupa de guardar el orden y posición exactos de cada uno de los archivos y directorios almacenados en este archivo.tar que se crea y, por lo tanto, fácilmente se puede extraer este archivo y tomar de ahí el orden en que fueron almacenados.

El tar es muy fácil de usar. Algunos switches que se pueden usar con el tar son:

• v - La v siempre viene de verbose (ser hablador), permite que el tar hable bastante sobre lo que está

haciendo

• f - Indica el archivo tar que se va a crear o a extraer

• c - create, crear un archivo (c o x, no ambas)

• x - eXtract, extraer un archivo (c o x, no ambas)

• z - comprimir el tar que se está creando con gzip (z o j, no ambas)

28

• j - comprimir el tar que se está creando con bzip2 (z o j, no ambas)

Ejemplos del tar para crear un archivo:

tar -cf /root/etc.tar /etc

Los expositores explicaron: Esto es, crea (c) un archivo .tar hacia (f) /root/etc.tar con

todos los contenidos del directorio /etc. El tar actuará calladito pues no tenemos el v

puesto.

Este tar quedará del mismo tamaño prácticamente que el directorio /etc, pues no lo hemos comprimido sólo lo creamos (c) hacia un archivo (f) llamado /root/etc.tar

Los expositores pidieron que lo asistentes hicieran preguntas, y fueron respondiendo una a una:

¿Cómo hacer para crear un archivo comprimido? Tenemos dos

opciones, la j y la z (bzip2: j, gzip:z): tar -zcvf /root/etcyvar.tar.gz /etc

/var

¿Qué hicimos aquí?: Creamos un tar (c) comprimido (z) con gzip, le pedimos al tar que dijera (v, verbose) lo

que fuera realizando y que el archivo creado (f) lo pusiera en /root/etcyvar.tar.gz, también le indicamos DOS

directorios a poner dentro del tar (/etc y /var). Esto creará un sólo archivo (root/etcyvar.tar.gz) conteniendo

ambos directorios (/etc y /var).

¿Cómo extraer los contenidos de tar? Simple: tar -zxvf /root/etcyvar.tar.gz |

Este comando extraerá (x) un archivo tar comprimido con gzip (z), le pedirá al tar

que hable bastante (v) y el archivo desde donde procederá a extraer (f) es

/root/etcyvar.tar.gz

Al extraer, el tar no respeta el /, es decir, el tar ignora, por seguridad ese / de etc y var, a fin de que no sobrescriba nuestro propio /etc y /var. El tar extraerá pensando que el lugar donde procederá a extraer los contenidos es el directorio donde estemos parados. Así podemos recuperar respaldos hacia cualquier directorio y decidir con calma qué hacer con lo que hemos recuperado.

¿Cómo podemos recuperar una parte de lo que guardamos en tar? A veces tenemos un archivo tar muy,

muy grande, de digamos 50GB, y sólo queremos recuperar, por ejemplo, el archivo /etc/passwd. Indicamos

precisamente el directorio y nombre de archivo a recuperar. Pensemos en el archivo etcyvar.tar.gz que

creamos anteriormente:

tar -zxvf etcyvar.tar.gz etc/passwd ____________________________________________

Le hemos indicado que queremos extraer (x) información comprimida (z) en un archivo tar (f) llamado etcyvar.tar.gz y que lo que queremos extraer es un archivo llamado passwd que está dentro de etc (etc/passwd). Fíjense que quité el / del etc., porque el tar no guarda / por seguridad; así, al extraer algo no tenemos que preocuparnos que nos sobrescriba archivos o directorios de dentro de la raíz.

Lo mismo aplica si queremos extraer un directorio entero:

tar -zxvf etcyvar.tar.gz etc/ __________________________________________________

extraería TODOS los contenidos del directorio etc, pero no extraería los de var

29

(recuerden que este etcyvar.tar.gz lo creamos con los contenidos de /etc y /ver). ¿Cómo hacemos para

guardar los contenidos en una cinta?

La cinta es un dispositivo de bloques de e/s que como ya dijimos no tiene formato específicamente, lo que

hace que tengamos que referirnos a ella sin montarla, es decir, hablar directamente con el dispositivo.

La cinta se atiende mediante dos posibles dispositivos:

/dev/st0 es el que recomendamos que siempre se use. Este dispositivo permite leer y escribir en la cinta, pero además al terminar de leer/escribir, este dispositivo rebobina la cinta hacia el inicio.

/dev/nst0 este no lo recomendamos, pero en todo caso, hace lo mismo que /dev/st0 sólo que no rebobina la cinta al terminar. Esto con el fin de que, el que quiera complicarse la vida, pueda tener varios archivos tar en una misma cinta.

Entonces para escribir un tar hacia una cinta, nos aseguramos que tenemos un dispositivo de cinta instalado en nuestro servidor Linux así como que tenemos una cinta puesta en el dispositivo y ponemos:

Itar -cvf /dev/st0 /etc /var I

Esto creará un tar (c) e indicará al tar que hable (v) hacia el dispositivo (f) /dev/st0 y en ese tar incluirá /etc y /var ¡ya tenemos una forma de hacer respaldos!

¿Y por qué no comprimo?

Bueno, no somos expertos en cintas, pero la enorme mayoría de las cintas tienen sistemas de compresión de datos al vuelo incluidos en su hardware. Esto es, nosotros le pasaremos el tar sin comprimir (sin z ni j) a la cinta (/dev/st0) y el sistema de la cinta se ocupará de comprimir estos datos. Así logramos no gastar tiempo realizando la compresión nosotros (gastando ciclos de cpu) y le pasamos ese trabajo a la cinta que lo hará transparentemente.

Si nuestra cinta no realizara compresión al vuelo, entonces no está de más el ponerle z al comando tar para de una vez comprimir nosotros, y que la cinta también guarde los datos.

Comparando bzip2 con gzip nuevamente:

Los expositotres pidieron que se analizara el nivel de compresión de /etc con bz2 y con gz:

[root@eperez ~]# tar -zcf etc.tar.gz /etc [root@eperez ~]# tar -jcf etc.tar.bz2 /etc [root@eperez ~]# ll etc* -rw-r--r-- 1 root root 4828393 Aug 19 11:00 etc.tar.bz2

-rw-r~r~ 1 root root 6731130 Aug 19 10:58 etc.tar.gz

En este caso, /etc es un directorio lleno de archivos de texto mayormente, por lo que bzip2 tiene muchas más opciones para comprimir. Como se puede ver, bzip2 comprimió a unos 4.8MB mientras gzip sólo logró 6.7MB de compresión.

En resumen realizando comparaciones, el bzip2 es bueno para grandes cantidades de información de texto pero es muy lento, mientras que gzip es muy rápido y actúa muy bien para bajos niveles de compresión.

5.8.2 star

Ahora, el comando tar tiene ciertas dificultades que ya se han probado previamente. Los expositores contaron que al realizar respaldos muy grandes, tiende a dejar de responder y a veces hasta es capaz de echar la máquina al piso.

30

Al ver la cara de asombro del personal de laboratorio un expositor puntualizó: "Cuando decimos respaldos muy grandes, estamos hablando de aproximadamente 50 GB en información sumamente fraccionada (mayormente compuesta por archivos menores a 5kb) que hay que respaldar en una máquina intel dual Xeon con 2.4GHz de velocidad y 6GB de memoria así como un arreglo de discos SCSI de 570GB."

Por eso es necesario ver otro comando más moderno llamado star.

Definitivamente se ha comprobado que es, posiblemente, un 25% más rápido que el antiguo tar. El star es

más eficiente en el manejo de memoria y procesador, por lo que se han logrado controlar los problemas en

máquinas que demoraban un mundo o fallaban haciendo un respaldo con tar.

Al momento la utilidad star es la más rápida conocida que imita al tar. Se ha comprobado que puede

trabajar a velocidades superiores a 14mbit/s y que ofrece una tecnología de doble buffering que mantiene la

unidad de cinta alimentada con datos constantemente.

El star comenzó a implementarse por el año 1982 y sigue siendo un trabajo en progreso. Es muy eficiente además con respaldos mayores a 1GB y es capaz de manejar una enorme cantidad de archivos (inodos) sin mayor uso de memoria (este es un grave problema del tar: cuando hay millones de archivos, tiende a crear grandes zonas de memoria con todo el árbol de directorio y, eventualmente, la máquina puede colapsar).

El star tiene cierta compatibilidad con el tar; por ello, es capaz de abrir archivos hechos en tar.

Definitivamente por todas estas razones y muchas más, es necesario aprender el procedimiento para usar el star.

Primero, hay que verificar que se tenga el comando star en la máquina, en redhat y clones de redhat. Está en un paquete aparte que se llama star. Hay que buscar este rpm e instalarlo si es que no está instalado ya en el sistema. Este paquete no sobrescribe al tar; por eso, siguen siendo dos comandos apartes e independientes.

Seguidamente, hay que hacer el respaldo; se puede comenzar con el más simple:

star -cv f=/dev/st0 /etc /var

Con este comando se hace un respaldo (c) hablador (v) hacia el dispositivo (f) de cinta (/dev/st0).

Si se lo quiere comprimir, hay que usar además la z: star -zcv f=/dev/st0 /etc

/var

Esto lo comprimiría con gzip. Los expositores señalaron que no conocían de compresión vía bzip2 de forma directa. Es decir, el star no sabe usar bzip2 para comprimir.

Si se quiere usar un archivo en vez de cinta se puede hacer lo siguiente: star -cv f=/backup/respaldo.tar /etc

/var

y listo, crearía (c) el tar en un archivo (f) llamado /backup/respaldo.tar dentro de un directorio. No lo crearía

comprimido (no se usó la z).

Los expositores precisaron que existen otras herramientas como cpio, pero que no las analizarían pues redundarían en el tema y realmente a su entender el tar es mucho más potente.

31

¿Cómo se abre un archivo star? star -xv f=/dev/st0

abrirían (x) todos los contenidos de la cinta (f).

Si se desea solamente un directorio o archivo en específico, hay que especificarlo con el nombre al lado, sin / inicial:

star -xv f=/dev/st0 etc/passwd

este sacaría sólo /etc/passwd y nada más de todo el respaldo, lo que permitiría recuperar cierto archivo si conoce su nombre o directorio.

Los expositores concluyeron que, el star es definitivamente el recomendado para manejar grandes cantidades de archivos dispersos o respaldos mayores a 1GB. Es mucho más rápido en estas circunstancias y seguro dará menos problemas de performance.

5.9 Planificar y realizar respaldos

Realizar respaldos es una de las tareas más penosas de preparar y una de las pocas consideradas por los

administradores. Los expositores señalaron que pocos administradores se preocupan por mantener

respaldos actualizados de sus sistemas, y menos aún se ocupan de revisar si los respaldos funcionan, y a

la hora de la verdad, cuando el sistema deja de responder, ahí vienen las quejas y los lamentos.

Por esto una de las primeras tareas que todo administrador debe realizar es, precisamente, preparar algún

tipo de sistema de respaldos, de ser posibles automáticos.

Los respaldos son la última línea de defensa en la seguridad. Los expositores recalcaron que en el tema de

seguridad conviene ser bastantes repetitivos: "ya verán durante el curso cómo tomamos muchas

precauciones sobre cómo seguir asegurando nuestro sistema, esto por el hecho de que nunca hay

seguridad de más y la seguridad es en capas".

Los respaldos, en realidad, se usan cuando las otras medidas de seguridad han fallado, cuando ya no

quede más que volver a empezar desde cero y comenzar a reponer datos de nuestros respaldos.

Los respaldos también sirven para ayudar cuando un usuario o cliente de nuestro servidor ha perdido algún

dato valioso y desea que le busquemos en los respaldos una copia anterior de este.

Pasos para realizar los respaldos:

• El primer paso para realizar los respaldos es definir hacia dónde se escribirán:

1. Hacia otro disco: Es una forma rápida y fácil; tiene de bueno el que podemos recuperar un

respaldo sin tener que perder mucho tiempo pues el disco está puesto en la misma máquina o en

una máquina contigua. Tiene de inconveniente que cuando el sistema se daña, existe la posibilidad

de que también se dañe ese disco.

2. Hacia una unidad de cinta: Es el proceso más recomendado para empresas serias y tiene de

inconveniente que las cintas son un poco lentas, tanto para respaldar, como para recuperar.

Además, de vez en cuando, hay que revisar que estén guardando correctamente la información

pues tienden a dañarse.

32

3. Hacia un CD: Tiene de inconveniente que posteriormente al respaldo hacia un directorio en el disco,

hay que preparar un iso con mkisofs y quemar ese ISO con cdrecord. Pero es una variante factible.

• El segundo paso será definir cada cuánto tiempo realizaremos los respaldos.

Esto dependerá mucho de las políticas de la empresa donde se trabaje y del tiempo que demoran los respaldos. Hay muchas empresas que realizan respaldos diarios y guardan copias de al menos 7 o 15 días de los respaldos, para poder buscar información.

Otras empresas no pueden realizar respaldos diarios, pues estos demoran mucho tiempo (digamos 12 horas) y consumiría muchos recursos el realizar respaldos cada día. Por eso, algunas empresas prefieren realizar respaldos semanales o aún quincenales o mensuales. Estos dos últimos se realizan, sobre todo, cuando el sistema no cambia en mucho tiempo.

Algunos sistemas son sencillamente inmutables en el tiempo; esto es, una vez instalados no reciben ni guardan en disco información que cambie en el tiempo, por lo que crear una sola vez un respaldo con la configuración del sistema normalmente es suficiente para ellos. Estos sistemas son mayormente sistemas de firewall o proxy que no varían sus datos de configuración ni de uso durante el tiempo y que, en caso de una rotura que requiera de restablecer un respaldo, sólo con la configuración del sistema bastaría.

• El tercer paso sería definir qué directorios y archivos se desean respaldar.

Esto depende mucho del tipo de sistema en que se está trabajando. Como ejemplo, los expositores

tabularon diferentes tipos de sistemas y qué consideraron apropiado respaldar en cada uno de ellos. Para

hacer todo más fácil repartieron una hoja con estos datos, en el que, en primer lugar había una advertencia

que el equipo del personal de laboratorio leyó con cuidado:

Hemos de advertir que esto no debe tomarse como una receta, y si ustedes o su empresa tienen

otras políticas o requieren de otros sistemas a respaldarse, deben respaldarlos de la forma más

conveniente a sus necesidades.

Tipo de sistema Qué sugerimos respaldar?

Mailserver /etc

/var/spool

/var/log

/home

/root

Proxy y/o firewall /etc

Web server /etc

/var/www

/home

/root

BD /etc /home

/directoriodelaBD dump (vaciado) de las BD

DNS /etc /home /var/named

En Linux, normalmente, no se respaldan los binarios, si nos fijamos en la tabla anterior, siempre hemos escogido los directorios donde se conservan datos valiosos e irrecuperables para nuestra empresa. Los

33

binarios y librerías del sistema siempre se reinstalan al reinstalar el sistema, por lo tanto, son recuperables; pero no son recuperables, sin un respaldo, datos como nombres de usuarios, páginas web, bases de datos, en fin, todo tipo de información específica para nuestra empresa que no está presente en un sistema Linux por defecto.

Si nos fijamos bien, uno de los directorios que siempre está presente es /etc, pues es aquí donde siempre se almacenan las claves y datos esenciales de configuración del sistema y siempre, a ojos cerrados, debemos siempre incluir /etc en nuestros respaldos para mantener una copia de toda la info esencial del sistema. Otro directorio que nunca hay que olvidar respaldar, así sea necesario o no, es /home, para mantener de una vez los directorios de los usuarios ya sean miles o sean unos 2 ó 3. Así poder realizar una recuperación rápida sin tener que crear estos directorios.

5.9.1 Definir cómo respaldar

Es algo más que importante y es qué utilería se usará para respaldar. Cualquiera de las dos anteriormente descritas (tar y star) son buenas, igual si se tiene la oportunidad o el interés se puede echar a andar el rsync que permite sincronizar directorios entre dos servidores.

Una forma cómoda sería por ejemplo respaldar a otro directorio usando tar:

tar -zcf /otrodiscomontadoaqui/respaldo.tar.gz /etc /home /var/spool /var/log ___________

Este ejemplo realizaría un respaldo en un disco montado en un directorio (llamado en nuestro caso: /otrodiscomontadoaqui) de los directorios /etc /home /var/spool y /var/log

Al hacer respaldos no se debe usar v porque puede resultar una cantidad de información tediosa de leer, confusa y puede conducir a que no se noten las diferentes advertencias que el tar quiera comunicar.

5.9.2 Verificar respaldos

Una vez finalizado de realizar los respaldos, se debe verificar que estos se estén creando correctamente. La forma más usual es probando que esté correctamente comprimido o guardado el respaldo (usando -t en el gzip o abriendo totalmente el respaldo) y, sobre todo, verificando que todos los contenidos de nuestros directorios respaldados estén intactos.

Para eso, básicamente, los expositores sugirieron que hay que abrir el paquete y verificarlo todo.

Esta labor debe realizarse de vez en cuando. Siempre es bueno, al realizar respaldos, hacer comprobaciones de restauraciones (restores) de vez en cuando. Esto permite estar seguros de que nada ha afectado la política de realización de respaldos y poder reaccionar prontamente ante una falla por algún cambio en el sistema.

5.9.3 ¿Cómo realizar una recuperación?

Supongamos que pasó lo peor de lo peor y tenemos que reinstalar el sistema. ¿Cómo recuperamos los respaldos?

Aquí algunos pasos comunes a seguir para recuperar la información:

1. Tratar, antes de reinstalar, de guardar una imagen de nuestro sistema dañado actual. Esto lo

podemos hacer con dd posiblemente o con un tar. Básicamente con esto logramos guardar el

estado actual del sistema para posterior análisis y hasta logramos tener un respaldo del último

instante en que el sistema estuvo funcionando.

34

2. Reinstalar normalmente el sistema Linux: asegurarlo, optimizarlo, actualizarlo y realizar todas las

tareas previas e inmediatas posteriores a una instalación. Por supuesto, la instalación debe incluir

todos los paquetes que nosotros sabemos que requeriremos para nuestro trabajo normal con el

sistema.

3. Traer de otro disco o de la cinta o del CDrom los tar con los respaldos

4. Abrir estos respaldos hacia un directorio temporal (normalmente se abren en /home/tmp o en

/root/tmp, en la partición que tenga más espacio), para esto hay que cambiarse primero al directorio

donde se abrirán los respaldos (cd /home/tmp por ejemplo) y después abrirlos para tenerlos todos

ahí.

5. Los directorios: /home, /var/spool y /var/www normalmente se pueden copiar hacia sus destinos de forma inmediata. Es decir, una vez abiertos en /home/tmp/var/spool, se puede, por ejemplo:

cp -a /home/tmp/var/spool/* /var/spool/

pues estos directorios no afectan en nada el funcionamiento actual de nuestro nuevo sistema.

6. Del directorio /etc, como sugerencia, solamente trabajeromos con /etc/passwd, /etc/shadow y

/etc/group. Por supuesto, si se quiere la copia antigua de nuestro servidor web, trabajaríamos con el

directorio de configuración web (/etc/httpd/) y lo mismo con cada demonio que requiramos

(/etc/squid para el squid, /etc/named* para el named). La idea con /etc es solamente tomar del

directorio recuperado los archivos que necesitemos y de ser posible no sobrescribamos los archivos

recién instalados sino que los unamos o manualmente editemos (El etc recuperado deberá estar en

/home/tmp/etc pues recuerden. siempre nos debemos cambiar al directorio /home/tmp para abrir los

respaldos)

7. Recuperar y poner en su lugar todos los archivos que necesitemos según el caso.

La recuperación en Linux es un proceso que no es difícil. Aquí no trabajamos con registros ni ningún tipo de información complicada, sino que sencillamente trabajamos con archivos de texto que son muy fáciles de reemplazar o de editar para agregar la nueva información.

Por ejemplo, para recuperar los usuarios se puede: editar el archivo passwd que estará en /home/tmp/etc y borrar todos los usuarios privilegiados (esos que el UID sea menor a 500), de forma tal que quedará un archivo passwd solamente con los usuarios propios de mi empresa (los que hemos creado y su UID es igual o mayor que 500). Una vez guardado ese passwd podemos proceder a unirlo:

Icat /home/tmp/etc/passwd >> /etc/passwd I

Aquí lo que habremos hecho será agregar (>>) al archivo /etc/passwd, los contenidos de /home/tmp/etc/passwd, que es el archivo al que hemos eliminado los usuarios privilegiados (esos ya están presentes en /etc/passwd al instalarlo nuevo). De esta forma nos queda original y adaptado a nuestro sistema.

Lo mismo debemos hacer con group y con shadow (eliminar los usuarios propios del sistema y solamente

dejar los usuarios que hemos creado nosotros, los usuarios con UID mayor de 500)

35

Y ¡listo! ya pasamos el problema mayor. Ahora, por supuesto, pasaremos por algunos otros problemas, pues

siempre ocurren al realizar una recuperación, lo normal es que se nos olvide instalar algún paquete que sí

usábamos antes, o que se nos olvide activar o reconfigurar algún servicio. Poco a poco, con el transcurso

de los minutos nos iremos dando cuenta, gracias a nuestras propias averiguaciones o a los usuarios

mismos, que vendrán a quejarse.

Un detalle a considerar: siempre es importante, antes de sobrescribir un archivo de los recién instalados (por

ejemplo /etc/passwd o /etc/group o cualquier otro), realizar una copia de seguridad de este. Se puede hacer

copiando el archivo con la extensión .bak:

cp /etc/passwd /etc/passwd.bak

Así, si algo fallara en nuestro nuevo sistema, podemos, al menos, recuperar el archivo original que recién

habíamos instalado y proceder a tomar otra variante para reconfigurarlo.

5.9.4 mt

mt es una utilería para trabajo con cintas. Aunque no es requerido usarlo al realizar respaldos, sí es importante

conocer qué ayudas puede brindar.

mt se debe invocar con el nombre del dispositivo de cinta al que nos estamos refiriendo (normalmente /dev/st0)

y un comando que le deseamos enviar a la cinta.

El comando mt puede demorarse en dar una respuesta y no se debe detener si notamos que no está

respondiendo, pues, a veces, tarda horas.

mt -f /dev/st0 status

mt -f /dev/st0 eject mt -f /dev/st0 retension mt -f

/dev/st0 erase mt -f /dev/st0 rewind

Fin del capítulo.